sap-ai-dev-toolkit 0.9.7 → 0.9.8

package/package.json

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

@@ -212,10 +212,16 @@ async function configuredLocalSapGuiDestination(env) {
     let url = env.SAP_URL;
     // SAP GUI landscapes carry no HTTP port, and the SSO browser cannot sign in on a guessed one.
     if (!hasExplicitPort(url)) {
-      const detected = await detectLocalAdtUrl({ url, client }).catch(() => '');
+      const host = new URL(url).hostname;
+      logLine(`[sap-ai-dev] ${name}: SAP_URL has no port; port scan in progress on ${host} (usual ADT ports)`);
+      let detected = await detectLocalAdtUrl({ url, client }).catch(() => '');
+      if (!detected) {
+        logLine(`[sap-ai-dev] ${name}: no ADT port on the usual ports; port scan in progress on every conventional SAP port of ${host} (can take a minute)`);
+        detected = await detectLocalAdtUrl({ url, client, exhaustive: true }).catch(() => '');
+      }
       logLine(detected
-        ? `[sap-ai-dev] ${name}: SAP_URL has no port; ADT answers at ${detected}`
-        : `[sap-ai-dev] ${name}: SAP_URL has no port and no ADT port answered on ${new URL(url).hostname}; add the port to SAP_URL or rerun sap-ai-dev --setup`);
+        ? `[sap-ai-dev] ${name}: port scan finished; ADT answers at ${detected}`
+        : `[sap-ai-dev] ${name}: port scan finished; no ADT port answered on ${host}; add the port to SAP_URL or rerun sap-ai-dev --setup`);
       url = detected || url;
     }
     return {

package/src/local-sap-gui.mjs

@@ -409,10 +409,14 @@ export function hasExplicitPort(url) {
 
 // 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, env = process.env, timeoutMs = 60_000 } = {}) {
+export async function detectAdtUrl(binary, { url, client, env = process.env, exhaustive = false, ports = [], timeoutMs = 180_000 } = {}) {
   let configured;
   try { configured = new URL(url); } catch { return ''; }
-  const args = ['detect', configured.hostname.replace(/^\[(.*)\]$/, '$1'), '--json', ...(client ? ['--client', String(client)] : [])];
+  const host = configured.hostname.replace(/^\[(.*)\]$/, '$1');
+  const args = ['detect', host, '--json', ...(client ? ['--client', String(client)] : []), ...(exhaustive ? ['--all'] : []), ...ports.flatMap(port => ['--port', String(port)])];
+  // A corporate HTTPS_PROXY rarely routes internal SAP hosts; probe them directly.
+  const noProxy = [env.NO_PROXY || env.no_proxy, host].filter(Boolean).join(',');
+  env = { ...env, NO_PROXY: noProxy, no_proxy: noProxy };
   const [command, ...prefixArgs] = /\.(?:mjs|cjs|js)$/i.test(binary)
     ? [process.execPath, binary]
     : (/\.(?:cmd|bat)$/i.test(binary) && platform() === 'win32' ? ['cmd', '/c', binary] : [binary]);

package/src/setup.mjs

@@ -126,19 +126,39 @@ function localAuthenticationLabel(authMode) {
 
 // The SSO browser signs in on the ADT URL itself, and SAP GUI landscapes never
 // carry the HTTP port, so a portless URL would send it to 443.
-async function detectSsoAdtPort(destination, label, client, { output = stdout, env = process.env, detectAdtUrl } = {}) {
+async function detectSsoAdtPort(destination, label, client, { input = stdin, output = stdout, env = process.env, detectAdtUrl } = {}) {
   if (!detectAdtUrl || hasExplicitPort(destination.url)) return;
-  const stopProgress = startProgress(`Detecting the ADT port for ${label}`, { output, env, label: 'SSO' });
-  let detected = '';
-  try { detected = await detectAdtUrl({ url: destination.url, client }); }
-  catch { detected = ''; }
-  finally { stopProgress(); }
-  if (detected) {
-    destination.url = detected;
-    print(output, formatStatus(`ADT answers at ${detected}; SSO signs in there.`, 'success', output, 'SSO'));
-    return;
+  const scan = async (message, options) => {
+    const stopProgress = startProgress(message, { output, env, label: 'SSO' });
+    try { return await detectAdtUrl({ url: destination.url, client, ...options }); }
+    catch { return ''; }
+    finally { stopProgress(); }
+  };
+  print(output, formatStatus(`Port scan in progress on ${new URL(destination.url).hostname} to find the ADT port for ${label}.`, 'progress', output, 'SSO'));
+  let detected = await scan(`Detecting the ADT port for ${label}`, {});
+  if (!detected) {
+    print(output, formatStatus(`No ADT port answered on the usual ports for ${label}; port scan in progress on every conventional SAP port (this can take a minute).`, 'progress', output, 'SSO'));
+    detected = await scan(`Sweeping SAP HTTP(S) ports for ${label}`, { exhaustive: true });
+  }
+  // Nothing on the machine knows the port, so the person who does is asked until one answers.
+  while (!detected) {
+    const host = new URL(destination.url).hostname;
+    print(output, formatStatus(`No ADT port answered on ${host}. Ask basis or check SMICM (Goto > Services) for the HTTPS port.`, 'warning', output, 'SSO'));
+    const answer = String(await textPrompt({
+      message: `ADT port or URL for ${label}`,
+      placeholder: '44300 or https://host:44300',
+      validate: value => /^\d{2,5}$/.test(String(value).trim()) || validateAdtUrlCandidate(String(value).trim())
+    }, { input, output })).trim();
+    const candidate = /^\d+$/.test(answer) ? `${new URL(destination.url).origin}:${answer}` : answer;
+    const port = Number(new URL(candidate).port || (candidate.startsWith('http:') ? 80 : 443));
+    detected = await detectAdtUrl({ url: candidate, client, ports: [port] }).catch(() => '');
+    if (!detected && await confirmPrompt(`${candidate} did not answer as ADT. Use it anyway? (y/Enter=yes, n=try another)`, { input, output })) {
+      destination.url = candidate;
+      return;
+    }
   }
-  print(output, formatStatus(`No ADT port answered for ${label}; SSO keeps ${destination.url}. If the browser cannot reach it, rerun setup and enter the ADT URL with its port, for example ${new URL(destination.url).origin}:44300.`, 'warning', output, 'SSO'));
+  destination.url = detected;
+  print(output, formatStatus(`ADT answers at ${detected}; SSO signs in there.`, 'success', output, 'SSO'));
 }
 
 async function confirmPrompt(message, { input = stdin, output = stdout } = {}) {
@@ -246,7 +266,7 @@ async function runManualEntryWizard({ env = process.env, input = stdin, output =
     await maybeConfigureTlsSelfHeal(destination, name, { input, output });
     const clients = await promptSapClients(destination, { input, output });
     const authMode = await chooseLocalAuthMode(destination, { input, output, env });
-    if (authMode === 'sso') await detectSsoAdtPort(destination, name, clients[0], { output, env, detectAdtUrl });
+    if (authMode === 'sso') await detectSsoAdtPort(destination, name, clients[0], { input, output, env, detectAdtUrl });
     destination.authentication = localAuthenticationLabel(authMode);
     destination.authMode = authMode;
     for (const client of clients) {
@@ -398,6 +418,7 @@ async function chooseDiscoveredDestinations(destinations, { isBas, input = stdin
     message: colorText('🧭 Select destinations', 'cyan', output),
     choices,
     required: false,
+    searchable: true,
     shortcuts: { all: 'a' },
     actions: { m: addManually },
     confirmEmpty: 'Press Enter again to continue with none (removes this add-on’s MCP entries).'
@@ -435,7 +456,7 @@ async function chooseDiscoveredDestinations(destinations, { isBas, input = stdin
       destination.url = url || fallback;
       await maybeConfigureTlsSelfHeal(destination, promptLabel, { input, output });
       const authMode = await chooseLocalAuthMode({ ...destination, name: promptLabel }, { input, output, env });
-      if (authMode === 'sso') await detectSsoAdtPort(destination, promptLabel, clients[0], { output, env, detectAdtUrl });
+      if (authMode === 'sso') await detectSsoAdtPort(destination, promptLabel, clients[0], { input, output, env, detectAdtUrl });
       destination.authentication = localAuthenticationLabel(authMode);
       destination.authMode = authMode;
       for (const client of clients) {

package/src/terminal-ui.mjs

@@ -213,11 +213,13 @@ export async function selectPrompt({ message, choices, defaultValue } = {}, { in
   });
 }
 
-export async function checkboxPrompt({ message, choices: initialChoices, required = false, shortcuts = { all: 'a' }, actions = {}, validate, confirmEmpty = '' } = {}, { input = process.stdin, output = process.stdout } = {}) {
+export async function checkboxPrompt({ message, choices: initialChoices, required = false, shortcuts = { all: 'a' }, actions = {}, validate, confirmEmpty = '', searchable = false } = {}, { input = process.stdin, output = process.stdout } = {}) {
   if (!Array.isArray(initialChoices) || !initialChoices.length) return [];
   // Action shortcuts (for example 'm' → manual entry wizard) may append new
   // choices while the picker is open, so the list itself stays mutable.
   let choices = initialChoices;
+  let searchQuery = '';
+  let searchMode = false;
   const selectable = enabledChoices(choices);
   const selected = new Set(choices.flatMap((choice, index) => choice.checked && !choice.disabled ? [index] : []));
   let cursor = firstEnabledIndex(choices);
@@ -228,40 +230,70 @@ export async function checkboxPrompt({ message, choices: initialChoices, require
   // With confirmEmpty set, Enter on an empty selection shows it and waits for a second Enter.
   let awaitingEmptyConfirm = false;
 
+  const matchingIndexes = () => choices
+    .map((choice, index) => ({ choice, index }))
+    .filter(({ choice }) => !searchQuery || String(choice.name || '').toLowerCase().startsWith(searchQuery.toLowerCase()))
+    .map(({ index }) => index);
+  const visibleIndexes = () => {
+    const indexes = matchingIndexes();
+    if (searchable && (!indexes.includes(cursor) || choices[cursor]?.disabled)) {
+      cursor = indexes.find(index => !choices[index]?.disabled) ?? -1;
+    }
+    return indexes;
+  };
+  const moveCursor = step => {
+    if (!searchable) {
+      cursor = nextEnabledIndex(choices, cursor, step);
+      return;
+    }
+    const indexes = visibleIndexes();
+    const visibleChoices = indexes.map(index => choices[index]);
+    if (!visibleChoices.some(choice => !choice.disabled)) return;
+    const position = nextEnabledIndex(visibleChoices, indexes.indexOf(cursor), step);
+    cursor = indexes[position] ?? -1;
+  };
+
   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 ensureVisible = (pageSize, visibleCount, cursorPosition) => {
+    if (cursorPosition >= 0 && cursorPosition < top) top = cursorPosition;
+    if (cursorPosition >= top + pageSize) top = cursorPosition - pageSize + 1;
+    top = clamp(top, 0, Math.max(0, visibleCount - pageSize));
   };
   const footer = error => {
     if (error) return [[error, 'red']];
     if (awaitingEmptyConfirm) return [['Nothing is selected yet. Press Space to select the highlighted item (❯).', 'yellow'], [confirmEmpty, 'yellow']];
+    if (searchable && matchingIndexes().length === 0) return [['No choices match. Backspace or Esc clears search.', 'yellow']];
     if (!selected.size) return [['Press Space to select the highlighted item (❯), then Enter to confirm.', 'cyan']];
     return [[`${selected.size} selected. Press Enter to confirm, or Space to change.`, 'green']];
   };
   const render = (error = '') => {
     const columns = Number.isFinite(output?.columns) ? output.columns : 80;
-    const pageSize = checkboxPageSize(output, choices.length);
-    ensureVisible(pageSize);
+    const indexes = visibleIndexes();
+    const pageSize = searchable
+      ? Math.max(1, checkboxPageSize(output, indexes.length + 1) - 1)
+      : checkboxPageSize(output, indexes.length);
+    const cursorPosition = indexes.indexOf(cursor);
+    ensureVisible(pageSize, indexes.length, cursorPosition);
     const lines = [];
     lines.push(truncateToColumns(`${message} (Space: select, ${shortcuts?.all || 'a'}: toggle all, Enter: confirm)`, columns));
-    const end = Math.min(choices.length, top + pageSize);
+    if (searchable) lines.push(truncateToColumns(`Search: ${searchQuery || (searchMode ? '' : 'type a prefix; / for a or m')}`, columns));
+    const end = Math.min(indexes.length, top + pageSize);
     for (let index = top; index < end; index += 1) {
-      const choice = choices[index];
-      const pointer = index === cursor ? '❯' : ' ';
+      const choiceIndex = indexes[index];
+      const choice = choices[choiceIndex];
+      const pointer = choiceIndex === cursor ? '❯' : ' ';
       // A red ✗ for "not selected yet" was read as an error, so unselected rows show an empty box.
-      const box = choice.disabled ? '[-]' : (selected.has(index) ? colorText('[✓]', 'green', output) : '[ ]');
+      const box = choice.disabled ? '[-]' : (selected.has(choiceIndex) ? colorText('[✓]', 'green', output) : '[ ]');
       const disabled = choice.disabled ? ` — ${choice.disabled}` : '';
       lines.push(truncateToColumns(`${pointer} ${box} ${choice.name}${disabled}`, columns));
     }
-    if (choices.length > pageSize) {
-      lines.push(truncateToColumns(colorText(`  Showing ${top + 1}-${end} of ${choices.length}; use ↑/↓ to scroll.`, 'cyan', output), columns));
+    if (indexes.length > pageSize) {
+      lines.push(truncateToColumns(colorText(`  Showing ${top + 1}-${end} of ${indexes.length}; use ↑/↓ to scroll.`, 'cyan', output), columns));
     }
     for (const [text, color] of footer(error)) lines.push(truncateToColumns(colorText(`  ${text}`, color, output), columns));
     clearRendered();
@@ -328,16 +360,25 @@ export async function checkboxPrompt({ message, choices: initialChoices, require
     };
     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 === 'space' && !choices[cursor]?.disabled) {
+      else if (searchable && key.name === 'escape') {
+        searchQuery = '';
+        searchMode = false;
+        top = 0;
+      } else if (searchable && searchMode && (key.name === 'backspace' || key.name === 'delete')) {
+        searchQuery = Array.from(searchQuery).slice(0, -1).join('');
+        if (!searchQuery) searchMode = false;
+        top = 0;
+      } else if (searchable && !searchMode && String(_chunk ?? '') === '/' && !key.ctrl && !key.meta) searchMode = true;
+      else if (key.name === 'up' || (!searchable && key.name === 'k')) moveCursor(-1);
+      else if (key.name === 'down' || (!searchable && key.name === 'j')) moveCursor(1);
+      else if (key.name === 'space' && cursor >= 0 && !choices[cursor]?.disabled) {
         if (selected.has(cursor)) selected.delete(cursor);
         else selected.add(cursor);
-      } else if (shortcuts?.all && key.name === shortcuts.all) {
+      } else if ((!searchable || !searchMode) && shortcuts?.all && key.name === shortcuts.all) {
         const allSelected = enabledChoices(choices).every(choice => selected.has(choices.indexOf(choice)));
         selected.clear();
         if (!allSelected) for (const choice of enabledChoices(choices)) selected.add(choices.indexOf(choice));
-      } else if (actionShortcutFor(_chunk, key)) {
+      } else if ((!searchable || !searchMode) && actionShortcutFor(_chunk, key)) {
         awaitingEmptyConfirm = false;
         void runAction(actionShortcutFor(_chunk, key));
         return;
@@ -351,6 +392,10 @@ export async function checkboxPrompt({ message, choices: initialChoices, require
           return render();
         }
         return finish(values);
+      } else if (searchable && !key.ctrl && !key.meta && Array.from(String(_chunk ?? '')).length === 1 && !/[\u0000-\u001f\u007f]/u.test(String(_chunk))) {
+        searchMode = true;
+        searchQuery += String(_chunk);
+        top = 0;
       } else {
         return;
       }