@sap-ux/create 1.3.27 → 1.4.2

package/README.md

@@ -314,7 +314,8 @@ Options:
 - `--connection-type <string>` - Connection type (abap_catalog | generic_host | odata_service) _(default: `abap_catalog`)_
 - `--username <string>` - Username for basic authentication
 - `--password <string>` - To avoid plain-text credentials in the shell's history, pass an env reference: --password env:MY_VAR
-- `--skip-check` - Skip connection verification before saving
+- `--skip-credentials-prompt` - Skip credential prompts. No credentials will be saved, but may be added later if required
+- `--skip-connection-validation` - Skip connection verification before saving
 
 --------------------------------
 
@@ -456,7 +457,8 @@ Options:
 - `--username <string>` - New username
 - `--password <string>` - To avoid plain-text credentials in the shell's history, pass an env reference: --password env:MY_VAR
 - `--clear-credentials` - Remove stored credentials from the system
-- `--skip-check` - Skip connection verification before saving
+- `--skip-connection-validation` - Skip connection verification before saving
+- `--skip-check` - (Deprecated: use --skip-connection-validation) Skip connection verification before saving
 
 --------------------------------
 

package/dist/cli/add/system.js

@@ -6,6 +6,7 @@ import { validateClient } from '@sap-ux/project-input-validator';
 import { getLogger } from '../../tracing/index.js';
 import { promptForSystemConfig } from '../utils/system-prompts.js';
 import { checkConnectionOrPrompt } from '../utils/system-connection.js';
+import { t } from '../../i18n.js';
 /**
  * Add the "add system" subcommand to a passed command.
  * Adds a new backend system to the saved systems store (~/.fioritools).
@@ -31,7 +32,8 @@ Example:
         .option('--connection-type <string>', `Connection type (${Object.values(ConnectionType).join(' | ')})`, ConnectionType.AbapCatalog)
         .option('--username <string>', 'Username for basic authentication')
         .option('--password <string>', "To avoid plain-text credentials in the shell's history, pass an env reference: --password env:MY_VAR")
-        .option('--skip-check', 'Skip connection verification before saving')
+        .option('--skip-credentials-prompt', 'Skip credential prompts. No credentials will be saved, but may be added later if required')
+        .option('--skip-connection-validation', 'Skip connection verification before saving')
         .action(async (options) => {
         loadEnvConfig();
         await addSystem({
@@ -43,7 +45,8 @@ Example:
             connectionType: options.connectionType,
             username: options.username,
             password: options.password,
-            skipCheck: !!options.skipCheck
+            skipCredentialsPrompt: !!options.skipCredentialsPrompt,
+            skipConnectionValidation: !!options.skipConnectionValidation
         });
     });
 }
@@ -62,7 +65,7 @@ Example:
  */
 function validateSystemConfig(config, logger) {
     if (!config.name || !config.url || !config.systemType || !config.authenticationType || !config.connectionType) {
-        logger.error('Missing required fields. System was not added.');
+        logger.error('Missing required fields.');
         return false;
     }
     if (config.name.trim().length === 0) {
@@ -83,6 +86,8 @@ function validateSystemConfig(config, logger) {
             return false;
         }
     }
+    // Validate that provided type values are valid enum members
+    // (TypeScript types don't prevent invalid runtime values from CLI flags)
     const validSystemTypes = Object.values(SystemType);
     if (!validSystemTypes.includes(config.systemType)) {
         logger.error(`Invalid system type '${config.systemType}'. Valid values: ${validSystemTypes.join(', ')}`);
@@ -137,7 +142,8 @@ async function checkForDuplicates(config, service, logger) {
  * @param params.connectionType - connection type
  * @param params.username - optional username for basic auth
  * @param params.password - optional password for basic auth
- * @param params.skipCheck - skip connection verification
+ * @param params.skipCredentialsPrompt - skip credential prompts entirely
+ * @param params.skipConnectionValidation - skip connection verification
  */
 async function addSystem(params) {
     const logger = getLogger();
@@ -154,14 +160,17 @@ async function addSystem(params) {
             authenticationType: params.authenticationType,
             connectionType: params.connectionType,
             username: params.username,
-            password: params.password
+            password: params.password,
+            skipCredentialsPrompt: params.skipCredentialsPrompt
         });
         replaceEnvVariables(config);
         if (!validateSystemConfig(config, logger)) {
+            logger.info(t('systemActions.systemNotAddedInvalidConfig'));
             return;
         }
         const service = await getService({ entityName: 'system' });
         if (!(await checkForDuplicates(config, service, logger))) {
+            logger.info(t('systemActions.systemNotAddedDuplicate'));
             return;
         }
         const shouldSave = await checkConnectionOrPrompt({
@@ -169,11 +178,12 @@ async function addSystem(params) {
             client: config.client,
             systemType: config.systemType,
             authenticationType: config.authenticationType,
+            connectionType: config.connectionType,
             username: config.username,
             password: config.password
-        }, params.skipCheck || false);
+        }, params.skipConnectionValidation || false);
         if (!shouldSave) {
-            logger.info('System was not saved.');
+            logger.info(t('systemActions.systemNotSaved'));
             return;
         }
         const system = new BackendSystem({
@@ -187,7 +197,7 @@ async function addSystem(params) {
             password: config.password
         });
         await service.write(system);
-        logger.info(`System '${config.name}' added.`);
+        logger.info(t('systemActions.systemAdded', { name: config.name }));
     }
     catch (error) {
         logger.error(error.message);

package/dist/cli/get/system.js

@@ -2,6 +2,7 @@ import { isAppStudio } from '@sap-ux/btp-utils';
 import { getService, BackendSystemKey } from '@sap-ux/store';
 import { NullTransport, ToolsLogger } from '@sap-ux/logger';
 import { getLogger } from '../../tracing/index.js';
+import { findSystemByUrl } from '../utils/system-lookup.js';
 /**
  * Add the "get system" subcommand to a passed command.
  * Retrieves details of a saved backend system identified by its URL and optional client.
@@ -45,9 +46,10 @@ async function getSystem(url, client, asJson) {
             entityName: 'system',
             logger: storeLogger
         });
-        const key = new BackendSystemKey({ url, client });
-        const system = await service.read(key);
+        // Use smart lookup to handle client mismatch scenarios
+        const system = await findSystemByUrl(url, client, service);
         if (!system) {
+            const key = new BackendSystemKey({ url, client });
             logger.error(`System not found: ${key.getId()}`);
             return;
         }
@@ -78,6 +80,9 @@ async function getSystem(url, client, asJson) {
             if (system.hasSensitiveData) {
                 logger.info(`Credentials stored securely.`);
             }
+            else {
+                logger.info(`No credentials stored.`);
+            }
         }
     }
     catch (error) {

package/dist/cli/index.d.ts

@@ -4,7 +4,7 @@ import { Command } from 'commander';
  *
  * @param argv - arguments, typically 'process.argv'
  */
-export declare function handleCreateFioriCommand(argv: string[]): void;
+export declare function handleCreateFioriCommand(argv: string[]): Promise<void>;
 /**
  * Generates the full MCP specification for a top-level commander program.
  *

package/dist/cli/index.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'node:url';
 import { Command } from 'commander';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 import { getLogger } from '../tracing/index.js';
+import { initI18n } from '../i18n.js';
 import { getAddCommands } from './add/index.js';
 import { getRemoveCommands } from './remove/index.js';
 import { getGenerateCommands } from './generate/index.js';
@@ -24,12 +25,14 @@ import { getUpdateCommands } from './update/index.js';
  *
  * @param argv - arguments, typically 'process.argv'
  */
-export function handleCreateFioriCommand(argv) {
+export async function handleCreateFioriCommand(argv) {
     const logger = getLogger();
     if (!Array.isArray(argv) || argv.length < 2) {
         throw Error(`This function must be called from command line interface (cli). Or provide meaningful arguments.`);
     }
     try {
+        // Initialize i18n before executing commands
+        await initI18n();
         const program = getCommanderProgram();
         program.parse(argv);
     }

package/dist/cli/remove/system.js

@@ -2,6 +2,8 @@ import { isAppStudio } from '@sap-ux/btp-utils';
 import { getService, BackendSystemKey } from '@sap-ux/store';
 import { getLogger } from '../../tracing/index.js';
 import { promptForSystemIdentifier, promptForRemoveConfirmation } from '../utils/system-prompts.js';
+import { findSystemByUrl } from '../utils/system-lookup.js';
+import { t } from '../../i18n.js';
 /**
  * Add the "remove system" subcommand to a passed command.
  * Removes a saved backend system from the store (~/.fioritools) and deletes its credentials from the OS keychain.
@@ -39,9 +41,10 @@ async function removeSystem(url, client, force) {
         // Prompt for system identifier if not provided
         const identifier = await promptForSystemIdentifier({ url, client });
         const service = await getService({ entityName: 'system' });
-        const key = new BackendSystemKey({ url: identifier.url, client: identifier.client });
-        const system = await service.read(key);
+        // Use smart lookup to handle client mismatch scenarios
+        const system = await findSystemByUrl(identifier.url, identifier.client, service);
         if (!system) {
+            const key = new BackendSystemKey({ url: identifier.url, client: identifier.client });
             logger.error(`System not found: ${key.getId()}`);
             return;
         }
@@ -55,9 +58,10 @@ async function removeSystem(url, client, force) {
         }
         const deleted = await service.delete(system);
         if (deleted) {
-            logger.info(`System '${system.name}' removed.`);
+            logger.info(t('systemActions.systemRemoved', { name: system.name }));
         }
         else {
+            const key = new BackendSystemKey({ url: system.url, client: system.client });
             logger.error(`Failed to remove system: ${key.getId()}`);
         }
     }

package/dist/cli/update/system.js

@@ -3,8 +3,10 @@ import { getService, BackendSystemKey, isSystemNameInUse } from '@sap-ux/store';
 import { replaceEnvVariables } from '@sap-ux/ui5-config';
 import { config as loadEnvConfig } from 'dotenv';
 import { getLogger } from '../../tracing/index.js';
-import { promptForSystemIdentifier, promptForUpdateFields, promptForFieldUpdates } from '../utils/system-prompts.js';
+import { promptForSystemIdentifier, promptForUpdateFields, promptForFieldUpdates, ClearCredentialsCancelledError } from '../utils/system-prompts.js';
 import { checkConnectionOrPrompt } from '../utils/system-connection.js';
+import { findSystemByUrl } from '../utils/system-lookup.js';
+import { t } from '../../i18n.js';
 /**
  * Add the "update system" subcommand to a passed command.
  * Updates an existing backend system in the saved systems store (~/.fioritools).
@@ -26,7 +28,8 @@ Example:
         .option('--username <string>', 'New username')
         .option('--password <string>', "To avoid plain-text credentials in the shell's history, pass an env reference: --password env:MY_VAR")
         .option('--clear-credentials', 'Remove stored credentials from the system')
-        .option('--skip-check', 'Skip connection verification before saving')
+        .option('--skip-connection-validation', 'Skip connection verification before saving')
+        .option('--skip-check', '(Deprecated: use --skip-connection-validation) Skip connection verification before saving')
         .action(async (options) => {
         loadEnvConfig();
         await updateSystem({
@@ -36,7 +39,7 @@ Example:
             username: options.username,
             password: options.password,
             clearCredentials: !!options.clearCredentials,
-            skipCheck: !!options.skipCheck
+            skipConnectionValidation: !!options.skipConnectionValidation || !!options.skipCheck
         });
     });
 }
@@ -103,7 +106,25 @@ async function determinePatch(params, existing, logger) {
         return await buildPatchFromParams(params, existing, logger);
     }
     const fieldsToUpdate = await promptForUpdateFields(existing);
-    return await promptForFieldUpdates(fieldsToUpdate, existing);
+    let updateValues;
+    try {
+        updateValues = await promptForFieldUpdates(fieldsToUpdate, existing);
+    }
+    catch (err) {
+        // User cancelled credential clearing operation
+        if (err instanceof ClearCredentialsCancelledError) {
+            logger.info(t('systemActions.operationCancelled'));
+            return null;
+        }
+        throw err;
+    }
+    // Check if clearCredentials was selected in interactive mode
+    if (updateValues.clearCredentials) {
+        updateValues.username = '';
+        updateValues.password = '';
+        delete updateValues.clearCredentials;
+    }
+    return updateValues;
 }
 /**
  * Verifies connection if credentials are being updated.
@@ -112,22 +133,35 @@ async function determinePatch(params, existing, logger) {
  * @param existing - existing system
  * @param params - update parameters
  * @param params.clearCredentials - whether credentials are being cleared
- * @param params.skipCheck - whether to skip connection check
+ * @param params.skipConnectionValidation - whether to skip connection check
  * @returns true if should proceed, false otherwise
  */
 async function verifyCredentialsUpdate(patch, existing, params) {
-    const updatingCredentials = patch.username !== undefined || patch.password !== undefined;
-    if (!updatingCredentials || params.clearCredentials) {
+    // Check if credentials are being updated (set to new values or cleared)
+    const hasUsernameChange = patch.username !== undefined;
+    const hasPasswordChange = patch.password !== undefined;
+    const updatingCredentials = hasUsernameChange || hasPasswordChange;
+    // Skip verification if:
+    // 1. No credential changes at all, OR
+    // 2. Explicitly clearing credentials (--clear-credentials flag), OR
+    // 3. Setting both to empty strings (clearing via interactive prompts)
+    if (!updatingCredentials) {
+        return true;
+    }
+    const clearingCredentials = params.clearCredentials || (patch.username === '' && patch.password === '');
+    if (clearingCredentials) {
         return true;
     }
+    // Otherwise, verify the new credentials work
     return await checkConnectionOrPrompt({
         url: existing.url,
         client: existing.client,
         systemType: existing.systemType,
         authenticationType: existing.authenticationType || 'basic',
+        connectionType: existing.connectionType,
         username: patch.username ?? existing.username,
         password: patch.password ?? existing.password
-    }, params.skipCheck || false);
+    }, params.skipConnectionValidation || false);
 }
 /**
  * Updates a backend system in the saved systems store.
@@ -139,7 +173,7 @@ async function verifyCredentialsUpdate(patch, existing, params) {
  * @param params.username - optional new username
  * @param params.password - optional new password
  * @param params.clearCredentials - if true, clears stored credentials
- * @param params.skipCheck - skip connection verification
+ * @param params.skipConnectionValidation - skip connection verification
  */
 async function updateSystem(params) {
     const logger = getLogger();
@@ -153,28 +187,32 @@ async function updateSystem(params) {
             client: params.client
         });
         const service = await getService({ entityName: 'system' });
-        const key = new BackendSystemKey({ url: identifier.url, client: identifier.client });
-        const existing = await service.read(key);
+        // Use smart lookup to handle client mismatch scenarios
+        const existing = await findSystemByUrl(identifier.url, identifier.client, service);
         if (!existing) {
+            const key = new BackendSystemKey({ url: identifier.url, client: identifier.client });
             logger.error(`System not found: ${key.getId()}`);
             return;
         }
         const patchRecord = await determinePatch(params, existing, logger);
         if (!patchRecord) {
+            logger.info(t('systemActions.systemNotUpdated'));
             return;
         }
         replaceEnvVariables(patchRecord);
         if (!Object.keys(patchRecord).length) {
             logger.error('No fields to update. Provide at least one of: --name, --username, --password, --clear-credentials');
+            logger.info(t('systemActions.systemNotUpdated'));
             return;
         }
         const patch = patchRecord;
         if (!(await verifyCredentialsUpdate(patch, existing, params))) {
-            logger.info('System was not updated.');
+            logger.info(t('systemActions.systemNotUpdated'));
             return;
         }
+        const key = new BackendSystemKey({ url: existing.url, client: existing.client });
         await service.partialUpdate(key, patch);
-        logger.info(`System '${key.getId()}' updated.`);
+        logger.info(t('systemActions.systemUpdated', { name: existing.name }));
     }
     catch (error) {
         logger.error(error.message);

package/dist/cli/utils/system-connection.d.ts

@@ -1,20 +1,24 @@
+import type { SystemType } from '@sap-ux/store';
+import { AuthenticationType, ConnectionType } from '@sap-ux/store';
 /**
- * Checks connection to a backend system.
+ * Checks connection to a backend system by validating based on the connection type.
  *
  * @param config - System configuration to test
- * @param config.url
- * @param config.client
- * @param config.systemType
- * @param config.authenticationType
- * @param config.username
- * @param config.password
+ * @param config.url - System URL
+ * @param config.client - SAP client (optional)
+ * @param config.systemType - System type (OnPrem, AbapCloud, etc.)
+ * @param config.authenticationType - Authentication type
+ * @param config.connectionType - Connection type (determines validation method)
+ * @param config.username - Username for basic auth (optional)
+ * @param config.password - Password for basic auth (optional)
  * @returns Connection check result with success status and optional error message
  */
 export declare function checkSystemConnection(config: {
     url: string;
     client?: string;
-    systemType: string;
-    authenticationType: string;
+    systemType: SystemType;
+    authenticationType: AuthenticationType;
+    connectionType: ConnectionType;
     username?: string;
     password?: string;
 }): Promise<{
@@ -23,24 +27,26 @@ export declare function checkSystemConnection(config: {
 }>;
 /**
  * Checks connection to a backend system, or prompts user whether to save anyway if check fails.
- * If skipCheck is true, always returns true without checking.
+ * If skipConnectionValidation is true, always returns true without checking.
  *
  * @param config - System configuration to test
- * @param config.url
- * @param config.client
- * @param config.systemType
- * @param config.authenticationType
- * @param config.username
- * @param config.password
- * @param skipCheck - If true, skip the connection check
+ * @param config.url - System URL
+ * @param config.client - SAP client (optional)
+ * @param config.systemType - System type (OnPrem, AbapCloud, etc.)
+ * @param config.authenticationType - Authentication type
+ * @param config.connectionType - Connection type (determines validation method)
+ * @param config.username - Username for basic auth (optional)
+ * @param config.password - Password for basic auth (optional)
+ * @param skipConnectionValidation - If true, skip the connection check
  * @returns True if connection succeeded or user chose to save anyway, false if user chose not to save
  */
 export declare function checkConnectionOrPrompt(config: {
     url: string;
     client?: string;
-    systemType: string;
-    authenticationType: string;
+    systemType: SystemType;
+    authenticationType: AuthenticationType;
+    connectionType: ConnectionType;
     username?: string;
     password?: string;
-}, skipCheck: boolean): Promise<boolean>;
+}, skipConnectionValidation: boolean): Promise<boolean>;
 //# sourceMappingURL=system-connection.d.ts.map

package/dist/cli/utils/system-connection.js

@@ -1,15 +1,21 @@
 import prompts from 'prompts';
+import { createAbapServiceProvider } from '@sap-ux/system-access';
+import { ErrorHandler } from '@sap-ux/inquirer-common';
+import { AuthenticationType, ConnectionType } from '@sap-ux/store';
+import { ODataVersion } from '@sap-ux/axios-extension';
 import { getLogger } from '../../tracing/index.js';
+import { t } from '../../i18n.js';
 /**
- * Checks connection to a backend system.
+ * Checks connection to a backend system by validating based on the connection type.
  *
  * @param config - System configuration to test
- * @param config.url
- * @param config.client
- * @param config.systemType
- * @param config.authenticationType
- * @param config.username
- * @param config.password
+ * @param config.url - System URL
+ * @param config.client - SAP client (optional)
+ * @param config.systemType - System type (OnPrem, AbapCloud, etc.)
+ * @param config.authenticationType - Authentication type
+ * @param config.connectionType - Connection type (determines validation method)
+ * @param config.username - Username for basic auth (optional)
+ * @param config.password - Password for basic auth (optional)
  * @returns Connection check result with success status and optional error message
  */
 export async function checkSystemConnection(config) {
@@ -18,44 +24,102 @@ export async function checkSystemConnection(config) {
         new URL(config.url);
     }
     catch {
-        return { success: false, error: `Invalid URL: ${config.url}` };
+        return { success: false, error: t('systemConnection.invalidUrl', { url: config.url }) };
+    }
+    // Attempt actual connection check
+    try {
+        const logger = getLogger();
+        // Build target configuration for system-access
+        const target = {
+            url: config.url,
+            client: config.client,
+            authenticationType: config.authenticationType
+        };
+        // Build request options with auth if provided
+        // For basic auth with credentials, include them
+        // For reentranceTicket/oauth2, omit auth (will get 401 but proves reachability)
+        const requestOptions = config.authenticationType === AuthenticationType.Basic && config.username && config.password
+            ? {
+                auth: {
+                    username: config.username,
+                    password: config.password
+                }
+            }
+            : undefined;
+        // Create service provider using system-access utilities
+        // prompt=false because we're in non-interactive connection check mode
+        const service = await createAbapServiceProvider(target, requestOptions, false, logger);
+        // Validate based on connection type
+        if (config.connectionType === ConnectionType.AbapCatalog) {
+            // For ABAP catalog connections, request catalog services
+            const catalog = service.catalog(ODataVersion.v2);
+            const services = await catalog.listServices();
+            logger.info(t('systemConnection.catalogServicesFound', { count: services.length }));
+            return { success: true };
+        }
+        else if (config.connectionType === ConnectionType.ODataService) {
+            // For OData service URLs, attempt metadata request
+            const response = await service.get('/$metadata', { timeout: 5000 });
+            if (response.status === 200) {
+                logger.info(t('systemConnection.metadataRequestSuccessful'));
+                return { success: true };
+            }
+            return { success: false, error: t('systemConnection.unexpectedStatus', { status: response.status }) };
+        }
+        else if (config.connectionType === ConnectionType.GenericHost) {
+            // For generic host, basic connectivity check
+            await service.get('/', { timeout: 5000 });
+            return { success: true };
+        }
+        return { success: true };
+    }
+    catch (error) {
+        // 401 means system is reachable but requires auth - treat as success
+        if (error.response?.status === 401) {
+            return { success: true };
+        }
+        // Use ErrorHandler for comprehensive error analysis
+        const errorHandler = new ErrorHandler(getLogger(), false);
+        const errorMsg = errorHandler.logErrorMsgs(error, undefined, false);
+        // For other errors, provide detailed message
+        return {
+            success: false,
+            error: errorMsg || t('systemConnection.unknownError')
+        };
     }
-    // For now, we just validate the URL format
-    // A real implementation would attempt to connect to the backend
-    // using the provided credentials and check if the system is reachable
-    return { success: true };
 }
 /**
  * Checks connection to a backend system, or prompts user whether to save anyway if check fails.
- * If skipCheck is true, always returns true without checking.
+ * If skipConnectionValidation is true, always returns true without checking.
  *
  * @param config - System configuration to test
- * @param config.url
- * @param config.client
- * @param config.systemType
- * @param config.authenticationType
- * @param config.username
- * @param config.password
- * @param skipCheck - If true, skip the connection check
+ * @param config.url - System URL
+ * @param config.client - SAP client (optional)
+ * @param config.systemType - System type (OnPrem, AbapCloud, etc.)
+ * @param config.authenticationType - Authentication type
+ * @param config.connectionType - Connection type (determines validation method)
+ * @param config.username - Username for basic auth (optional)
+ * @param config.password - Password for basic auth (optional)
+ * @param skipConnectionValidation - If true, skip the connection check
  * @returns True if connection succeeded or user chose to save anyway, false if user chose not to save
  */
-export async function checkConnectionOrPrompt(config, skipCheck) {
+export async function checkConnectionOrPrompt(config, skipConnectionValidation) {
     const logger = getLogger();
-    if (skipCheck) {
-        logger.info('Skipping connection check (--skip-check flag provided)');
+    if (skipConnectionValidation) {
+        logger.info(t('systemConnection.skippingCheck'));
         return true;
     }
-    logger.info('Verifying connection to backend system...');
+    logger.info(t('systemConnection.verifying'));
     const result = await checkSystemConnection(config);
     if (result.success) {
-        logger.info('✓ Connection successful');
+        logger.info(t('systemConnection.connectionSuccessful'));
         return true;
     }
-    logger.warn(`Connection check failed: ${result.error || 'Unknown error'}`);
+    logger.warn(t('systemConnection.connectionFailed', { error: result.error ?? t('systemConnection.unknownError') }));
     const answer = await prompts({
         type: 'confirm',
         name: 'saveAnyway',
-        message: 'Connection check failed. Save system anyway?',
+        message: t('systemConnection.saveAnywayPrompt'),
         initial: false
     });
     return answer.saveAnyway === true;

package/dist/cli/utils/system-lookup.d.ts

@@ -0,0 +1,17 @@
+import type { BackendSystem, BackendSystemKey, Service } from '@sap-ux/store';
+/**
+ * Finds a backend system by URL with smart matching when client is not specified or doesn't match.
+ *
+ * Logic:
+ * 1. Find all systems with the same URL (across all connection types).
+ * 2. If exactly one system found, use it automatically.
+ * 3. If multiple systems found, try exact match first, then prompt user to select if no exact match.
+ * 4. If none found, return undefined.
+ *
+ * @param url - URL of the backend system
+ * @param client - optional SAP client
+ * @param service - backend system service
+ * @returns the matched system, or undefined if not found or user cancelled
+ */
+export declare function findSystemByUrl(url: string, client: string | undefined, service: Service<BackendSystem, BackendSystemKey>): Promise<BackendSystem | undefined>;
+//# sourceMappingURL=system-lookup.d.ts.map