@mcp-abap-adt/proxy 0.1.1

package/dist/lib/config.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Configuration management for MCP ABAP ADT Proxy
+ */
+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.loadConfig = loadConfig;
+exports.validateConfig = validateConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Load configuration from file if exists, otherwise from environment variables
+ */
+function loadConfig(configPath) {
+    // Try to load from config file first
+    if (configPath || process.env.MCP_PROXY_CONFIG) {
+        const filePath = configPath || process.env.MCP_PROXY_CONFIG;
+        try {
+            if (fs.existsSync(filePath)) {
+                const configContent = fs.readFileSync(filePath, "utf-8");
+                const fileConfig = JSON.parse(configContent);
+                return mergeConfig(fileConfig, loadFromEnv());
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to load config from file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    // Try default config file locations
+    const defaultPaths = [
+        path.join(process.cwd(), "mcp-proxy-config.json"),
+        path.join(process.cwd(), ".mcp-proxy-config.json"),
+        path.join(process.env.HOME || process.env.USERPROFILE || "", ".mcp-proxy-config.json"),
+    ];
+    for (const configPath of defaultPaths) {
+        try {
+            if (fs.existsSync(configPath)) {
+                const configContent = fs.readFileSync(configPath, "utf-8");
+                const fileConfig = JSON.parse(configContent);
+                return mergeConfig(fileConfig, loadFromEnv());
+            }
+        }
+        catch (error) {
+            // Continue to next path
+        }
+    }
+    // Fall back to environment variables only
+    return loadFromEnv();
+}
+/**
+ * Load configuration from environment variables and command line
+ */
+function loadFromEnv() {
+    // Parse command line arguments for --btp, --mcp, --mcp-url, and --unsafe
+    const btpDestination = getArgValue("--btp");
+    const mcpDestination = getArgValue("--mcp");
+    const mcpUrl = getArgValue("--mcp-url");
+    const unsafe = hasArg("--unsafe") || process.env.MCP_PROXY_UNSAFE === "true";
+    return {
+        cloudLlmHubUrl: process.env.CLOUD_LLM_HUB_URL || "",
+        httpPort: parseInt(process.env.MCP_HTTP_PORT || "3001", 10),
+        ssePort: parseInt(process.env.MCP_SSE_PORT || "3002", 10),
+        httpHost: process.env.MCP_HTTP_HOST || "0.0.0.0",
+        sseHost: process.env.MCP_SSE_HOST || "0.0.0.0",
+        logLevel: process.env.LOG_LEVEL || "info",
+        btpDestination,
+        mcpDestination,
+        mcpUrl: mcpUrl || process.env.MCP_URL,
+        unsafe,
+        maxRetries: parseInt(process.env.MCP_PROXY_MAX_RETRIES || "3", 10),
+        retryDelay: parseInt(process.env.MCP_PROXY_RETRY_DELAY || "1000", 10),
+        requestTimeout: parseInt(process.env.MCP_PROXY_REQUEST_TIMEOUT || "60000", 10),
+        circuitBreakerThreshold: parseInt(process.env.MCP_PROXY_CIRCUIT_BREAKER_THRESHOLD || "5", 10),
+        circuitBreakerTimeout: parseInt(process.env.MCP_PROXY_CIRCUIT_BREAKER_TIMEOUT || "60000", 10),
+    };
+}
+/**
+ * Get argument value from command line
+ */
+function getArgValue(argName) {
+    const args = process.argv;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === argName && i + 1 < args.length) {
+            return args[i + 1];
+        }
+        if (args[i].startsWith(`${argName}=`)) {
+            return args[i].split("=")[1];
+        }
+    }
+    return undefined;
+}
+/**
+ * Check if argument exists in command line
+ */
+function hasArg(argName) {
+    const args = process.argv;
+    return args.some(arg => arg === argName || arg.startsWith(`${argName}=`));
+}
+/**
+ * Merge file config with environment config (env takes precedence)
+ */
+function mergeConfig(fileConfig, envConfig) {
+    return {
+        cloudLlmHubUrl: envConfig.cloudLlmHubUrl || fileConfig.cloudLlmHubUrl || "",
+        httpPort: envConfig.httpPort || fileConfig.httpPort || 3001,
+        ssePort: envConfig.ssePort || fileConfig.ssePort || 3002,
+        httpHost: envConfig.httpHost || fileConfig.httpHost || "0.0.0.0",
+        sseHost: envConfig.sseHost || fileConfig.sseHost || "0.0.0.0",
+        logLevel: envConfig.logLevel || fileConfig.logLevel || "info",
+        // Command line overrides take precedence
+        btpDestination: envConfig.btpDestination ?? fileConfig.btpDestination,
+        mcpDestination: envConfig.mcpDestination ?? fileConfig.mcpDestination,
+        mcpUrl: envConfig.mcpUrl ?? fileConfig.mcpUrl,
+        unsafe: envConfig.unsafe ?? fileConfig.unsafe ?? false,
+        maxRetries: envConfig.maxRetries ?? fileConfig.maxRetries ?? 3,
+        retryDelay: envConfig.retryDelay ?? fileConfig.retryDelay ?? 1000,
+        requestTimeout: envConfig.requestTimeout ?? fileConfig.requestTimeout ?? 60000,
+        circuitBreakerThreshold: envConfig.circuitBreakerThreshold ?? fileConfig.circuitBreakerThreshold ?? 5,
+        circuitBreakerTimeout: envConfig.circuitBreakerTimeout ?? fileConfig.circuitBreakerTimeout ?? 60000,
+    };
+}
+/**
+ * Validate configuration
+ */
+function validateConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Cloud LLM Hub URL is only required if we're using proxy functionality
+    // For direct cloud and basic auth, it's not needed
+    if (!config.cloudLlmHubUrl) {
+        warnings.push("CLOUD_LLM_HUB_URL is not set - proxy to cloud-llm-hub will not work");
+    }
+    else {
+        try {
+            new URL(config.cloudLlmHubUrl);
+        }
+        catch {
+            errors.push("CLOUD_LLM_HUB_URL must be a valid URL");
+        }
+    }
+    if (config.httpPort < 1 || config.httpPort > 65535) {
+        errors.push("MCP_HTTP_PORT must be between 1 and 65535");
+    }
+    if (config.ssePort < 1 || config.ssePort > 65535) {
+        errors.push("MCP_SSE_PORT must be between 1 and 65535");
+    }
+    if (config.httpPort === config.ssePort) {
+        errors.push("MCP_HTTP_PORT and MCP_SSE_PORT must be different");
+    }
+    if (config.maxRetries && (config.maxRetries < 0 || config.maxRetries > 10)) {
+        warnings.push("MCP_PROXY_MAX_RETRIES should be between 0 and 10");
+    }
+    if (config.retryDelay && (config.retryDelay < 0 || config.retryDelay > 60000)) {
+        warnings.push("MCP_PROXY_RETRY_DELAY should be between 0 and 60000ms");
+    }
+    if (config.requestTimeout && (config.requestTimeout < 1000 || config.requestTimeout > 300000)) {
+        warnings.push("MCP_PROXY_REQUEST_TIMEOUT should be between 1000 and 300000ms");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/lib/errorHandler.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Error Handling & Resilience utilities
+ */
+export interface RetryOptions {
+    maxRetries: number;
+    retryDelay: number;
+    retryableStatusCodes?: number[];
+    retryableErrors?: string[];
+}
+/**
+ * Check if error is retryable
+ */
+export declare function isRetryableError(error: unknown, retryableStatusCodes?: number[]): boolean;
+/**
+ * Sleep for specified milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry function with exponential backoff
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, options: RetryOptions): Promise<T>;
+/**
+ * Circuit Breaker implementation
+ */
+export declare class CircuitBreaker {
+    private threshold;
+    private timeout;
+    private failures;
+    private lastFailureTime;
+    private state;
+    constructor(threshold?: number, timeout?: number);
+    /**
+     * Check if circuit breaker allows request
+     */
+    canProceed(): boolean;
+    /**
+     * Record success
+     */
+    recordSuccess(): void;
+    /**
+     * Record failure
+     */
+    recordFailure(): void;
+    /**
+     * Get current state
+     */
+    getState(): "closed" | "open" | "half-open";
+    /**
+     * Reset circuit breaker
+     */
+    reset(): void;
+}
+/**
+ * Handle token expiration errors
+ */
+export declare function isTokenExpirationError(error: unknown): boolean;
+/**
+ * Create error response in MCP format
+ */
+export declare function createErrorResponse(id: string | number | null, code: number, message: string, data?: any): {
+    jsonrpc: string;
+    id: string | number | null;
+    error: {
+        code: number;
+        message: string;
+        data?: any;
+    };
+};
+//# sourceMappingURL=errorHandler.d.ts.map

package/dist/lib/errorHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorHandler.d.ts","sourceRoot":"","sources":["../../src/lib/errorHandler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,oBAAoB,GAAE,MAAM,EAAyB,GAAG,OAAO,CAsB/G;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,CAAC,CAAC,CAgDZ;AAED;;GAEG;AACH,qBAAa,cAAc;IAMvB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,OAAO;IANjB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,KAAK,CAA6C;gBAGhD,SAAS,GAAE,MAAU,EACrB,OAAO,GAAE,MAAc;IAGjC;;OAEG;IACH,UAAU,IAAI,OAAO;IAkBrB;;OAEG;IACH,aAAa,IAAI,IAAI;IAYrB;;OAEG;IACH,aAAa,IAAI,IAAI;IAcrB;;OAEG;IACH,QAAQ,IAAI,QAAQ,GAAG,MAAM,GAAG,WAAW;IAI3C;;OAEG;IACH,KAAK,IAAI,IAAI;CAQd;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAiB9D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAC1B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,GAAG,GACT;IACD,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IAC3B,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,GAAG,CAAC;KACZ,CAAC;CACH,CAUA"}

package/dist/lib/errorHandler.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * Error Handling & Resilience utilities
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CircuitBreaker = void 0;
+exports.isRetryableError = isRetryableError;
+exports.sleep = sleep;
+exports.retryWithBackoff = retryWithBackoff;
+exports.isTokenExpirationError = isTokenExpirationError;
+exports.createErrorResponse = createErrorResponse;
+const logger_js_1 = require("./logger.js");
+/**
+ * Check if error is retryable
+ */
+function isRetryableError(error, retryableStatusCodes = [500, 502, 503, 504]) {
+    if (axios_1.default.isAxiosError(error)) {
+        const status = error.response?.status;
+        if (status && retryableStatusCodes.includes(status)) {
+            return true;
+        }
+        // Network errors are retryable
+        if (!error.response && error.request) {
+            return true;
+        }
+    }
+    // Token expiration errors are retryable (will be handled separately)
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        if (message.includes("token") && (message.includes("expired") || message.includes("invalid"))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Retry function with exponential backoff
+ */
+async function retryWithBackoff(fn, options) {
+    const { maxRetries, retryDelay, retryableStatusCodes = [500, 502, 503, 504] } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry on last attempt
+            if (attempt === maxRetries) {
+                break;
+            }
+            // Check if error is retryable
+            if (!isRetryableError(error, retryableStatusCodes)) {
+                logger_js_1.logger.debug("Error is not retryable, stopping retries", {
+                    type: "RETRY_STOPPED",
+                    attempt,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw error;
+            }
+            // Calculate backoff delay (exponential backoff)
+            const delay = retryDelay * Math.pow(2, attempt);
+            logger_js_1.logger.warn("Retrying after error", {
+                type: "RETRY_ATTEMPT",
+                attempt: attempt + 1,
+                maxRetries,
+                delay,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            await sleep(delay);
+        }
+    }
+    // All retries exhausted
+    logger_js_1.logger.error("All retry attempts exhausted", {
+        type: "RETRY_EXHAUSTED",
+        maxRetries,
+        error: lastError instanceof Error ? lastError.message : String(lastError),
+    });
+    throw lastError;
+}
+/**
+ * Circuit Breaker implementation
+ */
+class CircuitBreaker {
+    threshold;
+    timeout;
+    failures = 0;
+    lastFailureTime = 0;
+    state = "closed";
+    constructor(threshold = 5, timeout = 60000) {
+        this.threshold = threshold;
+        this.timeout = timeout;
+    }
+    /**
+     * Check if circuit breaker allows request
+     */
+    canProceed() {
+        const now = Date.now();
+        if (this.state === "open") {
+            // Check if timeout has passed
+            if (now - this.lastFailureTime >= this.timeout) {
+                this.state = "half-open";
+                logger_js_1.logger.info("Circuit breaker entering half-open state", {
+                    type: "CIRCUIT_BREAKER_HALF_OPEN",
+                });
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Record success
+     */
+    recordSuccess() {
+        if (this.state === "half-open") {
+            this.state = "closed";
+            this.failures = 0;
+            logger_js_1.logger.info("Circuit breaker closed after successful request", {
+                type: "CIRCUIT_BREAKER_CLOSED",
+            });
+        }
+        else if (this.state === "closed") {
+            this.failures = 0;
+        }
+    }
+    /**
+     * Record failure
+     */
+    recordFailure() {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        if (this.failures >= this.threshold) {
+            this.state = "open";
+            logger_js_1.logger.error("Circuit breaker opened due to failures", {
+                type: "CIRCUIT_BREAKER_OPENED",
+                failures: this.failures,
+                threshold: this.threshold,
+            });
+        }
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Reset circuit breaker
+     */
+    reset() {
+        this.failures = 0;
+        this.lastFailureTime = 0;
+        this.state = "closed";
+        logger_js_1.logger.info("Circuit breaker reset", {
+            type: "CIRCUIT_BREAKER_RESET",
+        });
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+/**
+ * Handle token expiration errors
+ */
+function isTokenExpirationError(error) {
+    if (axios_1.default.isAxiosError(error)) {
+        const status = error.response?.status;
+        if (status === 401 || status === 403) {
+            return true;
+        }
+    }
+    if (error instanceof Error) {
+        const message = error.message.toLowerCase();
+        return (message.includes("token") &&
+            (message.includes("expired") || message.includes("invalid") || message.includes("unauthorized")));
+    }
+    return false;
+}
+/**
+ * Create error response in MCP format
+ */
+function createErrorResponse(id, code, message, data) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+            code,
+            message,
+            data,
+        },
+    };
+}
+// Import axios for type checking
+const axios_1 = __importDefault(require("axios"));

package/dist/lib/logger.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Logger utility for MCP ABAP ADT Proxy
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+export interface Logger {
+    debug(message: string, meta?: Record<string, unknown>): void;
+    info(message: string, meta?: Record<string, unknown>): void;
+    warn(message: string, meta?: Record<string, unknown>): void;
+    error(message: string, meta?: Record<string, unknown>): void;
+}
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/lib/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/lib/logger.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,oBAAY,QAAQ;IAClB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACV;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC7D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC9D;AAqCD,eAAO,MAAM,MAAM,EAAE,MAIpB,CAAC"}

package/dist/lib/logger.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Logger utility for MCP ABAP ADT Proxy
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class SimpleLogger {
+    level;
+    constructor(level = LogLevel.INFO) {
+        this.level = level;
+    }
+    log(level, prefix, message, meta) {
+        if (level < this.level) {
+            return;
+        }
+        const timestamp = new Date().toISOString();
+        const metaStr = meta ? ` ${JSON.stringify(meta)}` : '';
+        console.error(`[${timestamp}] [${prefix}] ${message}${metaStr}`);
+    }
+    debug(message, meta) {
+        this.log(LogLevel.DEBUG, 'DEBUG', message, meta);
+    }
+    info(message, meta) {
+        this.log(LogLevel.INFO, 'INFO', message, meta);
+    }
+    warn(message, meta) {
+        this.log(LogLevel.WARN, 'WARN', message, meta);
+    }
+    error(message, meta) {
+        this.log(LogLevel.ERROR, 'ERROR', message, meta);
+    }
+}
+// Default logger instance
+exports.logger = new SimpleLogger(process.env.LOG_LEVEL?.toUpperCase()
+    ? (LogLevel[process.env.LOG_LEVEL.toUpperCase()] ?? LogLevel.INFO)
+    : LogLevel.INFO);

package/dist/lib/stores.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Platform-specific stores for proxy
+ * Uses FileServiceKeyStore and either FileSessionStore or SafeSessionStore
+ * depending on the unsafe configuration parameter
+ */
+import { IServiceKeyStore, ISessionStore } from "@mcp-abap-adt/auth-broker";
+/**
+ * Get platform-specific stores
+ * Returns stores based on configuration:
+ * - If unsafe=true: uses FileSessionStore (persists to disk)
+ * - If unsafe=false: uses SafeSessionStore (in-memory, secure)
+ * @param unsafe If true, use FileSessionStore. If false, use SafeSessionStore (default).
+ */
+export declare function getPlatformStores(unsafe?: boolean): Promise<{
+    serviceKeyStore: IServiceKeyStore;
+    sessionStore: ISessionStore;
+}>;
+//# sourceMappingURL=stores.d.ts.map

package/dist/lib/stores.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/lib/stores.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAIL,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AAEnC;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC;IACxE,eAAe,EAAE,gBAAgB,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC,CAKD"}

package/dist/lib/stores.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Platform-specific stores for proxy
+ * Uses FileServiceKeyStore and either FileSessionStore or SafeSessionStore
+ * depending on the unsafe configuration parameter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlatformStores = getPlatformStores;
+const auth_broker_1 = require("@mcp-abap-adt/auth-broker");
+/**
+ * Get platform-specific stores
+ * Returns stores based on configuration:
+ * - If unsafe=true: uses FileSessionStore (persists to disk)
+ * - If unsafe=false: uses SafeSessionStore (in-memory, secure)
+ * @param unsafe If true, use FileSessionStore. If false, use SafeSessionStore (default).
+ */
+async function getPlatformStores(unsafe = false) {
+    return {
+        serviceKeyStore: new auth_broker_1.FileServiceKeyStore(),
+        sessionStore: unsafe ? new auth_broker_1.FileSessionStore() : new auth_broker_1.SafeSessionStore(),
+    };
+}

package/dist/lib/transportConfig.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transport Configuration - Parse and manage transport settings
+ */
+export type TransportType = "stdio" | "streamable-http" | "sse";
+export interface TransportConfig {
+    type: TransportType;
+    host?: string;
+    port?: number;
+    enableJsonResponse?: boolean;
+    allowedOrigins?: string[];
+    allowedHosts?: string[];
+    enableDnsRebindingProtection?: boolean;
+}
+/**
+ * Parse transport configuration from command line arguments and environment variables
+ */
+export declare function parseTransportConfig(): TransportConfig;
+//# sourceMappingURL=transportConfig.d.ts.map

package/dist/lib/transportConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportConfig.d.ts","sourceRoot":"","sources":["../../src/lib/transportConfig.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,iBAAiB,GAAG,KAAK,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,4BAA4B,CAAC,EAAE,OAAO,CAAC;CACxC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,eAAe,CAgGtD"}