@babamba2/mcp-abap-connection 1.5.3

package/dist/connection/RfcAbapConnection.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RfcAbapConnection = void 0;
+const node_crypto_1 = require("node:crypto");
+/**
+ * Derive RFC connection parameters from ISapConfig.
+ * Parses hostname from config.url, system number from port (80XX → XX).
+ *
+ * Examples:
+ *   http://saphost:8000  → ashost=saphost, sysnr=00
+ *   http://saphost:8001  → ashost=saphost, sysnr=01
+ *   http://saphost:8042  → ashost=saphost, sysnr=42
+ */
+function buildRfcParams(config) {
+    const parsed = new URL(config.url);
+    const port = Number.parseInt(parsed.port || '8000', 10);
+    // SAP HTTP port convention: 80XX where XX = system number
+    const sysnr = String(port - 8000).padStart(2, '0');
+    return {
+        ashost: parsed.hostname,
+        sysnr,
+        client: config.client || '000',
+        user: config.username || '',
+        passwd: config.password || '',
+        lang: 'EN',
+    };
+}
+/**
+ * Map ADT exception type names to HTTP status codes.
+ * These are standard ADT exception types returned in `<exc:exception>` XML.
+ */
+const EXCEPTION_STATUS_MAP = {
+    ExceptionResourceNotFound: { code: 404, text: 'Not Found' },
+    ExceptionResourceNoAuthorization: { code: 403, text: 'Forbidden' },
+    ExceptionResourceAlreadyExists: { code: 409, text: 'Conflict' },
+    ExceptionResourceLocked: { code: 423, text: 'Locked' },
+    ExceptionBadRequest: { code: 400, text: 'Bad Request' },
+    ExceptionNotSupported: { code: 501, text: 'Not Implemented' },
+    ExceptionConflict: { code: 409, text: 'Conflict' },
+};
+/**
+ * Detect HTTP status from ADT exception XML in response body.
+ * On some legacy systems, SADT_REST_RFC_ENDPOINT returns errors as XML
+ * exceptions without setting proper HTTP status codes in STATUS_LINE.
+ */
+function detectExceptionStatus(body) {
+    // Extract exception type: <exc:exception ... xmlns:exc="..."><exc:type>ExceptionName</exc:type>
+    const typeMatch = body.match(/<exc:type[^>]*>([^<]+)<\/exc:type>/);
+    if (typeMatch) {
+        const exType = typeMatch[1].trim();
+        const mapped = EXCEPTION_STATUS_MAP[exType];
+        if (mapped) {
+            return { statusCode: mapped.code, statusText: mapped.text };
+        }
+    }
+    // Unknown exception type — return 500 as generic server error
+    return { statusCode: 500, statusText: 'Internal Server Error' };
+}
+/**
+ * RFC-based connection for on-premise SAP systems.
+ *
+ * Uses node-rfc to call SADT_REST_RFC_ENDPOINT — the same standard SAP FM
+ * that Eclipse ADT uses for all on-premise ADT operations via JCo.
+ *
+ * RFC connections are inherently stateful: one ABAP session persists for the
+ * entire connection lifetime. This solves the HTTP 423 "invalid lock handle"
+ * problem on legacy systems (BASIS < 7.50) where HTTP stateful sessions
+ * are not supported.
+ *
+ * Connection parameters are derived from the standard ISapConfig.url field:
+ *   http://saphost:8000 → ashost=saphost, sysnr=00
+ *
+ * Prerequisites:
+ *   - SAP NW RFC SDK installed on the machine
+ *   - node-rfc package installed: npm install node-rfc
+ */
+class RfcAbapConnection {
+    config;
+    logger;
+    rfcClient = null;
+    sessionId;
+    baseUrl;
+    rfcParams;
+    sessionType = 'stateless';
+    sessionCookie = null;
+    constructor(config, logger = null) {
+        this.config = config;
+        this.logger = logger;
+        RfcAbapConnection.validateConfig(config);
+        this.sessionId = (0, node_crypto_1.randomUUID)();
+        this.baseUrl = config.url;
+        this.rfcParams = buildRfcParams(config);
+        this.logger?.debug(`RfcAbapConnection created for ${this.rfcParams.ashost}:${this.rfcParams.sysnr}, client ${this.rfcParams.client}`);
+    }
+    async connect() {
+        let Client;
+        try {
+            // Dynamic require — node-rfc is NOT a declared dependency.
+            // Users who need RFC connections must install it manually:
+            //   npm install node-rfc (+ SAP NW RFC SDK on the machine)
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const noderfc = require('node-rfc');
+            Client = noderfc.Client;
+        }
+        catch (e) {
+            throw new Error('node-rfc is not available. To use RFC connections, install SAP NW RFC SDK ' +
+                'and run: npm install node-rfc. ' +
+                `Details: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        this.rfcClient = new Client(this.rfcParams);
+        try {
+            await this.rfcClient.open();
+            this.logger?.debug('RFC connection opened (stateful session)');
+        }
+        catch (e) {
+            this.rfcClient = null;
+            const msg = e instanceof Error ? e.message : String(e);
+            this.logger?.error(`RFC connection failed: ${msg}`);
+            throw new Error(`Failed to open RFC connection: ${msg}`);
+        }
+    }
+    async getBaseUrl() {
+        return this.baseUrl;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    setSessionType(type) {
+        this.sessionType = type;
+        if (type === 'stateless') {
+            this.sessionCookie = null;
+            this.logger?.debug('RFC session type: stateless (cookie cleared)');
+        }
+        else {
+            this.logger?.debug('RFC session type: stateful (will capture cookies)');
+        }
+    }
+    async makeAdtRequest(options) {
+        if (!this.rfcClient?.alive) {
+            throw new Error('RFC connection is not open. Call connect() first.');
+        }
+        const method = options.method.toUpperCase();
+        // Encode query params into URI (axios does this automatically for HTTP,
+        // but RFC needs it done manually)
+        let uri = options.url;
+        if (options.params && typeof options.params === 'object') {
+            const entries = Object.entries(options.params).filter(([, v]) => v !== undefined && v !== null);
+            if (entries.length > 0) {
+                const qs = new URLSearchParams(entries.map(([k, v]) => [k, String(v)]));
+                uri += (uri.includes('?') ? '&' : '?') + qs.toString();
+            }
+        }
+        // Note: sap-client is NOT added to URI for RFC connections.
+        // The RFC session is already logged into the correct client
+        // (via the 'client' param in RFC connection). Adding sap-client
+        // to the URI can cause "object not found" on some systems.
+        // Build header fields
+        const headerFields = [];
+        if (options.headers) {
+            for (const [name, value] of Object.entries(options.headers)) {
+                headerFields.push({ NAME: name, VALUE: value });
+            }
+        }
+        // Inject session type header so SAP creates/maintains an ICM session
+        if (this.sessionType === 'stateful') {
+            headerFields.push({ NAME: 'x-sap-adt-sessiontype', VALUE: 'stateful' });
+        }
+        // Replay session cookie for stateful operations (cookie captured from LOCK response)
+        if (this.sessionCookie) {
+            const existingCookie = headerFields.find((h) => h.NAME.toLowerCase() === 'cookie');
+            if (!existingCookie) {
+                headerFields.push({ NAME: 'Cookie', VALUE: this.sessionCookie });
+            }
+        }
+        // Ensure Content-Type for body
+        const body = options.data !== undefined && options.data !== null
+            ? String(options.data)
+            : '';
+        if (body &&
+            !headerFields.some((h) => h.NAME.toLowerCase() === 'content-type')) {
+            headerFields.push({
+                NAME: 'Content-Type',
+                VALUE: 'text/plain; charset=utf-8',
+            });
+        }
+        this.logger?.debug(`RFC → ${method} ${uri}`);
+        this.logger?.debug(`RFC → headers: ${JSON.stringify(headerFields)}`);
+        if (body)
+            this.logger?.debug(`RFC → body: ${body}`);
+        try {
+            const result = await this.rfcClient.call('SADT_REST_RFC_ENDPOINT', {
+                REQUEST: {
+                    REQUEST_LINE: {
+                        METHOD: method,
+                        URI: uri,
+                        VERSION: 'HTTP/1.1',
+                    },
+                    HEADER_FIELDS: headerFields,
+                    MESSAGE_BODY: body ? Buffer.from(body, 'utf-8') : Buffer.alloc(0),
+                },
+            });
+            const resp = result.RESPONSE || result;
+            // Log raw RFC response structure for debugging
+            this.logger?.debug(`RFC raw response keys: ${Object.keys(resp).join(', ')}`);
+            if (resp.STATUS_LINE) {
+                this.logger?.debug(`RFC STATUS_LINE: ${JSON.stringify(resp.STATUS_LINE)}`);
+            }
+            // Parse status — RFC returns status in STATUS_LINE structure
+            // Field names: STATUS_CODE (not CODE), REASON_PHRASE (not REASON)
+            const rawCode = resp.STATUS_LINE?.STATUS_CODE || resp.STATUS_LINE?.CODE || 0;
+            let statusCode = typeof rawCode === 'string' ? Number.parseInt(rawCode, 10) : rawCode;
+            let statusText = resp.STATUS_LINE?.REASON_PHRASE || resp.STATUS_LINE?.REASON || '';
+            // Parse response body
+            const respBody = resp.MESSAGE_BODY
+                ? Buffer.isBuffer(resp.MESSAGE_BODY)
+                    ? resp.MESSAGE_BODY.toString('utf-8')
+                    : String(resp.MESSAGE_BODY)
+                : '';
+            // Parse response headers
+            const respHeaders = {};
+            const respHeaderFields = resp.HEADER_FIELDS || [];
+            for (const field of respHeaderFields) {
+                if (field.NAME && field.VALUE !== undefined) {
+                    respHeaders[field.NAME.toLowerCase()] = field.VALUE;
+                }
+            }
+            // Capture session cookie from LOCK/stateful responses for cookie replay
+            if (this.sessionType === 'stateful' && respHeaders['set-cookie']) {
+                const setCookieHeader = respHeaders['set-cookie'];
+                // Extract cookie name=value pairs (strip attributes like Path, Secure, etc.)
+                const cookies = Array.isArray(setCookieHeader)
+                    ? setCookieHeader
+                    : [setCookieHeader];
+                const cookieValues = cookies
+                    .map((c) => c.split(';')[0].trim())
+                    .filter(Boolean);
+                if (cookieValues.length > 0) {
+                    this.sessionCookie = cookieValues.join('; ');
+                    this.logger?.debug(`RFC: captured session cookie: ${this.sessionCookie}`);
+                }
+            }
+            // On some systems (e.g. BASIS < 7.50), SADT_REST_RFC_ENDPOINT does not
+            // populate STATUS_LINE, returning status 0. Detect errors from the
+            // response body: ADT exception XML indicates a failed request.
+            if (!statusCode && respBody.includes('<exc:exception')) {
+                const detected = detectExceptionStatus(respBody);
+                statusCode = detected.statusCode;
+                statusText = detected.statusText;
+                this.logger?.debug(`RFC: STATUS_LINE empty, detected ${statusCode} from exception XML`);
+            }
+            // Default to 200 OK only when no error was detected
+            if (!statusCode) {
+                statusCode = 200;
+                statusText = statusText || 'OK';
+            }
+            this.logger?.debug(`RFC ← ${statusCode} ${statusText} (${respBody.length} bytes)`);
+            this.logger?.debug(`RFC ← headers: ${JSON.stringify(respHeaders)}`);
+            if (respBody)
+                this.logger?.debug(`RFC ← body: ${respBody}`);
+            const response = {
+                data: respBody,
+                status: statusCode,
+                statusText,
+                headers: respHeaders,
+            };
+            // Throw for error status codes (matching HTTP/axios behavior)
+            if (statusCode >= 400) {
+                const error = new Error(`Request failed with status ${statusCode}: ${method} ${uri}`);
+                error.response = response;
+                throw error;
+            }
+            return response;
+        }
+        catch (e) {
+            // Re-throw our own errors (status >= 400)
+            if (e?.response) {
+                throw e;
+            }
+            // RFC-level error
+            const msg = e instanceof Error ? e.message : String(e);
+            this.logger?.error(`RFC call failed: ${msg}`);
+            throw new Error(`RFC call to SADT_REST_RFC_ENDPOINT failed: ${msg}`);
+        }
+    }
+    /**
+     * Reset the connection — for RFC this closes the session.
+     * Provides interface compatibility with HTTP connections.
+     */
+    reset() {
+        this.close();
+    }
+    /**
+     * Close the RFC connection and release the ABAP session.
+     */
+    async close() {
+        if (this.rfcClient) {
+            try {
+                await this.rfcClient.close();
+                this.logger?.debug('RFC connection closed');
+            }
+            catch (e) {
+                this.logger?.debug(`RFC close error: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            this.rfcClient = null;
+        }
+    }
+    static validateConfig(config) {
+        if (config.connectionType !== 'rfc') {
+            throw new Error(`RFC connection expects connectionType "rfc", got "${config.connectionType}"`);
+        }
+        if (!config.url) {
+            throw new Error('RFC connection requires url (hostname is parsed from it)');
+        }
+        if (!config.username || !config.password) {
+            throw new Error('RFC connection requires both username and password');
+        }
+        if (!config.client) {
+            throw new Error('RFC connection requires SAP client');
+        }
+    }
+}
+exports.RfcAbapConnection = RfcAbapConnection;

package/dist/connection/SamlAbapConnection.d.ts

@@ -0,0 +1,21 @@
+import type { SapConfig } from '../config/sapConfig.js';
+import type { ILogger } from '../logger.js';
+import { AbstractAbapConnection } from './AbstractAbapConnection.js';
+/**
+ * SAML session cookie authentication for SAP systems
+ */
+export declare class SamlAbapConnection extends AbstractAbapConnection {
+    private sessionCookies;
+    constructor(config: SapConfig, logger?: ILogger | null, sessionId?: string, options?: {
+        skipSessionType?: boolean;
+    });
+    /**
+     * Connect to SAP system using existing session cookies
+     * Fetches CSRF token to establish session context
+     */
+    connect(): Promise<void>;
+    protected buildAuthorizationHeader(): string;
+    getAuthHeaders(): Promise<Record<string, string>>;
+    private static validateConfig;
+}
+//# sourceMappingURL=SamlAbapConnection.d.ts.map

package/dist/connection/SamlAbapConnection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SamlAbapConnection.d.ts","sourceRoot":"","sources":["../../src/connection/SamlAbapConnection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AAErE;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,sBAAsB;IAC5D,OAAO,CAAC,cAAc,CAAS;gBAG7B,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE;IAUzC;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiC9B,SAAS,CAAC,wBAAwB,IAAI,MAAM;IAItC,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAQvD,OAAO,CAAC,MAAM,CAAC,cAAc;CAW9B"}

package/dist/connection/SamlAbapConnection.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SamlAbapConnection = void 0;
+const axios_1 = require("axios");
+const AbstractAbapConnection_js_1 = require("./AbstractAbapConnection.js");
+/**
+ * SAML session cookie authentication for SAP systems
+ */
+class SamlAbapConnection extends AbstractAbapConnection_js_1.AbstractAbapConnection {
+    sessionCookies;
+    constructor(config, logger, sessionId, options) {
+        SamlAbapConnection.validateConfig(config);
+        super(config, logger || null, sessionId, options);
+        this.sessionCookies = config.sessionCookies || '';
+        if (this.sessionCookies) {
+            this.setInitialCookies(this.sessionCookies);
+        }
+    }
+    /**
+     * Connect to SAP system using existing session cookies
+     * Fetches CSRF token to establish session context
+     */
+    async connect() {
+        const baseUrl = await this.getBaseUrl();
+        const discoveryUrl = `${baseUrl}/sap/bc/adt/discovery`;
+        this.logger?.debug(`[DEBUG] SamlAbapConnection - Connecting to SAP system: ${discoveryUrl}`);
+        try {
+            const token = await this.fetchCsrfToken(discoveryUrl, 3, 1000);
+            this.setCsrfToken(token);
+            this.logger?.debug('Successfully connected to SAP system', {
+                hasCsrfToken: !!this.getCsrfToken(),
+                hasCookies: !!this.getCookies(),
+                cookieLength: this.getCookies()?.length || 0,
+            });
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logger?.warn(`[WARN] SamlAbapConnection - Could not connect to SAP system upfront: ${errorMsg}. Will retry on first request.`);
+            if (error instanceof axios_1.AxiosError && error.response?.headers) {
+                if (this.getCookies()) {
+                    this.logger?.debug(`[DEBUG] SamlAbapConnection - Cookies extracted from error response during connect (first 100 chars): ${this.getCookies()?.substring(0, 100)}...`);
+                }
+            }
+        }
+    }
+    buildAuthorizationHeader() {
+        return '';
+    }
+    async getAuthHeaders() {
+        const headers = await super.getAuthHeaders();
+        if (this.sessionCookies) {
+            headers.Cookie = this.sessionCookies;
+        }
+        return headers;
+    }
+    static validateConfig(config) {
+        if (config.authType !== 'saml') {
+            throw new Error(`SAML connection expects authType "saml", got "${config.authType}"`);
+        }
+        if (!config.sessionCookies) {
+            throw new Error('SAML authentication requires sessionCookies');
+        }
+    }
+}
+exports.SamlAbapConnection = SamlAbapConnection;

package/dist/connection/connectionFactory.d.ts

@@ -0,0 +1,8 @@
+import type { ITokenRefresher } from '@babamba2/mcp-abap-adt-interfaces';
+import type { SapConfig } from '../config/sapConfig.js';
+import type { ILogger } from '../logger.js';
+import type { AbapConnection } from './AbapConnection.js';
+export declare function createAbapConnection(config: SapConfig, logger?: ILogger | null, sessionId?: string, tokenRefresher?: ITokenRefresher, options?: {
+    skipSessionType?: boolean;
+}): AbapConnection;
+//# sourceMappingURL=connectionFactory.d.ts.map

package/dist/connection/connectionFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectionFactory.d.ts","sourceRoot":"","sources":["../../src/connection/connectionFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAM1D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,OAAO,GAAG,IAAI,EACvB,SAAS,CAAC,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,eAAe,EAChC,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,GACtC,cAAc,CAkBhB"}

package/dist/connection/connectionFactory.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAbapConnection = createAbapConnection;
+const BaseAbapConnection_js_1 = require("./BaseAbapConnection.js");
+const JwtAbapConnection_js_1 = require("./JwtAbapConnection.js");
+const RfcAbapConnection_js_1 = require("./RfcAbapConnection.js");
+const SamlAbapConnection_js_1 = require("./SamlAbapConnection.js");
+function createAbapConnection(config, logger, sessionId, tokenRefresher, options) {
+    // RFC connection type takes priority over auth type
+    if (config.connectionType === 'rfc') {
+        return new RfcAbapConnection_js_1.RfcAbapConnection(config, logger);
+    }
+    switch (config.authType) {
+        case 'basic':
+            return new BaseAbapConnection_js_1.BaseAbapConnection(config, logger, sessionId, options);
+        case 'jwt':
+            return new JwtAbapConnection_js_1.JwtAbapConnection(config, logger, sessionId, tokenRefresher);
+        case 'saml':
+            return new SamlAbapConnection_js_1.SamlAbapConnection(config, logger, sessionId, options);
+        default:
+            throw new Error(`Unsupported SAP authentication type: ${config.authType}`);
+    }
+}

package/dist/connection/csrfConfig.d.ts

@@ -0,0 +1,46 @@
+/**
+ * CSRF Token Configuration
+ *
+ * Centralized constants for CSRF token fetching to ensure consistency
+ * across different connection implementations.
+ */
+export declare const CSRF_CONFIG: {
+    /**
+     * Number of retry attempts for CSRF token fetch
+     * Default: 3 attempts (total of 4 requests: initial + 3 retries)
+     */
+    readonly RETRY_COUNT: 3;
+    /**
+     * Delay between retry attempts (milliseconds)
+     * Default: 1000ms (1 second)
+     */
+    readonly RETRY_DELAY: 1000;
+    /**
+     * CSRF token endpoint path (primary)
+     * Standard SAP ADT core discovery endpoint (newer systems, returns smaller response)
+     */
+    readonly ENDPOINT: "/sap/bc/adt/core/discovery";
+    /**
+     * CSRF token endpoint path (fallback)
+     * Legacy SAP ADT discovery endpoint for older systems (e.g. BASIS < 7.52)
+     * that don't have /sap/bc/adt/core/discovery
+     */
+    readonly FALLBACK_ENDPOINT: "/sap/bc/adt/discovery";
+    /**
+     * Required headers for CSRF token fetch
+     */
+    readonly REQUIRED_HEADERS: {
+        readonly 'x-csrf-token': "fetch";
+        readonly Accept: "application/atomsvc+xml";
+    };
+};
+/**
+ * CSRF token error messages
+ * Standardized error messages for consistent error reporting
+ */
+export declare const CSRF_ERROR_MESSAGES: {
+    readonly FETCH_FAILED: (attempts: number, cause: string) => string;
+    readonly NOT_IN_HEADERS: "No CSRF token in response headers";
+    readonly REQUIRED_FOR_MUTATION: "CSRF token is required for POST/PUT requests but could not be fetched";
+};
+//# sourceMappingURL=csrfConfig.d.ts.map

package/dist/connection/csrfConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"csrfConfig.d.ts","sourceRoot":"","sources":["../../src/connection/csrfConfig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,WAAW;IACtB;;;OAGG;;IAGH;;;OAGG;;IAGH;;;OAGG;;IAGH;;;;OAIG;;IAGH;;OAEG;;;;;CAKK,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,mBAAmB;sCACL,MAAM,SAAS,MAAM;;;CAOtC,CAAC"}

package/dist/connection/csrfConfig.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CSRF_ERROR_MESSAGES = exports.CSRF_CONFIG = void 0;
+/**
+ * CSRF Token Configuration
+ *
+ * Centralized constants for CSRF token fetching to ensure consistency
+ * across different connection implementations.
+ */
+exports.CSRF_CONFIG = {
+    /**
+     * Number of retry attempts for CSRF token fetch
+     * Default: 3 attempts (total of 4 requests: initial + 3 retries)
+     */
+    RETRY_COUNT: 3,
+    /**
+     * Delay between retry attempts (milliseconds)
+     * Default: 1000ms (1 second)
+     */
+    RETRY_DELAY: 1000,
+    /**
+     * CSRF token endpoint path (primary)
+     * Standard SAP ADT core discovery endpoint (newer systems, returns smaller response)
+     */
+    ENDPOINT: '/sap/bc/adt/core/discovery',
+    /**
+     * CSRF token endpoint path (fallback)
+     * Legacy SAP ADT discovery endpoint for older systems (e.g. BASIS < 7.52)
+     * that don't have /sap/bc/adt/core/discovery
+     */
+    FALLBACK_ENDPOINT: '/sap/bc/adt/discovery',
+    /**
+     * Required headers for CSRF token fetch
+     */
+    REQUIRED_HEADERS: {
+        'x-csrf-token': 'fetch',
+        Accept: 'application/atomsvc+xml',
+    },
+};
+/**
+ * CSRF token error messages
+ * Standardized error messages for consistent error reporting
+ */
+exports.CSRF_ERROR_MESSAGES = {
+    FETCH_FAILED: (attempts, cause) => `Failed to fetch CSRF token after ${attempts} attempts: ${cause}`,
+    NOT_IN_HEADERS: 'No CSRF token in response headers',
+    REQUIRED_FOR_MUTATION: 'CSRF token is required for POST/PUT requests but could not be fetched',
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export type { IWebSocketCloseInfo, IWebSocketConnectOptions, IWebSocketMessageEnvelope, IWebSocketMessageHandler, IWebSocketTransport, } from '@babamba2/mcp-abap-adt-interfaces';
+export type { SapAuthType, SapConfig, SapConnectionType, } from './config/sapConfig.js';
+export { sapConfigSignature } from './config/sapConfig.js';
+export type { AbapConnection, AbapRequestOptions, } from './connection/AbapConnection.js';
+export { BaseAbapConnection, BaseAbapConnection as OnPremAbapConnection, } from './connection/BaseAbapConnection.js';
+export { createAbapConnection } from './connection/connectionFactory.js';
+export { CSRF_CONFIG, CSRF_ERROR_MESSAGES } from './connection/csrfConfig.js';
+export { GenericWebSocketTransport, type IWebSocketFactory, type IWebSocketLike, } from './connection/GenericWebSocketTransport.js';
+export { JwtAbapConnection, JwtAbapConnection as CloudAbapConnection, } from './connection/JwtAbapConnection.js';
+export { RfcAbapConnection } from './connection/RfcAbapConnection.js';
+export { SamlAbapConnection } from './connection/SamlAbapConnection.js';
+export type { ILogger } from './logger.js';
+export { getTimeout, getTimeoutConfig, type TimeoutConfig, } from './utils/timeouts.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,YAAY,EACV,mBAAmB,EACnB,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,mCAAmC,CAAC;AAC3C,YAAY,EACV,WAAW,EACX,SAAS,EACT,iBAAiB,GAClB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,YAAY,EACV,cAAc,EACd,kBAAkB,GACnB,MAAM,gCAAgC,CAAC;AAGxC,OAAO,EACL,kBAAkB,EAClB,kBAAkB,IAAI,oBAAoB,GAC3C,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,KAAK,iBAAiB,EACtB,KAAK,cAAc,GACpB,MAAM,2CAA2C,CAAC;AACnD,OAAO,EACL,iBAAiB,EACjB,iBAAiB,IAAI,mBAAmB,GACzC,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AACxE,YAAY,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+// Types - re-exported from interfaces package with backward compatibility aliases
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeoutConfig = exports.getTimeout = exports.SamlAbapConnection = exports.RfcAbapConnection = exports.CloudAbapConnection = exports.JwtAbapConnection = exports.GenericWebSocketTransport = exports.CSRF_ERROR_MESSAGES = exports.CSRF_CONFIG = exports.createAbapConnection = exports.OnPremAbapConnection = exports.BaseAbapConnection = exports.sapConfigSignature = void 0;
+// Config utilities
+var sapConfig_js_1 = require("./config/sapConfig.js");
+Object.defineProperty(exports, "sapConfigSignature", { enumerable: true, get: function () { return sapConfig_js_1.sapConfigSignature; } });
+// Connection classes - only final implementations
+// Deprecated aliases for backward compatibility
+var BaseAbapConnection_js_1 = require("./connection/BaseAbapConnection.js");
+Object.defineProperty(exports, "BaseAbapConnection", { enumerable: true, get: function () { return BaseAbapConnection_js_1.BaseAbapConnection; } });
+Object.defineProperty(exports, "OnPremAbapConnection", { enumerable: true, get: function () { return BaseAbapConnection_js_1.BaseAbapConnection; } });
+// Factory
+var connectionFactory_js_1 = require("./connection/connectionFactory.js");
+Object.defineProperty(exports, "createAbapConnection", { enumerable: true, get: function () { return connectionFactory_js_1.createAbapConnection; } });
+// CSRF configuration
+var csrfConfig_js_1 = require("./connection/csrfConfig.js");
+Object.defineProperty(exports, "CSRF_CONFIG", { enumerable: true, get: function () { return csrfConfig_js_1.CSRF_CONFIG; } });
+Object.defineProperty(exports, "CSRF_ERROR_MESSAGES", { enumerable: true, get: function () { return csrfConfig_js_1.CSRF_ERROR_MESSAGES; } });
+var GenericWebSocketTransport_js_1 = require("./connection/GenericWebSocketTransport.js");
+Object.defineProperty(exports, "GenericWebSocketTransport", { enumerable: true, get: function () { return GenericWebSocketTransport_js_1.GenericWebSocketTransport; } });
+var JwtAbapConnection_js_1 = require("./connection/JwtAbapConnection.js");
+Object.defineProperty(exports, "JwtAbapConnection", { enumerable: true, get: function () { return JwtAbapConnection_js_1.JwtAbapConnection; } });
+Object.defineProperty(exports, "CloudAbapConnection", { enumerable: true, get: function () { return JwtAbapConnection_js_1.JwtAbapConnection; } });
+var RfcAbapConnection_js_1 = require("./connection/RfcAbapConnection.js");
+Object.defineProperty(exports, "RfcAbapConnection", { enumerable: true, get: function () { return RfcAbapConnection_js_1.RfcAbapConnection; } });
+var SamlAbapConnection_js_1 = require("./connection/SamlAbapConnection.js");
+Object.defineProperty(exports, "SamlAbapConnection", { enumerable: true, get: function () { return SamlAbapConnection_js_1.SamlAbapConnection; } });
+// Timeouts
+var timeouts_js_1 = require("./utils/timeouts.js");
+Object.defineProperty(exports, "getTimeout", { enumerable: true, get: function () { return timeouts_js_1.getTimeout; } });
+Object.defineProperty(exports, "getTimeoutConfig", { enumerable: true, get: function () { return timeouts_js_1.getTimeoutConfig; } });

package/dist/logger.d.ts

@@ -0,0 +1,3 @@
+import type { ILogger } from '@babamba2/mcp-abap-adt-interfaces';
+export type { ILogger };
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAGjE,YAAY,EAAE,OAAO,EAAE,CAAC"}

package/dist/logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/timeouts.d.ts

@@ -0,0 +1,5 @@
+import type { ITimeoutConfig } from '@babamba2/mcp-abap-adt-interfaces';
+export type TimeoutConfig = ITimeoutConfig;
+export declare function getTimeoutConfig(): ITimeoutConfig;
+export declare function getTimeout(type?: 'default' | 'csrf' | 'long' | number): number;
+//# sourceMappingURL=timeouts.d.ts.map

package/dist/utils/timeouts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeouts.d.ts","sourceRoot":"","sources":["../../src/utils/timeouts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AAGxE,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC;AAE3C,wBAAgB,gBAAgB,IAAI,cAAc,CAajD;AAED,wBAAgB,UAAU,CACxB,IAAI,GAAE,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAkB,GACrD,MAAM,CAOR"}

package/dist/utils/timeouts.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeoutConfig = getTimeoutConfig;
+exports.getTimeout = getTimeout;
+function getTimeoutConfig() {
+    const defaultTimeout = parseInt(process.env.SAP_TIMEOUT_DEFAULT || '45000', 10);
+    const csrfTimeout = parseInt(process.env.SAP_TIMEOUT_CSRF || '15000', 10);
+    const longTimeout = parseInt(process.env.SAP_TIMEOUT_LONG || '60000', 10);
+    return {
+        default: defaultTimeout,
+        csrf: csrfTimeout,
+        long: longTimeout,
+    };
+}
+function getTimeout(type = 'default') {
+    if (typeof type === 'number') {
+        return type;
+    }
+    const config = getTimeoutConfig();
+    return config[type];
+}