@mcp-abap-adt/auth-stores 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -7,6 +7,82 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.7] - 2025-12-08
+
+### Added
+- **Broker Usage Tests**: Added comprehensive test suites for broker usage scenarios
+  - Tests verify stores work correctly when used as in `AuthBroker` (without `saveSession`)
+  - Tests cover `setConnectionConfig` and `setAuthorizationConfig` on empty stores
+  - Tests verify session creation and updates in broker flow scenarios
+  - Test files: `*SessionStore.broker.test.ts` for all store types
+
+### Changed
+- **Session Store Initialization**: File-based session stores now automatically create directory in constructor
+  - `AbapSessionStore`, `BtpSessionStore`, `XsuaaSessionStore` create directory if it doesn't exist
+  - Stores are ready to use immediately after construction
+  - Directory creation is logged at debug level
+- **Session Creation Logic**: Session stores now automatically create sessions when calling `setConnectionConfig` or `setAuthorizationConfig`
+  - No need to call `saveSession` first - stores handle session creation internally
+  - `setConnectionConfig` creates new session if none exists (requires `serviceUrl` for ABAP)
+  - `setAuthorizationConfig` creates new session if none exists (for BTP/XSUAA, `mcpUrl` is optional)
+  - For ABAP: `setAuthorizationConfig` requires existing `serviceUrl` (from `setConnectionConfig` or throws error)
+  - This matches how `AuthBroker` uses stores - stores are now fully ready after construction
+- **Token Validation**: Updated validation to allow empty string for `jwtToken` in BTP/XSUAA stores
+  - Empty token is allowed (can be set later via `setConnectionConfig`)
+  - Only `undefined` or `null` tokens are rejected
+  - This enables creating sessions with authorization config first, then adding connection config
+
+### Fixed
+- **getConnectionConfig**: Fixed to allow empty string tokens (not just non-empty strings)
+  - Returns `null` only if token is `undefined` or `null`
+  - Empty string tokens are valid (can be set later)
+- **setConnectionConfig Updates**: Fixed to preserve existing token when updating connection config
+  - Only updates `jwtToken` if `authorizationToken` is provided in config
+  - Preserves existing token if `authorizationToken` is `undefined`
+- **Safe Session Stores**: Fixed session creation in `setConnectionConfig` and `setAuthorizationConfig`
+  - Now saves directly to Map (internal format) instead of calling `saveSession` with wrong format
+  - This fixes issues where `mcpUrl`/`serviceUrl` was not being saved correctly
+- **loadXsuaaEnvFile**: Fixed to allow empty string for `jwtToken` (can be set later)
+  - Only rejects `undefined` or `null` tokens
+  - Empty string tokens are valid and can be set later via `setConnectionConfig`
+- **testLogger**: Fixed to not output by default in test environment
+  - Now requires explicit enable via `DEBUG_AUTH_STORES=true` or `DEBUG=true`
+  - No longer enables logging automatically when `NODE_ENV === 'test'`
+
+## [0.1.6] - 2025-12-08
+
+### Added
+- **Comprehensive Logging System**: Added optional logging support throughout the package
+  - All stores, parsers, and storage functions now accept optional `ILogger` parameter
+  - Logging shows detailed information: file paths, file sizes, parsed data structure, operation results
+  - Logging works by default in test environment (`NODE_ENV === 'test'`)
+  - Controlled via environment variables: `DEBUG_AUTH_STORES`, `LOG_LEVEL`
+- **Test Logger Helper**: Added `createTestLogger` helper for tests
+  - Respects `DEBUG_AUTH_STORES`, `DEBUG`, and `LOG_LEVEL` environment variables
+  - Formats messages and meta into single-line output
+  - Shows stack traces for debug and error levels
+- **Logging in Parsers**: Added logging to `AbapServiceKeyParser` and `XsuaaServiceKeyParser`
+  - Logs parsing operations, validation checks, and results
+  - Shows structure of parsed data (keys, fields, validation results)
+- **Logging in Storage**: Added logging to all storage functions
+  - `loadEnvFile`, `saveTokenToEnv` (ABAP)
+  - `loadXsuaaEnvFile`, `saveXsuaaTokenToEnv` (XSUAA)
+  - Logs file operations: reading, writing, file sizes, preserved variables
+
+### Changed
+- **Store Constructors**: All stores now accept optional `log?: ILogger` parameter
+  - `AbapServiceKeyStore`, `BtpServiceKeyStore`, `XsuaaServiceKeyStore`
+  - `AbapSessionStore`, `BtpSessionStore`, `XsuaaSessionStore`
+  - `SafeAbapSessionStore`, `SafeBtpSessionStore`, `SafeXsuaaSessionStore`
+- **Parser Constructors**: Parsers now accept optional `log?: ILogger` parameter
+  - `AbapServiceKeyParser`, `XsuaaServiceKeyParser`
+- **Storage Functions**: Storage functions now accept optional `log?: ILogger` parameter
+  - All storage functions pass logger through to enable detailed logging
+- **Logging Format**: All log messages are concise, single-line strings with embedded key data
+  - Example: `Reading service key file: /path/to/file.json`
+  - Example: `File read successfully, size: 121 bytes, keys: uaa`
+  - Example: `Session saved: token(2263 chars), hasRefreshToken(true), sapUrl(https://...)`
+
 ## [0.1.5] - 2025-12-07
 
 ### Changed

package/README.md

@@ -145,11 +145,12 @@ All stores accept a single directory path in the constructor:
 // Single directory path
 const store = new BtpServiceKeyStore('/path/to/service-keys');
 
-// Directory will be created automatically if it doesn't exist when saving files
-const sessionStore = new AbapSessionStore('/path/to/sessions');
-await sessionStore.saveSession('TRIAL', config); // Creates directory if needed
+// File-based session stores automatically create directory in constructor if it doesn't exist
+const sessionStore = new AbapSessionStore('/path/to/sessions'); // Directory created automatically
 ```
 
+**Note**: File-based session stores (`AbapSessionStore`, `BtpSessionStore`, `XsuaaSessionStore`) automatically create the directory in the constructor if it doesn't exist. Stores are ready to use immediately after construction.
+
 ### Service Key Format
 
 **ABAP Service Key** (with nested `uaa` object):
@@ -235,6 +236,80 @@ const abapKey = await loadServiceKey('TRIAL', '/path/to/service-keys');
 const xsuaaKey = await loadXSUAAServiceKey('mcp', '/path/to/service-keys');
 ```
 
+## Debug Logging
+
+Stores support optional logging through the `ILogger` interface. To enable detailed logging:
+
+### Using Logger in Code
+
+```typescript
+import { AbapServiceKeyStore } from '@mcp-abap-adt/auth-stores';
+import type { ILogger } from '@mcp-abap-adt/interfaces';
+
+// Create logger (or use your own implementation)
+const logger: ILogger = {
+  debug: (msg) => console.debug(msg),
+  info: (msg) => console.info(msg),
+  warn: (msg) => console.warn(msg),
+  error: (msg) => console.error(msg),
+};
+
+// Pass logger to store constructor
+const store = new AbapServiceKeyStore('/path/to/service-keys', logger);
+const sessionStore = new AbapSessionStore('/path/to/sessions', logger);
+```
+
+### Using Test Logger in Tests
+
+For tests, use the `createTestLogger` helper which respects environment variables:
+
+```typescript
+import { createTestLogger } from './__tests__/helpers/testLogger';
+
+// Logger will output only if DEBUG_AUTH_STORES=true is set
+const logger = createTestLogger('MY-TEST');
+const store = new AbapServiceKeyStore('/path/to/service-keys', logger);
+```
+
+### Environment Variables
+
+To enable logging in tests or when using `createTestLogger`:
+
+```bash
+# Enable logging for auth stores
+DEBUG_AUTH_STORES=true npm test
+
+# Or enable via general DEBUG variable
+DEBUG=true npm test
+
+# Or include in DEBUG list
+DEBUG=auth-stores npm test
+
+# Set log level (debug, info, warn, error)
+LOG_LEVEL=debug npm test
+```
+
+**Note**: Logging is enabled by default in test environment (`NODE_ENV === 'test'`). To disable, set `DEBUG_AUTH_STORES=false`.
+
+Logging shows:
+- **File operations**: Which files are read/written, file sizes, file paths
+- **Parsing operations**: Structure of parsed data, validation results, keys found
+- **Storage operations**: What data is saved/loaded, token lengths, refresh token presence, URLs
+- **Errors**: Detailed error information with context
+
+Example output with `LOG_LEVEL=debug`:
+```
+[TEST-STORE] [DEBUG] Reading service key file: /path/to/TRIAL.json
+[TEST-STORE] [DEBUG] File read successfully, size: 121 bytes, keys: uaa
+[TEST-STORE] [DEBUG] Parsed service key structure: hasUaa(true), uaaKeys(url, clientid, clientsecret)
+[TEST-STORE] Authorization config loaded from /path/to/TRIAL.json: uaaUrl(https://...authentication...), clientId(test-client...)
+[TEST-STORE] [DEBUG] Reading env file: /path/to/TRIAL.env
+[TEST-STORE] [DEBUG] Env file read successfully, size: 245 bytes
+[TEST-STORE] Session loaded for TRIAL: token(2263 chars), hasRefreshToken(true), sapUrl(https://...abap...)
+```
+
+**Note**: Logging only works when a logger is explicitly provided. Stores will not output anything to console if no logger is passed.
+
 ## Testing
 
 The package includes both unit tests (with mocked file system) and integration tests (with real files).
@@ -281,12 +356,23 @@ Integration tests will skip if `test-config.yaml` is not configured or contains
 
 - All stores implement `IServiceKeyStore` or `ISessionStore` interfaces from `@mcp-abap-adt/auth-broker`
 - Stores accept a single directory path in constructor
-- File-based stores automatically create directories when saving
+- File-based session stores automatically create directories in constructor if they don't exist
+- Session stores automatically create sessions when calling `setConnectionConfig` or `setAuthorizationConfig` (no need to call `saveSession` first)
 - In-memory stores (`Safe*SessionStore`) don't persist data to disk
 
+### Session Store Behavior
+
+Session stores are designed to work seamlessly with `AuthBroker`:
+
+- **Ready after construction**: File-based stores create directory automatically, stores are ready to use immediately
+- **Automatic session creation**: Calling `setConnectionConfig` or `setAuthorizationConfig` on an empty store creates a new session
+- **ABAP stores**: Require `serviceUrl` when creating new session via `setConnectionConfig` or `setAuthorizationConfig`
+- **BTP/XSUAA stores**: `mcpUrl` is optional - can create session with authorization config first, then add connection config
+- **Token updates**: `setConnectionConfig` updates token if provided, preserves existing token if not provided
+
 ## Dependencies
 
-- `@mcp-abap-adt/auth-broker` (^0.1.6) - Interface definitions
+- `@mcp-abap-adt/interfaces` (^0.1.3) - Interface definitions (`IServiceKeyStore`, `ISessionStore`, `IConfig`, `IConnectionConfig`, `IAuthorizationConfig`, `ILogger`)
 - `dotenv` - Environment variable parsing
 
 ## License

package/dist/parsers/abap/AbapServiceKeyParser.d.ts

@@ -15,10 +15,17 @@
  *   ...
  * }
  */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 /**
  * Parser for standard ABAP service key format
  */
 export declare class AbapServiceKeyParser {
+    private log?;
+    /**
+     * Create a new AbapServiceKeyParser instance
+     * @param log Optional logger for logging operations
+     */
+    constructor(log?: ILogger);
     /**
      * Check if this parser can handle the given raw service key data
      * @param rawData Raw JSON data from service key file

package/dist/parsers/abap/AbapServiceKeyParser.js

@@ -22,13 +22,23 @@ exports.AbapServiceKeyParser = void 0;
  * Parser for standard ABAP service key format
  */
 class AbapServiceKeyParser {
+    log;
+    /**
+     * Create a new AbapServiceKeyParser instance
+     * @param log Optional logger for logging operations
+     */
+    constructor(log) {
+        this.log = log;
+    }
     /**
      * Check if this parser can handle the given raw service key data
      * @param rawData Raw JSON data from service key file
      * @returns true if data has nested uaa object, false otherwise
      */
     canParse(rawData) {
-        return rawData && typeof rawData === 'object' && rawData.uaa && typeof rawData.uaa === 'object';
+        const result = rawData && typeof rawData === 'object' && rawData.uaa && typeof rawData.uaa === 'object';
+        this.log?.debug(`canParse check: hasUaa(${!!rawData?.uaa}), result(${result})`);
+        return result;
     }
     /**
      * Parse raw service key data
@@ -37,13 +47,21 @@ class AbapServiceKeyParser {
      * @throws Error if data cannot be parsed or is invalid
      */
     parse(rawData) {
+        this.log?.debug(`Parsing ABAP service key: hasUaa(${!!rawData?.uaa}), keys(${rawData ? Object.keys(rawData).join(', ') : 'none'})`);
         if (!this.canParse(rawData)) {
+            this.log?.error(`Service key does not match ABAP format: missing uaa object`);
             throw new Error('Service key does not match ABAP format (missing uaa object)');
         }
         // Validate UAA configuration
-        if (!rawData.uaa.url || !rawData.uaa.clientid || !rawData.uaa.clientsecret) {
+        const hasUrl = !!rawData.uaa.url;
+        const hasClientId = !!rawData.uaa.clientid;
+        const hasClientSecret = !!rawData.uaa.clientsecret;
+        this.log?.debug(`UAA validation: url(${hasUrl}), clientid(${hasClientId}), clientsecret(${hasClientSecret})`);
+        if (!hasUrl || !hasClientId || !hasClientSecret) {
+            this.log?.error(`Service key uaa object missing required fields: url(${hasUrl}), clientid(${hasClientId}), clientsecret(${hasClientSecret})`);
             throw new Error('Service key "uaa" object missing required fields: url, clientid, clientsecret');
         }
+        this.log?.debug(`ABAP service key parsed successfully: uaaUrl(${rawData.uaa.url.substring(0, 40)}...), hasAbap(${!!rawData.abap})`);
         return rawData;
     }
 }

package/dist/parsers/xsuaa/XsuaaServiceKeyParser.d.ts

@@ -10,10 +10,17 @@
  *   ...
  * }
  */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 /**
  * Parser for direct XSUAA service key format from BTP
  */
 export declare class XsuaaServiceKeyParser {
+    private log?;
+    /**
+     * Create a new XsuaaServiceKeyParser instance
+     * @param log Optional logger for logging operations
+     */
+    constructor(log?: ILogger);
     /**
      * Check if this parser can handle the given raw service key data
      * @param rawData Raw JSON data from service key file

package/dist/parsers/xsuaa/XsuaaServiceKeyParser.js

@@ -17,6 +17,14 @@ exports.XsuaaServiceKeyParser = void 0;
  * Parser for direct XSUAA service key format from BTP
  */
 class XsuaaServiceKeyParser {
+    log;
+    /**
+     * Create a new XsuaaServiceKeyParser instance
+     * @param log Optional logger for logging operations
+     */
+    constructor(log) {
+        this.log = log;
+    }
     /**
      * Check if this parser can handle the given raw service key data
      * @param rawData Raw JSON data from service key file
@@ -24,19 +32,21 @@ class XsuaaServiceKeyParser {
      */
     canParse(rawData) {
         if (!rawData || typeof rawData !== 'object' || Array.isArray(rawData)) {
+            this.log?.debug(`canParse check: invalid type, result(false)`);
             return false;
         }
         // Check for nested uaa object (ABAP format) - should not have it
         if (rawData.uaa) {
+            this.log?.debug(`canParse check: has nested uaa (ABAP format), result(false)`);
             return false;
         }
         // Check for required XSUAA fields at root level
-        return (typeof rawData.url === 'string' &&
-            typeof rawData.clientid === 'string' &&
-            typeof rawData.clientsecret === 'string' &&
-            rawData.url.length > 0 &&
-            rawData.clientid.length > 0 &&
-            rawData.clientsecret.length > 0);
+        const hasUrl = typeof rawData.url === 'string' && rawData.url.length > 0;
+        const hasClientId = typeof rawData.clientid === 'string' && rawData.clientid.length > 0;
+        const hasClientSecret = typeof rawData.clientsecret === 'string' && rawData.clientsecret.length > 0;
+        const result = hasUrl && hasClientId && hasClientSecret;
+        this.log?.debug(`canParse check: url(${hasUrl}), clientid(${hasClientId}), clientsecret(${hasClientSecret}), result(${result})`);
+        return result;
     }
     /**
      * Parse raw service key data
@@ -45,14 +55,16 @@ class XsuaaServiceKeyParser {
      * @throws Error if data cannot be parsed or is invalid
      */
     parse(rawData) {
+        this.log?.debug(`Parsing XSUAA service key: hasUrl(${!!rawData?.url}), hasClientId(${!!rawData?.clientid}), hasClientSecret(${!!rawData?.clientsecret}), keys(${rawData ? Object.keys(rawData).join(', ') : 'none'})`);
         if (!this.canParse(rawData)) {
+            this.log?.error(`Service key does not match XSUAA format: missing required fields at root level`);
             throw new Error('Service key does not match XSUAA format (missing url, clientid, or clientsecret at root level)');
         }
         // Normalize to standard format
         // For authorization (OAuth2 authorize endpoint), use 'url' (not 'apiurl')
         // 'apiurl' is for token endpoint, but authorization uses base 'url'
         const uaaUrl = rawData.url;
-        return {
+        const result = {
             uaa: {
                 url: uaaUrl,
                 clientid: rawData.clientid,
@@ -68,6 +80,8 @@ class XsuaaServiceKeyParser {
             sap_client: rawData.sap_client,
             language: rawData.language,
         };
+        this.log?.debug(`XSUAA service key parsed successfully: uaaUrl(${uaaUrl.substring(0, 40)}...), hasAbap(${!!rawData.abap})`);
+        return result;
     }
 }
 exports.XsuaaServiceKeyParser = XsuaaServiceKeyParser;

package/dist/storage/abap/envLoader.d.ts

@@ -1,6 +1,7 @@
 /**
  * Environment file loader - loads .env files by destination name for ABAP
  */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 interface EnvConfig {
     sapUrl: string;
     sapClient?: string;
@@ -15,7 +16,8 @@ interface EnvConfig {
  * Load environment configuration from {destination}.env file
  * @param destination Destination name
  * @param directory Directory where the file is located
+ * @param log Optional logger for logging operations
  * @returns EnvConfig object or null if file not found
  */
-export declare function loadEnvFile(destination: string, directory: string): Promise<EnvConfig | null>;
+export declare function loadEnvFile(destination: string, directory: string, log?: ILogger): Promise<EnvConfig | null>;
 export {};

package/dist/storage/abap/envLoader.js

@@ -45,22 +45,29 @@ const constants_1 = require("../../utils/constants");
  * Load environment configuration from {destination}.env file
  * @param destination Destination name
  * @param directory Directory where the file is located
+ * @param log Optional logger for logging operations
  * @returns EnvConfig object or null if file not found
  */
-async function loadEnvFile(destination, directory) {
+async function loadEnvFile(destination, directory, log) {
     const fileName = `${destination}.env`;
     const envFilePath = path.join(directory, fileName);
+    log?.debug(`Reading env file: ${envFilePath}`);
     if (!fs.existsSync(envFilePath)) {
+        log?.debug(`Env file not found: ${envFilePath}`);
         return null;
     }
     try {
         // Read and parse .env file
         const envContent = fs.readFileSync(envFilePath, 'utf8');
+        log?.debug(`Env file read successfully, size: ${envContent.length} bytes`);
         const parsed = dotenv.parse(envContent);
+        log?.debug(`Parsed env variables: ${Object.keys(parsed).join(', ')}`);
         // Extract required fields
         const sapUrl = parsed[constants_1.ABAP_CONNECTION_VARS.SERVICE_URL];
         const jwtToken = parsed[constants_1.ABAP_CONNECTION_VARS.AUTHORIZATION_TOKEN];
+        log?.debug(`Extracted fields: hasSapUrl(${!!sapUrl}), hasJwtToken(${!!jwtToken})`);
         if (!sapUrl || !jwtToken) {
+            log?.warn(`Env file missing required fields: sapUrl(${!!sapUrl}), jwtToken(${!!jwtToken})`);
             return null;
         }
         const config = {
@@ -86,9 +93,11 @@ async function loadEnvFile(destination, directory) {
         if (parsed[constants_1.ABAP_CONNECTION_VARS.SAP_LANGUAGE]) {
             config.language = parsed[constants_1.ABAP_CONNECTION_VARS.SAP_LANGUAGE].trim();
         }
+        log?.info(`Env config loaded from ${envFilePath}: sapUrl(${config.sapUrl.substring(0, 50)}...), token(${config.jwtToken.length} chars), hasRefreshToken(${!!config.refreshToken}), hasUaaUrl(${!!config.uaaUrl})`);
         return config;
     }
     catch (error) {
+        log?.error(`Failed to load env file from ${envFilePath}: ${error instanceof Error ? error.message : String(error)}`);
         throw new Error(`Failed to load environment file for destination "${destination}": ${error instanceof Error ? error.message : String(error)}`);
     }
 }

package/dist/storage/abap/tokenStorage.d.ts

@@ -1,6 +1,7 @@
 /**
  * Token storage - saves tokens to .env files for ABAP
  */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 interface EnvConfig {
     sapUrl: string;
     sapClient?: string;
@@ -16,9 +17,10 @@ interface EnvConfig {
  * @param destination Destination name
  * @param savePath Path where to save the file
  * @param config Configuration to save
+ * @param log Optional logger for logging operations
  */
 export declare function saveTokenToEnv(destination: string, savePath: string, config: Partial<EnvConfig> & {
     sapUrl?: string;
     jwtToken: string;
-}): Promise<void>;
+}, log?: ILogger): Promise<void>;
 export {};

package/dist/storage/abap/tokenStorage.js

@@ -45,18 +45,26 @@ const constants_1 = require("../../utils/constants");
  * @param destination Destination name
  * @param savePath Path where to save the file
  * @param config Configuration to save
+ * @param log Optional logger for logging operations
  */
-async function saveTokenToEnv(destination, savePath, config) {
+async function saveTokenToEnv(destination, savePath, config, log) {
+    const envFilePath = path.join(savePath, `${destination}.env`);
+    const tempFilePath = `${envFilePath}.tmp`;
+    log?.debug(`Saving token to env file: ${envFilePath}`);
+    log?.debug(`Config to save: hasSapUrl(${!!config.sapUrl}), token(${config.jwtToken.length} chars), hasRefreshToken(${!!config.refreshToken}), hasUaaUrl(${!!config.uaaUrl})`);
     // Ensure directory exists
     if (!fs.existsSync(savePath)) {
+        log?.debug(`Creating directory: ${savePath}`);
         fs.mkdirSync(savePath, { recursive: true });
     }
-    const envFilePath = path.join(savePath, `${destination}.env`);
-    const tempFilePath = `${envFilePath}.tmp`;
     // Read existing .env file if it exists
     let existingContent = '';
     if (fs.existsSync(envFilePath)) {
         existingContent = fs.readFileSync(envFilePath, 'utf8');
+        log?.debug(`Reading existing env file, size: ${existingContent.length} bytes`);
+    }
+    else {
+        log?.debug(`Env file does not exist, creating new one`);
     }
     // Parse existing content to preserve other values
     const lines = existingContent.split('\n');
@@ -73,6 +81,7 @@ async function saveTokenToEnv(destination, savePath, config) {
             existingVars.set(key, value);
         }
     }
+    log?.debug(`Preserved ${existingVars.size} existing variables from env file`);
     // Update with new values
     if (config.sapUrl) {
         existingVars.set(constants_1.ABAP_CONNECTION_VARS.SERVICE_URL, config.sapUrl);
@@ -106,8 +115,10 @@ async function saveTokenToEnv(destination, savePath, config) {
         envLines.push(`${key}=${escapedValue}`);
     }
     const envContent = envLines.join('\n') + '\n';
+    log?.debug(`Writing ${envLines.length} variables to env file: ${Object.keys(config).join(', ')}`);
     // Write to temp file
     fs.writeFileSync(tempFilePath, envContent, 'utf8');
     // Atomic rename
     fs.renameSync(tempFilePath, envFilePath);
+    log?.info(`Token saved to ${envFilePath}: token(${config.jwtToken.length} chars), sapUrl(${config.sapUrl ? config.sapUrl.substring(0, 50) + '...' : 'none'}), variables(${envLines.length})`);
 }

package/dist/storage/xsuaa/xsuaaEnvLoader.d.ts

@@ -1,6 +1,7 @@
 /**
  * XSUAA Environment file loader - loads .env files with XSUAA_* variables for XSUAA
  */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 interface XsuaaSessionConfig {
     mcpUrl?: string;
     jwtToken: string;
@@ -14,7 +15,8 @@ interface XsuaaSessionConfig {
  * Reads XSUAA_* variables instead of SAP_* variables
  * @param destination Destination name
  * @param directory Directory where the file is located
+ * @param log Optional logger for logging operations
  * @returns XsuaaSessionConfig object or null if file not found
  */
-export declare function loadXsuaaEnvFile(destination: string, directory: string): Promise<XsuaaSessionConfig | null>;
+export declare function loadXsuaaEnvFile(destination: string, directory: string, log?: ILogger): Promise<XsuaaSessionConfig | null>;
 export {};

package/dist/storage/xsuaa/xsuaaEnvLoader.js

@@ -46,21 +46,30 @@ const constants_1 = require("../../utils/constants");
  * Reads XSUAA_* variables instead of SAP_* variables
  * @param destination Destination name
  * @param directory Directory where the file is located
+ * @param log Optional logger for logging operations
  * @returns XsuaaSessionConfig object or null if file not found
  */
-async function loadXsuaaEnvFile(destination, directory) {
+async function loadXsuaaEnvFile(destination, directory, log) {
     const fileName = `${destination}.env`;
     const envFilePath = path.join(directory, fileName);
+    log?.debug(`Reading XSUAA env file: ${envFilePath}`);
     if (!fs.existsSync(envFilePath)) {
+        log?.debug(`XSUAA env file not found: ${envFilePath}`);
         return null;
     }
     try {
         // Read and parse .env file
         const envContent = fs.readFileSync(envFilePath, 'utf8');
+        log?.debug(`XSUAA env file read successfully, size: ${envContent.length} bytes`);
         const parsed = dotenv.parse(envContent);
+        log?.debug(`Parsed XSUAA env variables: ${Object.keys(parsed).filter(k => k.startsWith('XSUAA_')).join(', ')}`);
         // Extract required fields (XSUAA_* variables)
         const jwtToken = parsed[constants_1.XSUAA_CONNECTION_VARS.AUTHORIZATION_TOKEN];
-        if (!jwtToken) {
+        log?.debug(`Extracted fields: hasJwtToken(${jwtToken !== undefined && jwtToken !== null})`);
+        // Allow empty string for jwtToken (can be set later via setConnectionConfig)
+        // Only reject if jwtToken is undefined or null
+        if (jwtToken === undefined || jwtToken === null) {
+            log?.warn(`XSUAA env file missing required field: jwtToken`);
             return null;
         }
         const config = {
@@ -83,9 +92,11 @@ async function loadXsuaaEnvFile(destination, directory) {
         if (parsed[constants_1.XSUAA_AUTHORIZATION_VARS.UAA_CLIENT_SECRET]) {
             config.uaaClientSecret = parsed[constants_1.XSUAA_AUTHORIZATION_VARS.UAA_CLIENT_SECRET].trim();
         }
+        log?.info(`XSUAA env config loaded from ${envFilePath}: token(${config.jwtToken.length} chars), hasRefreshToken(${!!config.refreshToken}), hasUaaUrl(${!!config.uaaUrl}), mcpUrl(${config.mcpUrl ? config.mcpUrl.substring(0, 50) + '...' : 'none'})`);
         return config;
     }
     catch (error) {
+        log?.error(`Failed to load XSUAA env file from ${envFilePath}: ${error instanceof Error ? error.message : String(error)}`);
         throw new Error(`Failed to load XSUAA environment file for destination "${destination}": ${error instanceof Error ? error.message : String(error)}`);
     }
 }

package/dist/storage/xsuaa/xsuaaTokenStorage.d.ts

@@ -1,6 +1,7 @@
 /**
  * XSUAA Token storage - saves tokens to .env files with XSUAA_* variables
  */
+import type { ILogger } from '@mcp-abap-adt/interfaces';
 interface XsuaaSessionConfig {
     mcpUrl?: string;
     jwtToken: string;
@@ -14,6 +15,7 @@ interface XsuaaSessionConfig {
  * @param destination Destination name
  * @param savePath Path where to save the file
  * @param config XSUAA session configuration to save
+ * @param log Optional logger for logging operations
  */
-export declare function saveXsuaaTokenToEnv(destination: string, savePath: string, config: XsuaaSessionConfig): Promise<void>;
+export declare function saveXsuaaTokenToEnv(destination: string, savePath: string, config: XsuaaSessionConfig, log?: ILogger): Promise<void>;
 export {};

package/dist/storage/xsuaa/xsuaaTokenStorage.js

@@ -45,18 +45,26 @@ const constants_1 = require("../../utils/constants");
  * @param destination Destination name
  * @param savePath Path where to save the file
  * @param config XSUAA session configuration to save
+ * @param log Optional logger for logging operations
  */
-async function saveXsuaaTokenToEnv(destination, savePath, config) {
+async function saveXsuaaTokenToEnv(destination, savePath, config, log) {
+    const envFilePath = path.join(savePath, `${destination}.env`);
+    const tempFilePath = `${envFilePath}.tmp`;
+    log?.debug(`Saving XSUAA token to env file: ${envFilePath}`);
+    log?.debug(`Config to save: token(${config.jwtToken.length} chars), hasRefreshToken(${!!config.refreshToken}), hasUaaUrl(${!!config.uaaUrl}), mcpUrl(${config.mcpUrl ? config.mcpUrl.substring(0, 50) + '...' : 'none'})`);
     // Ensure directory exists
     if (!fs.existsSync(savePath)) {
+        log?.debug(`Creating directory: ${savePath}`);
         fs.mkdirSync(savePath, { recursive: true });
     }
-    const envFilePath = path.join(savePath, `${destination}.env`);
-    const tempFilePath = `${envFilePath}.tmp`;
     // Read existing .env file if it exists
     let existingContent = '';
     if (fs.existsSync(envFilePath)) {
         existingContent = fs.readFileSync(envFilePath, 'utf8');
+        log?.debug(`Reading existing XSUAA env file, size: ${existingContent.length} bytes`);
+    }
+    else {
+        log?.debug(`XSUAA env file does not exist, creating new one`);
     }
     // Parse existing content to preserve other values
     // Remove old SAP_* variables for XSUAA (use XSUAA_* instead)
@@ -79,6 +87,7 @@ async function saveXsuaaTokenToEnv(destination, savePath, config) {
             existingVars.set(key, value);
         }
     }
+    log?.debug(`Preserved ${existingVars.size} existing variables from XSUAA env file`);
     // Update with new values (XSUAA_* variables)
     // mcpUrl can be saved as additional variable (not part of CONNECTION_VARS, but can be stored for convenience)
     // URL comes from elsewhere (YAML config, parameter, or request header), but can be stored in .env
@@ -108,8 +117,10 @@ async function saveXsuaaTokenToEnv(destination, savePath, config) {
         envLines.push(`${key}=${escapedValue}`);
     }
     const envContent = envLines.join('\n') + '\n';
+    log?.debug(`Writing ${envLines.length} XSUAA variables to env file: ${Object.keys(config).join(', ')}`);
     // Write to temp file
     fs.writeFileSync(tempFilePath, envContent, 'utf8');
     // Atomic rename
     fs.renameSync(tempFilePath, envFilePath);
+    log?.info(`XSUAA token saved to ${envFilePath}: token(${config.jwtToken.length} chars), mcpUrl(${config.mcpUrl ? config.mcpUrl.substring(0, 50) + '...' : 'none'}), variables(${envLines.length})`);
 }

package/dist/stores/abap/AbapServiceKeyStore.d.ts

@@ -1,7 +1,7 @@
 /**
  * ABAP Service key store - reads ABAP service keys from {destination}.json files
  */
-import type { IServiceKeyStore, IAuthorizationConfig, IConnectionConfig, IConfig } from '@mcp-abap-adt/interfaces';
+import type { IServiceKeyStore, IAuthorizationConfig, IConnectionConfig, IConfig, ILogger } from '@mcp-abap-adt/interfaces';
 /**
  * ABAP Service key store implementation
  *
@@ -10,11 +10,13 @@ import type { IServiceKeyStore, IAuthorizationConfig, IConnectionConfig, IConfig
 export declare class AbapServiceKeyStore implements IServiceKeyStore {
     private directory;
     private parser;
+    private log?;
     /**
      * Create a new AbapServiceKeyStore instance
      * @param directory Directory where service key .json files are located
+     * @param log Optional logger for logging operations
      */
-    constructor(directory: string);
+    constructor(directory: string, log?: ILogger);
     /**
      * Get service key for destination
      * @param destination Destination name (e.g., "TRIAL")