@mcp-abap-adt/auth-broker 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Contributors
+
+Thank you to all contributors! See [CONTRIBUTORS.md](CONTRIBUTORS.md) for the complete list.
+
+## [0.1.0] - 2025-01-XX
+
+### Added
+- **AuthBroker class** - Main class for managing JWT authentication tokens
+  - `getToken(destination)` - Get token for destination (loads, validates, refreshes if needed)
+  - `refreshToken(destination)` - Force refresh token using service key or browser authentication
+  - `clearCache(destination)` - Clear cached token for specific destination
+  - `clearAllCache()` - Clear all cached tokens
+- **Multi-path file search** - Configurable search paths for `.env` and `.json` files
+  - Constructor parameter (highest priority)
+  - `AUTH_BROKER_PATH` environment variable
+  - Current working directory (fallback)
+- **Token management**
+  - Automatic token validation before use
+  - Automatic token refresh when expired
+  - In-memory token caching for performance
+  - Token expiry information in `.env` file comments
+- **Browser-based OAuth2 authentication**
+  - Automatic browser opening for initial authentication
+  - Configurable browser selection (chrome, edge, firefox, system, none)
+  - Manual URL copy option when browser cannot be opened
+  - OAuth2 callback server with success page
+- **Service key support**
+  - Load service keys from `{destination}.json` files
+  - Support for multiple service key formats (url, abap.url, sap_url)
+  - Extract UAA credentials for token refresh
+- **Environment file management**
+  - Load tokens from `{destination}.env` files
+  - Automatic `.env` file creation after authentication
+  - Atomic file writes for safe updates
+  - Format compatible with `sap-abap-auth` utility
+- **Comprehensive error handling**
+  - Clear error messages with file location instructions
+  - Searched paths listed in error messages
+  - Graceful handling of missing files and invalid configurations
+- **TypeScript support**
+  - Full TypeScript definitions
+  - Type-safe API
+  - Exported types: `EnvConfig`, `ServiceKey`
+- **Configurable logging system**
+  - Injectable logger interface for custom logging implementations
+  - Environment variable `DEBUG_AUTH_LOG` to control debug output
+  - Minimal logging by default (only errors and manual URLs)
+  - Detailed debug logging when `DEBUG_AUTH_LOG=true`
+  - Custom logger support via constructor injection
+- **Testing infrastructure**
+  - Unit tests for all components
+  - Integration tests for authentication flows
+  - Sequential test execution for reliable results
+  - Test scenarios covering error cases, browser auth, and token refresh
+  - Silent test output (no verbose logging during test execution)
+  - Clean test output focusing on failures
+- **Documentation**
+  - Complete API documentation
+  - Architecture documentation
+  - Installation guide
+  - Usage guide with examples
+  - Testing methodology guide
+  - Logging configuration guide
+
+### Changed
+- **Logging behavior**
+  - Default logger now shows minimal output (only errors and manual URLs)
+  - Debug messages only visible when `DEBUG_AUTH_LOG=true`
+  - Browser opening notifications moved to debug level
+  - Token refresh operations logged at debug level
+- **Test output**
+  - Removed verbose logging from test files
+  - Tests now produce clean, focused output
+  - Only test results and errors are displayed
+  - Improved readability and CI/CD integration
+
+### Technical Details
+- **Dependencies**
+  - `@mcp-abap-adt/connection` - Token refresh utilities
+  - `axios` - HTTP requests
+  - `express` - OAuth callback server
+  - `open` - Browser opening utility
+- **Node.js version**: >= 18.0.0
+- **Module system**: CommonJS
+- **Build output**: TypeScript compiled to JavaScript with type definitions
+- **Logging**: Injectable logger interface with environment variable control
+

package/CONTRIBUTORS.md

@@ -0,0 +1,33 @@
+# Contributors
+
+Thank you to all contributors who have helped make `@mcp-abap-adt/auth-broker` better!
+
+## How to Contribute
+
+We welcome contributions! Please see the project documentation for details on how to get started.
+
+## Contributors
+
+<!-- Contributors are listed alphabetically by last name -->
+
+### Core Contributors
+
+- **Oleksii Kyslytsia** - Project creator and maintainer
+
+---
+
+## Recognition
+
+We appreciate every contribution, whether it's:
+- 🐛 Bug reports and fixes
+- ✨ New features and enhancements
+- 📚 Documentation improvements
+- 🧪 Test coverage
+- 💬 Feedback and suggestions
+
+Every contribution helps make `@mcp-abap-adt/auth-broker` better for everyone!
+
+---
+
+**Note:** This list is manually maintained. If you've contributed but don't see your name here, please open an issue or submit a PR to update this file.
+

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Oleksii Kyslytsia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,166 @@
+# @mcp-abap-adt/auth-broker
+
+JWT authentication broker for MCP ABAP ADT server. Manages authentication tokens based on destination headers, automatically loading tokens from `.env` files and refreshing them using service keys when needed.
+
+## Features
+
+- 🔐 **Destination-based Authentication**: Load tokens based on `x-mcp-destination` header
+- 📁 **Environment File Support**: Automatically loads tokens from `{destination}.env` files
+- 🔄 **Automatic Token Refresh**: Refreshes expired tokens using service keys from `{destination}.json` files
+- ✅ **Token Validation**: Validates tokens by testing connection to SAP system
+- 💾 **Token Caching**: In-memory caching for improved performance
+- 🔧 **Configurable Base Path**: Customize where `.env` and `.json` files are stored
+
+## Installation
+
+```bash
+npm install @mcp-abap-adt/auth-broker
+```
+
+## Usage
+
+```typescript
+import { AuthBroker } from '@mcp-abap-adt/auth-broker';
+
+const broker = new AuthBroker('/path/to/destinations', 'chrome');
+
+// Get token for destination (loads from .env, validates, refreshes if needed)
+const token = await broker.getToken('TRIAL');
+
+// Force refresh token using service key
+const newToken = await broker.refreshToken('TRIAL');
+```
+
+## Configuration
+
+### Environment Variables
+
+- `AUTH_BROKER_PATH` - Colon/semicolon-separated paths for searching `.env` and `.json` files (default: current working directory)
+- `DEBUG_AUTH_LOG` - Set to `true` to enable debug logging (default: `false`)
+
+### File Structure
+
+#### Environment File (`{destination}.env`)
+
+```env
+SAP_URL=https://your-system.abap.us10.hana.ondemand.com
+SAP_CLIENT=100
+SAP_JWT_TOKEN=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...
+SAP_REFRESH_TOKEN=refresh_token_string
+SAP_UAA_URL=https://your-account.authentication.us10.hana.ondemand.com
+SAP_UAA_CLIENT_ID=client_id
+SAP_UAA_CLIENT_SECRET=client_secret
+```
+
+#### Service Key File (`{destination}.json`)
+
+```json
+{
+  "url": "https://your-system.abap.us10.hana.ondemand.com",
+  "uaa": {
+    "url": "https://your-account.authentication.us10.hana.ondemand.com",
+    "clientid": "your_client_id",
+    "clientsecret": "your_client_secret"
+  }
+}
+```
+
+## API
+
+### `AuthBroker`
+
+#### Constructor
+
+```typescript
+new AuthBroker(searchPaths?: string | string[], browser?: string)
+```
+
+- `searchPaths` - Optional base directory or array of directories for searching `.env` and `.json` files
+- `browser` - Optional browser name for authentication (`chrome`, `edge`, `firefox`, `system`, `none`). Default: `system`
+
+#### Methods
+
+##### `getToken(destination: string): Promise<string>`
+
+Gets authentication token for destination. Tries to load from `.env` file, validates it, and refreshes if needed.
+
+##### `refreshToken(destination: string): Promise<string>`
+
+Force refresh token for destination using service key from `{destination}.json` file.
+
+##### `clearCache(destination: string): void`
+
+Clear cached token for specific destination.
+
+##### `clearAllCache(): void`
+
+Clear all cached tokens.
+
+## Testing
+
+Tests are located in `src/__tests__/` and use Jest as the test runner.
+
+### Running Tests
+
+```bash
+# Run all tests
+npm test
+
+# Run specific test file (all tests in that file)
+npm test -- getToken.test.ts
+npm test -- refreshToken.test.ts
+
+# Run specific test by name/pattern
+npm test -- getToken.test.ts -t "Test 1"
+npm test -- getToken.test.ts -t "Test 2"
+npm test -- getToken.test.ts -t "Test 3"
+
+# Run test group (e.g., all getToken tests)
+npm test -- getToken.test.ts
+
+# Note: Test 2 requires Test 1 to pass first (test1Passed flag)
+# To run Test 2 alone, you may need to run all tests in the file:
+npm test -- getToken.test.ts
+```
+
+### Test Structure
+
+Tests are designed to run sequentially (guaranteed by `maxWorkers: 1` and `maxConcurrency: 1` in `jest.config.js`):
+
+1. **Test 1**: Verifies error handling for non-existent destination (`NO_EXISTS`)
+   - Requires: `NO_EXISTS.json` should NOT exist
+   
+2. **Test 2**: Tests browser authentication when service key exists but `.env` file doesn't
+   - Requires: `TRIAL.json` must exist, `TRIAL.env` should NOT exist
+   - Will open browser for OAuth authentication
+   
+3. **Test 3**: Tests token refresh using existing `.env` file
+   - Requires: `TRIAL.json` and `TRIAL.env` must exist
+   - Can run independently if `.env` file exists (created manually or by Test 2)
+
+### Test Setup
+
+Place your service key file in `./test-destinations/TRIAL.json` to run tests 2 and 3.
+
+Tests will automatically skip if required files are missing or present when they shouldn't be.
+
+## Documentation
+
+Complete documentation is available in the [`docs/`](docs/) directory:
+
+- **[Architecture](docs/architecture/ARCHITECTURE.md)** - System architecture and design decisions
+- **[Development](docs/development/)** - Testing methodology and development roadmap
+- **[Development Roadmap](docs/development/DEVELOPMENT_ROADMAP.md)** - Development roadmap and future plans
+- **[Installation](docs/installing/INSTALLATION.md)** - Installation and setup guide
+- **[Usage](docs/using/USAGE.md)** - API reference and usage examples
+
+See [docs/README.md](docs/README.md) for the complete documentation index.
+
+## Contributors
+
+Thank you to all contributors! See [CONTRIBUTORS.md](CONTRIBUTORS.md) for the complete list.
+
+## License
+
+MIT
+

package/dist/AuthBroker.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Main AuthBroker class for managing JWT tokens based on destinations
+ */
+import { Logger } from './logger';
+/**
+ * AuthBroker manages JWT authentication tokens for destinations
+ */
+export declare class AuthBroker {
+    private searchPaths;
+    private browser;
+    private logger;
+    /**
+     * Create a new AuthBroker instance
+     * @param searchPaths Optional search paths for .env and .json files.
+     *                    Can be a single path (string) or array of paths.
+     *                    Priority:
+     *                    1. Constructor parameter (highest)
+     *                    2. AUTH_BROKER_PATH environment variable (colon/semicolon-separated)
+     *                    3. Current working directory (lowest)
+     * @param browser Optional browser name for authentication (chrome, edge, firefox, system, none).
+     *                Default: 'system' (system default browser).
+     *                Use 'none' to print URL instead of opening browser.
+     * @param logger Optional logger instance. If not provided, uses default logger.
+     */
+    constructor(searchPaths?: string | string[], browser?: string, logger?: Logger);
+    /**
+     * Get authentication token for destination.
+     * Tries to load from .env file, validates it, and refreshes if needed.
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns Promise that resolves to JWT token string
+     * @throws Error if neither .env file nor service key found
+     */
+    getToken(destination: string): Promise<string>;
+    /**
+     * Force refresh token for destination using service key.
+     * If no refresh token exists, starts browser authentication flow.
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns Promise that resolves to new JWT token string
+     */
+    refreshToken(destination: string): Promise<string>;
+    /**
+     * Save token to {destination}.env file
+     * Creates .env file similar to sap-abap-auth utility format
+     * @private
+     */
+    private saveTokenToEnv;
+    /**
+     * Get token expiry information from JWT token
+     * @private
+     */
+    private getTokenExpiry;
+    /**
+     * Clear cached token for specific destination
+     * @param destination Destination name
+     */
+    clearCache(destination: string): void;
+    /**
+     * Clear all cached tokens
+     */
+    clearAllCache(): void;
+}
+//# sourceMappingURL=AuthBroker.d.ts.map

package/dist/AuthBroker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthBroker.d.ts","sourceRoot":"","sources":["../src/AuthBroker.ts"],"names":[],"mappings":"AAAA;;GAEG;AAYH,OAAO,EAAE,MAAM,EAAiB,MAAM,UAAU,CAAC;AAIjD;;GAEG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,MAAM,CAAS;IAEvB;;;;;;;;;;;;OAYG;gBACS,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAM9E;;;;;;OAMG;IACG,QAAQ,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKpD;;;;;OAKG;IACG,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKxD;;;;OAIG;YACW,cAAc;IA6E5B;;;OAGG;IACH,OAAO,CAAC,cAAc;IAyCtB;;;OAGG;IACH,UAAU,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAIrC;;OAEG;IACH,aAAa,IAAI,IAAI;CAGtB"}

package/dist/AuthBroker.js

@@ -0,0 +1,219 @@
+"use strict";
+/**
+ * Main AuthBroker class for managing JWT tokens based on destinations
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthBroker = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cache_1 = require("./cache");
+const pathResolver_1 = require("./pathResolver");
+const logger_1 = require("./logger");
+const refreshToken_1 = require("./refreshToken");
+const getToken_1 = require("./getToken");
+/**
+ * AuthBroker manages JWT authentication tokens for destinations
+ */
+class AuthBroker {
+    searchPaths;
+    browser;
+    logger;
+    /**
+     * Create a new AuthBroker instance
+     * @param searchPaths Optional search paths for .env and .json files.
+     *                    Can be a single path (string) or array of paths.
+     *                    Priority:
+     *                    1. Constructor parameter (highest)
+     *                    2. AUTH_BROKER_PATH environment variable (colon/semicolon-separated)
+     *                    3. Current working directory (lowest)
+     * @param browser Optional browser name for authentication (chrome, edge, firefox, system, none).
+     *                Default: 'system' (system default browser).
+     *                Use 'none' to print URL instead of opening browser.
+     * @param logger Optional logger instance. If not provided, uses default logger.
+     */
+    constructor(searchPaths, browser, logger) {
+        this.searchPaths = (0, pathResolver_1.resolveSearchPaths)(searchPaths);
+        this.browser = browser || 'system';
+        this.logger = logger || logger_1.defaultLogger;
+    }
+    /**
+     * Get authentication token for destination.
+     * Tries to load from .env file, validates it, and refreshes if needed.
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns Promise that resolves to JWT token string
+     * @throws Error if neither .env file nor service key found
+     */
+    async getToken(destination) {
+        // Use getToken function with logger
+        return (0, getToken_1.getToken)(destination, this.searchPaths, this.logger);
+    }
+    /**
+     * Force refresh token for destination using service key.
+     * If no refresh token exists, starts browser authentication flow.
+     * @param destination Destination name (e.g., "TRIAL")
+     * @returns Promise that resolves to new JWT token string
+     */
+    async refreshToken(destination) {
+        // Use refreshToken function with logger and browser
+        return (0, refreshToken_1.refreshToken)(destination, this.searchPaths, this.logger);
+    }
+    /**
+     * Save token to {destination}.env file
+     * Creates .env file similar to sap-abap-auth utility format
+     * @private
+     */
+    async saveTokenToEnv(destination, savePath, config) {
+        // Ensure directory exists
+        if (!fs.existsSync(savePath)) {
+            fs.mkdirSync(savePath, { recursive: true });
+        }
+        const envFilePath = path.join(savePath, `${destination}.env`);
+        const tempFilePath = `${envFilePath}.tmp`;
+        // Write to temporary file first (atomic write)
+        // Format similar to sap-abap-auth utility - always create fresh file
+        const envLines = [];
+        // Add token expiry information if we can decode JWT
+        const jwtExpiry = this.getTokenExpiry(config.jwtToken);
+        const refreshExpiry = config.refreshToken ? this.getTokenExpiry(config.refreshToken) : null;
+        if (jwtExpiry || refreshExpiry) {
+            envLines.push('# Token Expiry Information (auto-generated)');
+            if (jwtExpiry) {
+                envLines.push(`# JWT Token expires: ${jwtExpiry.readableDate} (UTC)`);
+                envLines.push(`# JWT Token expires at: ${jwtExpiry.dateString}`);
+            }
+            else {
+                envLines.push('# JWT Token expiry: Unable to determine (token may not be a standard JWT)');
+            }
+            if (refreshExpiry) {
+                envLines.push(`# Refresh Token expires: ${refreshExpiry.readableDate} (UTC)`);
+                envLines.push(`# Refresh Token expires at: ${refreshExpiry.dateString}`);
+            }
+            else if (config.refreshToken) {
+                envLines.push('# Refresh Token expiry: Unable to determine (token may not be a standard JWT)');
+            }
+            envLines.push('');
+        }
+        // Write JWT auth parameters (similar to sap-abap-auth format)
+        // Required fields
+        envLines.push(`SAP_URL=${config.sapUrl}`);
+        if (config.sapClient) {
+            envLines.push(`SAP_CLIENT=${config.sapClient}`);
+        }
+        if (config.language) {
+            envLines.push(`SAP_LANGUAGE=${config.language}`);
+        }
+        envLines.push('TLS_REJECT_UNAUTHORIZED=0');
+        envLines.push('SAP_AUTH_TYPE=jwt');
+        envLines.push(`SAP_JWT_TOKEN=${config.jwtToken}`);
+        if (config.refreshToken) {
+            envLines.push(`SAP_REFRESH_TOKEN=${config.refreshToken}`);
+        }
+        if (config.uaaUrl) {
+            envLines.push(`SAP_UAA_URL=${config.uaaUrl}`);
+        }
+        if (config.uaaClientId) {
+            envLines.push(`SAP_UAA_CLIENT_ID=${config.uaaClientId}`);
+        }
+        if (config.uaaClientSecret) {
+            envLines.push(`SAP_UAA_CLIENT_SECRET=${config.uaaClientSecret}`);
+        }
+        envLines.push('');
+        envLines.push('# For JWT authentication');
+        envLines.push('# SAP_USERNAME=your_username');
+        envLines.push('# SAP_PASSWORD=your_password');
+        const envContent = envLines.join('\n') + '\n';
+        // Write to temp file
+        fs.writeFileSync(tempFilePath, envContent, 'utf8');
+        // Atomic rename
+        fs.renameSync(tempFilePath, envFilePath);
+    }
+    /**
+     * Get token expiry information from JWT token
+     * @private
+     */
+    getTokenExpiry(token) {
+        try {
+            // JWT tokens have format: header.payload.signature
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                return null;
+            }
+            // Decode payload (base64url)
+            const payload = parts[1];
+            // Add padding if needed
+            const padded = payload + '='.repeat((4 - payload.length % 4) % 4);
+            const decoded = Buffer.from(padded.replace(/-/g, '+').replace(/_/g, '/'), 'base64').toString('utf8');
+            const parsed = JSON.parse(decoded);
+            // Check for exp claim
+            if (parsed.exp) {
+                const expiryDate = new Date(parsed.exp * 1000);
+                const readableDate = expiryDate.toLocaleString('en-US', {
+                    weekday: 'long',
+                    year: 'numeric',
+                    month: 'long',
+                    day: 'numeric',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    timeZone: 'UTC',
+                    timeZoneName: 'short',
+                });
+                return {
+                    dateString: expiryDate.toISOString(),
+                    readableDate: readableDate,
+                };
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Clear cached token for specific destination
+     * @param destination Destination name
+     */
+    clearCache(destination) {
+        (0, cache_1.clearCache)(destination);
+    }
+    /**
+     * Clear all cached tokens
+     */
+    clearAllCache() {
+        (0, cache_1.clearAllCache)();
+    }
+}
+exports.AuthBroker = AuthBroker;

package/dist/__tests__/testHelpers.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Common test helpers for AuthBroker tests
+ */
+import { AuthBroker } from '../AuthBroker';
+export declare const TEST_DESTINATIONS_PATH: string;
+export interface TestBrokers {
+    tempDir: string;
+    broker: AuthBroker;
+    testDestinationsBroker: AuthBroker;
+}
+/**
+ * Setup test brokers for a test suite
+ */
+export declare function setupTestBrokers(testName: string): TestBrokers;
+/**
+ * Cleanup test brokers
+ */
+export declare function cleanupTestBrokers(brokers: TestBrokers): void;
+/**
+ * Check if NO_EXISTS.json exists and skip test if it does
+ */
+export declare function checkNoExistsFile(): boolean;
+/**
+ * Prepare Test 2: Remove TRIAL.env if exists, check for TRIAL.json
+ */
+export declare function prepareTest2(): {
+    envFile: string;
+    serviceKeyPath: string;
+    shouldSkip: boolean;
+};
+/**
+ * Prepare Test 3: Check for TRIAL.json and TRIAL.env
+ */
+export declare function prepareTest3(): {
+    envFile: string;
+    serviceKeyPath: string;
+    sapUrl: string;
+    shouldSkip: boolean;
+};
+/**
+ * Verify .env file contains required tokens
+ */
+export declare function verifyEnvFile(envFile: string, requireRefreshToken?: boolean): void;
+//# sourceMappingURL=testHelpers.d.ts.map

package/dist/__tests__/testHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testHelpers.d.ts","sourceRoot":"","sources":["../../src/__tests__/testHelpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAI3C,eAAO,MAAM,sBAAsB,QAAsF,CAAC;AAE1H,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,UAAU,CAAC;IACnB,sBAAsB,EAAE,UAAU,CAAC;CACpC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAM9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CAM7D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAM3C;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAe/F;AAED;;GAEG;AACH,wBAAgB,YAAY,IAAI;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAE,CAsB/G;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,mBAAmB,GAAE,OAAe,GAAG,IAAI,CAOzF"}