@mcp-abap-adt/proxy 0.1.8 → 0.2.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.9] - 2026-02-12
+
+### Changed
+- **AUTH_BROKER_PATH resolution aligned with `mcp-abap-adt`**
+  - `AUTH_BROKER_PATH` is now treated as a base directory.
+  - Proxy now resolves stores from `<base>/service-keys` and `<base>/sessions`.
+  - If a path already ends with `service-keys` or `sessions`, it is normalized and still resolved correctly.
+
+### Documentation
+- Clarified in README and troubleshooting docs how default store paths and `AUTH_BROKER_PATH` are resolved.
+
 ## [0.1.8] - 2026-02-05
 
 ### Added
@@ -198,4 +209,3 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `@mcp-abap-adt/header-validator` ^0.1.3 - Header validation
 - `axios` - HTTP client
 - `zod` - Schema validation
-

package/README.md

@@ -157,8 +157,17 @@ The proxy is transparent - it only adds authentication headers and forwards requ
 export MCP_HTTP_PORT=3001
 export LOG_LEVEL=info
 export MCP_PROXY_UNSAFE=true  # Enable file-based session storage (optional)
+export AUTH_BROKER_PATH=~/.config/mcp-abap-adt  # Optional base path for service-keys/sessions
 ```
 
+`AUTH_BROKER_PATH` is treated as a base directory. The proxy resolves:
+- `service-keys` from `<AUTH_BROKER_PATH>/service-keys`
+- `sessions` from `<AUTH_BROKER_PATH>/sessions`
+
+Defaults when `AUTH_BROKER_PATH` is not set:
+- Unix/Linux/macOS: `~/.config/mcp-abap-adt/service-keys` and `~/.config/mcp-abap-adt/sessions`
+- Windows: `%USERPROFILE%\\Documents\\mcp-abap-adt\\service-keys` and `%USERPROFILE%\\Documents\\mcp-abap-adt\\sessions`
+
 ### Configuration File
 
 Create `mcp-proxy-config.json`:
@@ -175,7 +184,7 @@ Create `mcp-proxy-config.json`:
 
 **Session Storage:**
 - `unsafe: false` (default) - Session data stored in-memory (secure, lost on restart)
-- `unsafe: true` - Session data persisted to disk (tokens saved to `.env` files)
+- `unsafe: true` - Session data persisted to disk (tokens saved under the session store path)
 
 See [Configuration Guide](./docs/CONFIGURATION.md) for complete options.
 

package/bin/mcp-abap-adt-proxy.js

@@ -7,6 +7,7 @@
  *
  * Usage:
  *   mcp-abap-adt-proxy [options]
+ *   mcp-abap-adt-proxy tui
  *   mcp-abap-adt-proxy --transport=stdio
  *   mcp-abap-adt-proxy --transport=http
  */
@@ -43,6 +44,10 @@ MCP ABAP ADT Proxy Server v${pkg.version}
 
 Usage:
   mcp-abap-adt-proxy [options]
+  mcp-abap-adt-proxy tui
+
+Commands:
+  tui                       Interactive configuration wizard (generates YAML config)
 
 Options:
   --transport=<type>       Transport type: stdio, http, streamable-http, sse
@@ -77,6 +82,7 @@ Examples:
   mcp-abap-adt-proxy --transport=sse --sse-port=3002     # SSE mode on port 3002
   mcp-abap-adt-proxy --btp=ai                           # With BTP destination override
   mcp-abap-adt-proxy --btp=ai --unsafe                  # With file-based session storage
+  mcp-abap-adt-proxy tui                                 # Interactive configuration wizard
   mcp-abap-adt-proxy --config=proxy-config.yaml         # Load configuration from YAML file
   mcp-abap-adt-proxy -c proxy-config.yml                # Load configuration from YAML file (short form)
 
@@ -137,6 +143,30 @@ function main() {
     process.exit(0);
   }
 
+  // Handle 'tui' subcommand — interactive configuration wizard
+  if (process.argv[2] === 'tui') {
+    const wizardPath = path.resolve(__dirname, '../dist/tui/index.js');
+    if (!fs.existsSync(wizardPath)) {
+      process.stderr.write(`[MCP Proxy] ✗ Wizard not found at: ${wizardPath}\n`);
+      process.stderr.write(`[MCP Proxy]   Make sure to build the project with 'npm run build' first.\n`);
+      process.exit(1);
+      return;
+    }
+    import(wizardPath).then(({ runWizard }) => {
+      runWizard().catch((err) => {
+        if (err.name === 'ExitPromptError') {
+          process.exit(0);
+        }
+        process.stderr.write(`[MCP Proxy] ✗ Wizard error: ${err.message}\n`);
+        process.exit(1);
+      });
+    }).catch((err) => {
+      process.stderr.write(`[MCP Proxy] ✗ Failed to load wizard: ${err.message}\n`);
+      process.exit(1);
+    });
+    return;
+  }
+
   // Spawn the main server process
   const serverPath = path.resolve(__dirname, '../dist/index.js');
 

package/dist/index.d.ts

@@ -31,7 +31,7 @@ export declare class McpAbapAdtProxyServer {
      */
     private startHttpServer;
     /**
-     * Handle proxy request - add JWT token and forward to MCP server
+     * Handle proxy request - get JWT token and forward transparently via reverse proxy
      */
     private handleProxyRequest;
     /**

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAiBH,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAC;AAsBlC;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAW;gBAEhB,eAAe,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,MAAM;IA0ClE;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE1B;;OAEG;YACW,eAAe;IA4M7B;;OAEG;YACW,kBAAkB;IAyOhC;;OAEG;YACW,cAAc;IA0S5B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAmBhC;AAGD,eAAe,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAuBH,OAAO,EAEL,KAAK,eAAe,EAErB,MAAM,0BAA0B,CAAC;AAqBlC;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,UAAU,CAAC,CAAa;IAChC,OAAO,CAAC,QAAQ,CAAC,CAAW;gBAEhB,eAAe,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,MAAM;IAoDlE;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;IAuE1B;;OAEG;YACW,eAAe;IAgG7B;;OAEG;YACW,kBAAkB;IA8ChC;;OAEG;YACW,cAAc;IA2T5B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAmBhC;AAGD,eAAe,qBAAqB,CAAC"}

package/dist/index.js

@@ -15,6 +15,7 @@ const interfaces_1 = require("@mcp-abap-adt/interfaces");
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const sse_js_1 = require("@modelcontextprotocol/sdk/server/sse.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const reverseProxy_js_1 = require("./proxy/reverseProxy.js");
 const config_js_1 = require("./lib/config.js");
 const logger_js_1 = require("./lib/logger.js");
 const transportConfig_js_1 = require("./lib/transportConfig.js");
@@ -40,7 +41,17 @@ class McpAbapAdtProxyServer {
     httpServer;
     btpProxy;
     constructor(transportConfig, configPath) {
-        this.transportConfig = transportConfig || (0, transportConfig_js_1.parseTransportConfig)();
+        // Load config first to extract transport overrides from YAML/JSON file
+        const resolvedConfigPath = configPath || (0, config_js_1.getConfigPath)();
+        let fileTransportOverrides;
+        if (resolvedConfigPath) {
+            const raw = (0, config_js_1.loadRawConfigFile)(resolvedConfigPath);
+            if (raw) {
+                fileTransportOverrides = (0, config_js_1.extractTransportFields)(raw);
+            }
+        }
+        this.transportConfig =
+            transportConfig || (0, transportConfig_js_1.parseTransportConfig)(fileTransportOverrides);
         this.config = (0, config_js_1.loadConfig)(configPath);
         // Validate configuration
         if (this.transportConfig.type === 'streamable-http' ||
@@ -145,9 +156,7 @@ Authorization source: BTP destination "${this.config.btpDestination}"`;
     async startHttpServer() {
         const httpConfig = this.transportConfig;
         this.httpServer = (0, node_http_1.createServer)(async (req, res) => {
-            // Log incoming HTTP request (always log in DEBUG mode)
-            const _debugEnabled = process.env.DEBUG === 'true' ||
-                process.env.DEBUG_HTTP_REQUESTS === 'true';
+            // Log incoming HTTP request
             const sanitizedHeaders = (0, requestInterceptor_js_1.sanitizeHeadersForLogging)(req.headers);
             logger_js_1.logger?.info('=== HTTP REQUEST RECEIVED ===', {
                 type: 'HTTP_REQUEST_RECEIVED',
@@ -156,92 +165,14 @@ Authorization source: BTP destination "${this.config.btpDestination}"`;
                 headers: sanitizedHeaders,
                 remoteAddress: req.socket.remoteAddress,
             });
-            // Allow all HTTP methods (GET, POST, PUT, DELETE, etc.)
-            // if (req.method !== 'POST') {
-            //   logger?.warn('Non-POST request rejected', { ... });
-            //   ...
-            // }
-            // Read request body
-            let body;
-            try {
-                const chunks = [];
-                for await (const chunk of req) {
-                    chunks.push(chunk);
-                }
-                const bodyString = Buffer.concat(chunks).toString('utf-8');
-                logger_js_1.logger?.info('=== PARSING REQUEST BODY ===', {
-                    type: 'REQUEST_BODY_PARSING',
-                    bodyLength: bodyString.length,
-                    bodyPreview: bodyString.substring(0, 200),
-                });
-                if (bodyString.trim().length > 0) {
-                    body = JSON.parse(bodyString);
-                }
-                else {
-                    body = undefined;
-                }
-                // Sanitize body for logging
-                const sanitizedBody = {};
-                if (body && typeof body === 'object' && body !== null) {
-                    const bodyObj = body;
-                    sanitizedBody.method = bodyObj.method;
-                    sanitizedBody.id = bodyObj.id;
-                    sanitizedBody.jsonrpc = bodyObj.jsonrpc;
-                    if (bodyObj.params &&
-                        typeof bodyObj.params === 'object' &&
-                        bodyObj.params !== null) {
-                        const params = bodyObj.params;
-                        sanitizedBody.params = {};
-                        const sanitizedParams = sanitizedBody.params;
-                        if (params.arguments &&
-                            typeof params.arguments === 'object' &&
-                            params.arguments !== null) {
-                            sanitizedParams.arguments = {};
-                            const sanitizedArgs = sanitizedParams.arguments;
-                            for (const [key, value] of Object.entries(params.arguments)) {
-                                const lowerKey = key.toLowerCase();
-                                if (lowerKey.includes('password') ||
-                                    lowerKey.includes('token') ||
-                                    lowerKey.includes('secret')) {
-                                    sanitizedArgs[key] = '[REDACTED]';
-                                }
-                                else {
-                                    sanitizedArgs[key] = value;
-                                }
-                            }
-                        }
-                        for (const [key, value] of Object.entries(params)) {
-                            if (key === 'arguments')
-                                continue;
-                            sanitizedParams[key] = value;
-                        }
-                    }
-                }
-                logger_js_1.logger?.info('=== REQUEST BODY PARSED ===', {
-                    type: 'REQUEST_BODY_PARSED',
-                    body: sanitizedBody,
-                });
-            }
-            catch (error) {
-                logger_js_1.logger?.error('=== FAILED TO PARSE REQUEST BODY ===', {
-                    type: 'REQUEST_PARSE_ERROR',
-                    error: error instanceof Error ? error.message : String(error),
-                    errorStack: error instanceof Error ? error.stack : undefined,
-                });
-                res.writeHead(400, { 'Content-Type': 'text/plain' });
-                res.end('Invalid request body');
-                return;
-            }
-            // Intercept and analyze request
+            // Intercept and analyze request (headers only, body is piped through)
             const configOverrides = {
                 btpDestination: this.config.btpDestination,
                 targetUrl: this.config.targetUrl,
             };
-            logger_js_1.logger?.info('=== INTERCEPTING REQUEST ===', {
-                type: 'REQUEST_INTERCEPTING',
-                configOverrides,
+            const intercepted = (0, requestInterceptor_js_1.interceptRequest)(req, undefined, configOverrides, {
+                skipHeaderValidation: true,
             });
-            const intercepted = (0, requestInterceptor_js_1.interceptRequest)(req, body, configOverrides);
             // Check routing decision
             if (intercepted.routingDecision.strategy === headerAnalyzer_js_1.RoutingStrategy.UNKNOWN) {
                 logger_js_1.logger?.error('Routing decision failed', {
@@ -249,25 +180,16 @@ Authorization source: BTP destination "${this.config.btpDestination}"`;
                     reason: intercepted.routingDecision.reason,
                 });
                 res.writeHead(400, { 'Content-Type': 'application/json' });
-                const bodyId = body && typeof body === 'object' && body !== null && 'id' in body
-                    ? body.id
-                    : null;
                 res.end(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: bodyId || null,
-                    error: {
-                        code: -32602,
-                        message: intercepted.routingDecision.reason,
-                    },
+                    error: intercepted.routingDecision.reason,
                 }));
                 return;
             }
-            // Log proxy request
+            // Forward request via reverse proxy
             logger_js_1.logger?.info('=== PROXYING REQUEST ===', {
                 type: 'PROXY_REQUEST_START',
                 btpDestination: intercepted.routingDecision.btpDestination,
             });
-            // Handle proxy request - add JWT and forward to x-mcp-url
             try {
                 await this.handleProxyRequest(intercepted, req, res);
             }
@@ -278,8 +200,8 @@ Authorization source: BTP destination "${this.config.btpDestination}"`;
                     strategy: intercepted.routingDecision.strategy,
                 });
                 if (!res.headersSent) {
-                    res.writeHead(500, { 'Content-Type': 'text/plain' });
-                    res.end('Internal server error');
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Internal server error' }));
                 }
             }
         });
@@ -311,192 +233,38 @@ Authorization source: ${authSourceObj}`;
         });
     }
     /**
-     * Handle proxy request - add JWT token and forward to MCP server
+     * Handle proxy request - get JWT token and forward transparently via reverse proxy
      */
     async handleProxyRequest(intercepted, req, res) {
-        const btpDestination = intercepted.routingDecision.btpDestination;
-        // Log incoming request details
-        const incomingHeaders = {};
-        for (const [key, value] of Object.entries(intercepted.headers)) {
-            const lowerKey = key.toLowerCase();
-            if (lowerKey.includes('token') ||
-                lowerKey.includes('authorization') ||
-                lowerKey.includes('password') ||
-                lowerKey.includes('secret')) {
-                incomingHeaders[key] = '[REDACTED]';
-            }
-            else {
-                incomingHeaders[key] = Array.isArray(value)
-                    ? value.join(', ')
-                    : value || '';
-            }
+        const destination = intercepted.routingDecision.btpDestination;
+        if (!destination) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'No BTP destination specified' }));
+            return;
         }
-        const sanitizedBody = {};
-        if (intercepted.body &&
-            typeof intercepted.body === 'object' &&
-            intercepted.body !== null) {
-            const bodyObj = intercepted.body;
-            if (bodyObj.params &&
-                typeof bodyObj.params === 'object' &&
-                bodyObj.params !== null) {
-                const params = bodyObj.params;
-                sanitizedBody.params = {};
-                const sanitizedParams = sanitizedBody.params;
-                // For tools/call, log arguments
-                if (params.arguments &&
-                    typeof params.arguments === 'object' &&
-                    params.arguments !== null) {
-                    sanitizedParams.arguments = {};
-                    const sanitizedArgs = sanitizedParams.arguments;
-                    for (const [key, value] of Object.entries(params.arguments)) {
-                        const lowerKey = key.toLowerCase();
-                        if (lowerKey.includes('password') ||
-                            lowerKey.includes('token') ||
-                            lowerKey.includes('secret')) {
-                            sanitizedArgs[key] = '[REDACTED]';
-                        }
-                        else {
-                            sanitizedArgs[key] = value;
-                        }
-                    }
-                }
-                // Log other params
-                for (const [key, value] of Object.entries(params)) {
-                    if (key === 'arguments')
-                        continue;
-                    sanitizedParams[key] = value;
-                }
-            }
-            sanitizedBody.method = bodyObj.method;
-            sanitizedBody.id = bodyObj.id;
-            sanitizedBody.jsonrpc = bodyObj.jsonrpc;
+        // Ensure proxy is initialized
+        if (!this.btpProxy) {
+            this.btpProxy = await (0, btpProxy_js_1.createBtpProxy)(this.config);
         }
-        // Use original request body structure for proxying (generic support)
-        // We do NOT enforce JSON-RPC structure here anymore, to support REST/OData
-        const proxyRequestData = intercepted.body;
-        logger_js_1.logger?.info('=== INCOMING REQUEST ===', {
-            type: 'PROXY_REQUEST_INCOMING',
-            method: req.method,
-            url: req.url,
-            btpDestination,
-            sessionId: intercepted.sessionId,
-            headers: incomingHeaders,
-            body: sanitizedBody,
-            mode: 'BTP authentication',
-        });
         try {
-            // Ensure proxy is initialized (URL will be obtained from service key for btpDestination or mcpDestination)
-            if (!this.btpProxy) {
-                this.btpProxy = await (0, btpProxy_js_1.createBtpProxy)(this.config);
-            }
-            // Build MCP request from intercepted request
-            // Note: Use ?? instead of || to preserve falsy values like 0
-            const interceptedBodyId = getBodyId(intercepted.body);
-            const interceptedBodyIdType = typeof interceptedBodyId;
-            const interceptedBodyIdUndefined = interceptedBodyId === undefined;
-            logger_js_1.logger?.info('=== BEFORE BUILDING MCP REQUEST ===', {
-                type: 'BEFORE_BUILD_MCP_REQUEST',
-                interceptedBodyId,
-                interceptedBodyIdType,
-                interceptedBodyIdUndefined,
-                interceptedBodyIdNull: interceptedBodyId === null,
-                interceptedBodyIdZero: interceptedBodyId === 0,
-                interceptedBodyIdFalsy: !interceptedBodyId,
-                fullInterceptedBody: JSON.stringify(intercepted.body),
-            });
-            // Preserve id correctly - 0 is a valid id value
-            let mcpRequestId;
-            if (interceptedBodyId === undefined) {
-                mcpRequestId = null;
-            }
-            else if (typeof interceptedBodyId === 'string' ||
-                typeof interceptedBodyId === 'number') {
-                mcpRequestId = interceptedBodyId;
-            }
-            else {
-                mcpRequestId = null;
-            }
-            // Proxy request to BtpProxy
-            // Pass the original request data directly
-            const proxyRequest = {
-                method: intercepted.method, // Use original HTTP method (GET, POST, etc.)
-                url: intercepted.url, // Pass request URL (path)
-                data: proxyRequestData, // Use original body (or undefined)
-                id: mcpRequestId, // Keep ID for logging context if available
-            };
-            const proxyResponse = await this.btpProxy.proxyRequest(proxyRequest, intercepted.routingDecision, intercepted.headers);
-            // Fix: If backend returned null ID but we entered with a valid ID (e.g. 0), restore it.
-            // Cline/Zod schemas reject null ID for successful responses if request had an ID.
-            if ((proxyResponse.id === null || proxyResponse.id === undefined) &&
-                mcpRequestId !== null &&
-                mcpRequestId !== undefined) {
-                logger_js_1.logger?.debug('Restoring original request ID in response', {
-                    originalId: mcpRequestId,
-                    receivedId: proxyResponse.id,
-                });
-                proxyResponse.id = mcpRequestId;
-            }
-            logger_js_1.logger?.info('=== FORWARDING REQUEST ===', {
-                type: 'PROXY_REQUEST_FORWARDING',
-                interceptedBodyIdAtForward: getBodyId(intercepted.body),
-                proxyRequest,
-                routingDecision: intercepted.routingDecision,
-                headers: intercepted.headers,
-            });
-            // Log response
-            const sanitizedResponse = {
-                jsonrpc: proxyResponse.jsonrpc,
-                id: proxyResponse.id,
-            };
-            if (proxyResponse.result) {
-                sanitizedResponse.result = proxyResponse.result;
-            }
-            if (proxyResponse.error) {
-                sanitizedResponse.error = {
-                    code: proxyResponse.error.code,
-                    message: proxyResponse.error.message,
-                    data: proxyResponse.error.data,
-                };
-            }
-            logger_js_1.logger?.info('=== RESPONSE FROM TARGET SERVICE ===', {
-                type: 'PROXY_RESPONSE_RECEIVED',
-                response: sanitizedResponse,
-                hasResult: !!proxyResponse.result,
-                hasError: !!proxyResponse.error,
-            });
-            // Send response back to client
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(proxyResponse));
-            logger_js_1.logger?.info('=== RESPONSE SENT TO CLIENT ===', {
-                type: 'PROXY_RESPONSE_SENT',
-                statusCode: 200,
-            });
-            logger_js_1.logger?.debug('BtpProxy request completed', {
-                type: 'BTP_PROXY_COMPLETED',
-                hasResult: !!proxyResponse.result,
-                hasError: !!proxyResponse.error,
-            });
+            // Get JWT token (cached, auto-refresh)
+            const jwtToken = await this.btpProxy.getJwtToken(destination);
+            // Get target URL
+            const targetUrl = intercepted.routingDecision.targetUrl ||
+                (await this.btpProxy.getTargetUrl(destination));
+            // Forward request transparently
+            await (0, reverseProxy_js_1.forwardRequest)(req, res, targetUrl, jwtToken);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logger_js_1.logger?.error('Failed to handle BtpProxy request', {
-                type: 'BTP_PROXY_ERROR',
-                error: errorMessage,
-                stack: error instanceof Error ? error.stack : undefined,
+            logger_js_1.logger?.error('Proxy request failed', {
+                type: 'PROXY_REQUEST_ERROR',
+                destination,
+                error: error instanceof Error ? error.message : String(error),
             });
-            // Output error to stderr for user visibility (only if verbose mode is enabled)
-            if ((0, btpProxy_js_1.shouldWriteStderr)()) {
-                process.stderr.write(`[MCP Proxy] ✗ Connection error: ${errorMessage}\n`);
-            }
             if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.writeHead(502, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({
-                    jsonrpc: '2.0',
-                    id: getBodyId(intercepted.body) || null,
-                    error: {
-                        code: -32000,
-                        message: errorMessage,
-                    },
+                    error: error instanceof Error ? error.message : 'Proxy error',
                 }));
             }
         }
@@ -686,6 +454,7 @@ Authorization source: ${authSourceObj}`;
                 // Intercept and analyze request with config overrides
                 const configOverrides = {
                     btpDestination: this.config.btpDestination,
+                    targetUrl: this.config.targetUrl,
                 };
                 const intercepted = (0, requestInterceptor_js_1.interceptRequest)(req, body, configOverrides);
                 // Check routing decision
@@ -704,9 +473,19 @@ Authorization source: ${authSourceObj}`;
                     }));
                     return;
                 }
-                // Handle proxy request
+                // Handle proxy request via BtpProxy (JSON-RPC mode for SSE)
                 try {
-                    await this.handleProxyRequest(intercepted, req, res);
+                    if (!this.btpProxy) {
+                        this.btpProxy = await (0, btpProxy_js_1.createBtpProxy)(this.config);
+                    }
+                    const proxyResponse = await this.btpProxy.proxyRequest({
+                        method: intercepted.method,
+                        url: intercepted.url,
+                        data: body,
+                        id: getBodyId(body),
+                    }, intercepted.routingDecision, intercepted.headers);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify(proxyResponse));
                 }
                 catch (error) {
                     logger_js_1.logger?.error('Failed to process SSE POST request', {

package/dist/lib/config.d.ts

@@ -27,6 +27,24 @@ export interface ProxyConfig {
  * - If --config is NOT provided, load ONLY from command line parameters and environment variables
  */
 export declare function loadConfig(configPath?: string): ProxyConfig;
+/**
+ * Transport-related fields from config file (not part of ProxyConfig but needed by transportConfig)
+ */
+export interface FileTransportFields {
+    transport?: string;
+    httpPort?: number;
+    httpHost?: string;
+    ssePort?: number;
+    sseHost?: string;
+}
+/**
+ * Extract transport-related fields from a raw config object
+ */
+export declare function extractTransportFields(raw: Record<string, unknown>): FileTransportFields;
+/**
+ * Load raw config from file for transport field extraction
+ */
+export declare function loadRawConfigFile(filePath: string): Record<string, unknown> | null;
 /**
  * Get config file path from command line (--config or -c)
  */

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IAEjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAG/B,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,WAAW,CAqC3D;AAuHD;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,CAElD;AAUD;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG;IACnD,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAoDA"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IAEjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IAGnB,MAAM,CAAC,EAAE,OAAO,CAAC;IAEjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAG/B,OAAO,CAAC,EAAE,QAAQ,GAAG,UAAU,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IACzE,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,WAAW,CAqC3D;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC3B,mBAAmB,CAQrB;AAgBD;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,GACf,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAYhC;AA0GD;;GAEG;AACH,wBAAgB,aAAa,IAAI,MAAM,GAAG,SAAS,CAElD;AAUD;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG;IACnD,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAoDA"}

package/dist/lib/config.js

@@ -37,6 +37,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadConfig = loadConfig;
+exports.extractTransportFields = extractTransportFields;
+exports.loadRawConfigFile = loadRawConfigFile;
 exports.getConfigPath = getConfigPath;
 exports.validateConfig = validateConfig;
 const fs = __importStar(require("node:fs"));
@@ -80,6 +82,18 @@ function loadConfig(configPath) {
     // No --config provided: load ONLY from command line parameters and environment variables
     return loadFromEnv();
 }
+/**
+ * Extract transport-related fields from a raw config object
+ */
+function extractTransportFields(raw) {
+    return {
+        transport: typeof raw.transport === 'string' ? raw.transport : undefined,
+        httpPort: typeof raw.httpPort === 'number' ? raw.httpPort : undefined,
+        httpHost: typeof raw.httpHost === 'string' ? raw.httpHost : undefined,
+        ssePort: typeof raw.ssePort === 'number' ? raw.ssePort : undefined,
+        sseHost: typeof raw.sseHost === 'string' ? raw.sseHost : undefined,
+    };
+}
 /**
  * Load configuration from file (supports JSON and YAML)
  */
@@ -93,6 +107,24 @@ function loadConfigFile(filePath) {
         return JSON.parse(configContent);
     }
 }
+/**
+ * Load raw config from file for transport field extraction
+ */
+function loadRawConfigFile(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext === '.yaml' || ext === '.yml') {
+            return yaml.load(content) || {};
+        }
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Apply default values to partial config (used when loading from file)
  */
@@ -104,6 +136,7 @@ function applyDefaults(fileConfig) {
         sseHost: fileConfig.sseHost || '0.0.0.0',
         logLevel: fileConfig.logLevel || 'info',
         btpDestination: fileConfig.btpDestination,
+        targetUrl: fileConfig.targetUrl,
         unsafe: fileConfig.unsafe ?? false,
         maxRetries: fileConfig.maxRetries ?? 3,
         retryDelay: fileConfig.retryDelay ?? 1000,

package/dist/lib/stores.d.ts

@@ -4,6 +4,20 @@
  * depending on the unsafe configuration parameter
  */
 import type { IServiceKeyStore, ISessionStore } from '@mcp-abap-adt/auth-broker';
+/**
+ * Get platform-specific default paths for service keys and sessions
+ *
+ * Priority (matching mcp-abap-adt logic):
+ * 1. AUTH_BROKER_PATH environment variable
+ * 2. Platform-specific standard paths (only if no env paths were found):
+ *    - Unix: ~/.config/mcp-abap-adt/{subfolder}
+ *    - Windows: %USERPROFILE%\Documents\mcp-abap-adt\{subfolder}
+ * 3. Current working directory (process.cwd())
+ *
+ * @param subfolder Subfolder name ('service-keys' or 'sessions')
+ * @returns Array of resolved absolute paths
+ */
+export declare function getPlatformPaths(subfolder?: 'service-keys' | 'sessions'): string[];
 /**
  * Get platform-specific stores
  * Returns XSUAA stores for BTP authentication:

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

@@ -1 +1 @@
-{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/lib/stores.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AA4EnC;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC;IACxE,eAAe,EAAE,gBAAgB,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC,CAqBD"}
+{"version":3,"file":"stores.d.ts","sourceRoot":"","sources":["../../src/lib/stores.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AAOnC;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,CAAC,EAAE,cAAc,GAAG,UAAU,GACtC,MAAM,EAAE,CAgEV;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC;IACxE,eAAe,EAAE,gBAAgB,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC;CAC7B,CAAC,CAqBD"}