@mcp-abap-adt/core 2.1.3 → 2.1.6

package/dist/lib/servers/v2/__tests__/unit/McpServer.test.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * Unit tests for McpServer v2
+ *
+ * Tests with mocked implementations of all interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const McpServer_js_1 = require("../../server/McpServer.js");
+describe('McpServer', () => {
+    let mockTransport;
+    let mockSessionManager;
+    let mockConnectionProvider;
+    let mockProtocolHandler;
+    let mockHandlersRegistry;
+    let mockSdkServer;
+    let mockLogger;
+    beforeEach(() => {
+        // Mock Transport
+        mockTransport = {
+            type: 'stdio',
+            bindAddress: '127.0.0.1',
+            port: undefined,
+            start: jest.fn().mockResolvedValue(undefined),
+            stop: jest.fn().mockResolvedValue(undefined),
+            on: jest.fn(),
+            send: jest.fn().mockResolvedValue(undefined),
+        };
+        // Mock Session Manager
+        const mockSession = {
+            clientSessionId: 'test-session-id',
+            createdAt: new Date(),
+            lastActivity: new Date(),
+            connectionParams: {
+                sapUrl: 'https://test.sap.com',
+                auth: { type: 'jwt', jwtToken: 'test-token' },
+            },
+            metadata: {
+                transport: 'stdio',
+                requestCount: 0,
+                errorCount: 0,
+            },
+        };
+        mockSessionManager = {
+            createSession: jest.fn().mockReturnValue(mockSession),
+            getSession: jest.fn().mockReturnValue(mockSession),
+            deleteSession: jest.fn(),
+            setAbapSession: jest.fn(),
+            clearAbapSession: jest.fn(),
+            on: jest.fn(),
+            clearAll: jest.fn(),
+            updateConnectionParams: jest.fn(),
+        };
+        // Mock Connection Provider
+        const mockConnectionParams = {
+            sapUrl: 'https://test.sap.com',
+            auth: { type: 'jwt', jwtToken: 'test-token' },
+        };
+        mockConnectionProvider = {
+            mode: 'LOCAL',
+            getConnectionParams: jest.fn().mockResolvedValue(mockConnectionParams),
+            updateConnectionParams: jest.fn().mockResolvedValue(undefined),
+        };
+        // Mock Protocol Handler
+        mockProtocolHandler = {
+            initialize: jest.fn(),
+            handleRequest: jest.fn().mockResolvedValue({ result: 'success' }),
+        };
+        // Mock Handlers Registry
+        mockHandlersRegistry = {
+            registerAllTools: jest.fn(),
+            registerTool: jest.fn(),
+            getRegisteredTools: jest.fn().mockReturnValue(['test-tool']),
+        };
+        // Mock SDK Server
+        mockSdkServer = {};
+        // Mock Logger
+        mockLogger = {
+            info: jest.fn(),
+            error: jest.fn(),
+            warn: jest.fn(),
+            debug: jest.fn(),
+        };
+    });
+    describe('constructor', () => {
+        it('should initialize with all dependencies', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer, mockLogger);
+            expect(server).toBeDefined();
+            expect(mockProtocolHandler.initialize).toHaveBeenCalledWith(mockHandlersRegistry, mockSdkServer);
+            expect(mockTransport.on).toHaveBeenCalled();
+            expect(mockSessionManager.on).toHaveBeenCalled();
+        });
+        it('should work without logger', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(server).toBeDefined();
+        });
+    });
+    describe('start', () => {
+        it('should start transport', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer, mockLogger);
+            await server.start();
+            expect(mockTransport.start).toHaveBeenCalled();
+            expect(mockLogger.info).toHaveBeenCalledWith('Starting MCP Server v2...');
+            expect(mockLogger.info).toHaveBeenCalledWith('MCP Server v2 started successfully');
+        });
+        it('should throw error if already started', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            await server.start();
+            await expect(server.start()).rejects.toThrow('Server is already started');
+        });
+    });
+    describe('stop', () => {
+        it('should stop transport and clear sessions', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer, mockLogger);
+            await server.start();
+            await server.stop();
+            expect(mockTransport.stop).toHaveBeenCalled();
+            expect(mockSessionManager.clearAll).toHaveBeenCalled();
+            expect(mockLogger.info).toHaveBeenCalledWith('Stopping MCP Server v2...');
+        });
+        it('should not throw if not started', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            await expect(server.stop()).resolves.not.toThrow();
+        });
+    });
+    describe('validateConfiguration', () => {
+        it('should pass validation for LOCAL mode', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(() => server.validateConfiguration()).not.toThrow();
+        });
+        it('should throw error for LOCAL transport with REMOTE provider', () => {
+            const remoteProvider = {
+                ...mockConnectionProvider,
+                mode: 'REMOTE',
+            };
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, remoteProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(() => server.validateConfiguration()).toThrow('Configuration mismatch');
+        });
+        it('should throw error for REMOTE transport with LOCAL provider', () => {
+            const remoteTransport = {
+                ...mockTransport,
+                bindAddress: '0.0.0.0',
+            };
+            const server = new McpServer_js_1.McpServer(remoteTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(() => server.validateConfiguration()).toThrow('Configuration mismatch');
+        });
+    });
+    describe('session creation flow', () => {
+        it('should create session when transport emits session:created', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer, mockLogger);
+            // Get the session:created handler
+            const sessionCreatedCall = mockTransport.on.mock.calls.find((call) => call[0] === 'session:created');
+            expect(sessionCreatedCall).toBeDefined();
+            const handler = sessionCreatedCall[1];
+            const clientInfo = {
+                transport: 'stdio',
+            };
+            await handler('test-session-id', clientInfo);
+            expect(mockSessionManager.createSession).toHaveBeenCalledWith(clientInfo);
+            expect(mockConnectionProvider.getConnectionParams).toHaveBeenCalled();
+        });
+    });
+    describe('message handling flow', () => {
+        it('should process message and send response', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer, mockLogger);
+            // Get the message handler
+            const messageCall = mockTransport.on.mock.calls.find((call) => call[0] === 'message');
+            expect(messageCall).toBeDefined();
+            const handler = messageCall[1];
+            const message = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: { name: 'test-tool', arguments: {} },
+            };
+            await handler('test-session-id', message);
+            expect(mockProtocolHandler.handleRequest).toHaveBeenCalledWith('test-session-id', message);
+            expect(mockTransport.send).toHaveBeenCalled();
+        });
+        it('should handle errors and send error response', async () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer, mockLogger);
+            // Make getSession return undefined to simulate error
+            mockSessionManager.getSession = jest.fn().mockReturnValue(undefined);
+            // Get the message handler
+            const messageCall = mockTransport.on.mock.calls.find((call) => call[0] === 'message');
+            const handler = messageCall[1];
+            const message = {
+                jsonrpc: '2.0',
+                id: 1,
+                method: 'tools/call',
+                params: { name: 'test-tool', arguments: {} },
+            };
+            await handler('test-session-id', message);
+            expect(mockLogger.error).toHaveBeenCalled();
+            expect(mockTransport.send).toHaveBeenCalledWith('test-session-id', expect.objectContaining({
+                error: expect.any(Object),
+            }));
+        });
+    });
+    describe('getters', () => {
+        it('should return SDK server instance', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(server.getSdkServer()).toBe(mockSdkServer);
+        });
+        it('should return transport instance', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(server.getTransport()).toBe(mockTransport);
+        });
+        it('should return session manager instance', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(server.getSessionManager()).toBe(mockSessionManager);
+        });
+        it('should return connection provider instance', () => {
+            const server = new McpServer_js_1.McpServer(mockTransport, mockSessionManager, mockConnectionProvider, mockProtocolHandler, mockHandlersRegistry, mockSdkServer);
+            expect(server.getConnectionProvider()).toBe(mockConnectionProvider);
+        });
+    });
+});

package/dist/lib/servers/v2/connection/LocalConnectionProvider.d.ts

@@ -0,0 +1,20 @@
+/**
+ * LocalConnectionProvider implementation
+ *
+ * Provides connection parameters using service keys and AuthBroker (LOCAL mode)
+ * ServiceKeyStore, SessionStore, and TokenProvider are injected into AuthBroker through Factory
+ */
+import { IConnectionProvider, IConnectionRequest, IConnectionParams, IAuthBrokerFactory } from '../interfaces/connection.js';
+/**
+ * LocalConnectionProvider - LOCAL mode connection provider
+ *
+ * Uses service keys from ServiceKeyStore and AuthBroker for token management
+ */
+export declare class LocalConnectionProvider implements IConnectionProvider {
+    private authBrokerFactory;
+    readonly mode: "LOCAL";
+    constructor(authBrokerFactory: IAuthBrokerFactory);
+    getConnectionParams(request: IConnectionRequest): Promise<IConnectionParams>;
+    updateConnectionParams(sessionId: string, params: Partial<IConnectionParams>): Promise<void>;
+}
+//# sourceMappingURL=LocalConnectionProvider.d.ts.map

package/dist/lib/servers/v2/connection/LocalConnectionProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalConnectionProvider.d.ts","sourceRoot":"","sources":["../../../../../src/lib/servers/v2/connection/LocalConnectionProvider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AAErC;;;;GAIG;AACH,qBAAa,uBAAwB,YAAW,mBAAmB;IAGrD,OAAO,CAAC,iBAAiB;IAFrC,QAAQ,CAAC,IAAI,EAAG,OAAO,CAAU;gBAEb,iBAAiB,EAAE,kBAAkB;IAEnD,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAsD5E,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;CAKjB"}

package/dist/lib/servers/v2/connection/LocalConnectionProvider.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * LocalConnectionProvider implementation
+ *
+ * Provides connection parameters using service keys and AuthBroker (LOCAL mode)
+ * ServiceKeyStore, SessionStore, and TokenProvider are injected into AuthBroker through Factory
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalConnectionProvider = void 0;
+/**
+ * LocalConnectionProvider - LOCAL mode connection provider
+ *
+ * Uses service keys from ServiceKeyStore and AuthBroker for token management
+ */
+class LocalConnectionProvider {
+    authBrokerFactory;
+    mode = 'LOCAL';
+    constructor(authBrokerFactory) {
+        this.authBrokerFactory = authBrokerFactory;
+    }
+    async getConnectionParams(request) {
+        if (!request.destination) {
+            throw new Error('Destination required for LOCAL mode');
+        }
+        // 1. Create or get AuthBroker for session
+        // AuthBroker already has injected ServiceKeyStore, SessionStore, TokenProvider
+        const authBroker = await this.authBrokerFactory.getOrCreateBroker(request.sessionId, request.destination);
+        // 2. Get/update token through AuthBroker
+        // AuthBroker internally uses:
+        //   - ServiceKeyStore to read service key
+        //   - SessionStore to save/read tokens
+        //   - TokenProvider to get new tokens
+        // getToken returns JWT token string
+        const jwtToken = await authBroker.getToken(request.destination);
+        // 3. Get connection config for URL and client
+        // Access sessionStore and serviceKeyStore from AuthBrokerFactory
+        const authBrokerFactory = this.authBrokerFactory;
+        let sapUrl;
+        let client;
+        // Try to get from sessionStore first
+        if (authBrokerFactory.sessionStore) {
+            const connConfig = await authBrokerFactory.sessionStore.getConnectionConfig(request.destination);
+            sapUrl = connConfig?.serviceUrl;
+            client = connConfig?.client;
+        }
+        // Fallback to serviceKeyStore if not in session
+        if (!sapUrl && authBrokerFactory.serviceKeyStore) {
+            const serviceKeyConnConfig = await authBrokerFactory.serviceKeyStore.getConnectionConfig(request.destination);
+            sapUrl = serviceKeyConnConfig?.serviceUrl;
+            client = serviceKeyConnConfig?.client;
+        }
+        if (!sapUrl) {
+            throw new Error(`Unable to determine SAP URL for destination: ${request.destination}`);
+        }
+        return {
+            sapUrl,
+            auth: {
+                type: 'jwt',
+                jwtToken,
+            },
+            client,
+        };
+    }
+    async updateConnectionParams(sessionId, params) {
+        // Update connection params (e.g., after token refresh)
+        // This would typically update the session's connectionParams
+        // Implementation depends on session management strategy
+    }
+}
+exports.LocalConnectionProvider = LocalConnectionProvider;

package/dist/lib/servers/v2/connection/RemoteConnectionProvider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * RemoteConnectionProvider implementation
+ *
+ * Provides connection parameters from client headers (REMOTE mode)
+ * No AuthBroker - proxy only mode
+ */
+import { IConnectionProvider, IConnectionRequest, IConnectionParams, IHeaderValidator } from '../interfaces/connection.js';
+/**
+ * RemoteConnectionProvider - REMOTE mode connection provider
+ *
+ * Extracts connection parameters from client headers via HeaderValidator
+ * No service keys or AuthBroker - pure proxy mode
+ */
+export declare class RemoteConnectionProvider implements IConnectionProvider {
+    private headerValidator;
+    readonly mode: "REMOTE";
+    constructor(headerValidator: IHeaderValidator);
+    getConnectionParams(request: IConnectionRequest): Promise<IConnectionParams>;
+    updateConnectionParams(sessionId: string, params: Partial<IConnectionParams>): Promise<void>;
+}
+//# sourceMappingURL=RemoteConnectionProvider.d.ts.map

package/dist/lib/servers/v2/connection/RemoteConnectionProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RemoteConnectionProvider.d.ts","sourceRoot":"","sources":["../../../../../src/lib/servers/v2/connection/RemoteConnectionProvider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,6BAA6B,CAAC;AAErC;;;;;GAKG;AACH,qBAAa,wBAAyB,YAAW,mBAAmB;IAGtD,OAAO,CAAC,eAAe;IAFnC,QAAQ,CAAC,IAAI,EAAG,QAAQ,CAAU;gBAEd,eAAe,EAAE,gBAAgB;IAE/C,mBAAmB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAW5E,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC;CAKjB"}

package/dist/lib/servers/v2/connection/RemoteConnectionProvider.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * RemoteConnectionProvider implementation
+ *
+ * Provides connection parameters from client headers (REMOTE mode)
+ * No AuthBroker - proxy only mode
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteConnectionProvider = void 0;
+/**
+ * RemoteConnectionProvider - REMOTE mode connection provider
+ *
+ * Extracts connection parameters from client headers via HeaderValidator
+ * No service keys or AuthBroker - pure proxy mode
+ */
+class RemoteConnectionProvider {
+    headerValidator;
+    mode = 'REMOTE';
+    constructor(headerValidator) {
+        this.headerValidator = headerValidator;
+    }
+    async getConnectionParams(request) {
+        if (!request.headers) {
+            throw new Error('Headers required for REMOTE mode');
+        }
+        // Validate and extract parameters from headers
+        const validated = await this.headerValidator.validateAndExtract(request.headers);
+        return validated;
+    }
+    async updateConnectionParams(sessionId, params) {
+        // Update connection params (e.g., after token refresh)
+        // This would typically update the session's connectionParams
+        // Implementation depends on session management strategy
+    }
+}
+exports.RemoteConnectionProvider = RemoteConnectionProvider;

package/dist/lib/servers/v2/connection/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Connection provider implementations exports
+ */
+export { LocalConnectionProvider } from './LocalConnectionProvider.js';
+export { RemoteConnectionProvider } from './RemoteConnectionProvider.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/servers/v2/connection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/servers/v2/connection/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/lib/servers/v2/connection/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Connection provider implementations exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteConnectionProvider = exports.LocalConnectionProvider = void 0;
+var LocalConnectionProvider_js_1 = require("./LocalConnectionProvider.js");
+Object.defineProperty(exports, "LocalConnectionProvider", { enumerable: true, get: function () { return LocalConnectionProvider_js_1.LocalConnectionProvider; } });
+var RemoteConnectionProvider_js_1 = require("./RemoteConnectionProvider.js");
+Object.defineProperty(exports, "RemoteConnectionProvider", { enumerable: true, get: function () { return RemoteConnectionProvider_js_1.RemoteConnectionProvider; } });

package/dist/lib/servers/v2/factory/AuthBrokerFactory.d.ts

@@ -0,0 +1,29 @@
+/**
+ * AuthBrokerFactory implementation
+ *
+ * Creates and manages AuthBroker instances with injected dependencies
+ * (ServiceKeyStore, SessionStore, TokenProvider)
+ */
+import { AuthBroker } from '@mcp-abap-adt/auth-broker';
+import type { IServiceKeyStore, ISessionStore } from '@mcp-abap-adt/auth-broker';
+import type { ITokenProvider } from '@mcp-abap-adt/auth-broker';
+import { IAuthBrokerFactory } from '../interfaces/connection.js';
+import { ILogger } from '@mcp-abap-adt/interfaces';
+/**
+ * AuthBrokerFactory - creates AuthBroker instances with DI
+ *
+ * Manages AuthBroker instances per session/destination combination
+ */
+export declare class AuthBrokerFactory implements IAuthBrokerFactory {
+    private tokenProvider?;
+    private logger?;
+    private brokers;
+    readonly serviceKeyStore: IServiceKeyStore;
+    readonly sessionStore: ISessionStore;
+    constructor(serviceKeyStore: IServiceKeyStore, sessionStore: ISessionStore, tokenProvider?: ITokenProvider | undefined, logger?: ILogger | undefined);
+    getOrCreateBroker(sessionId: string, destination: string): Promise<AuthBroker>;
+    getBroker(sessionId: string, destination?: string): AuthBroker | undefined;
+    deleteBroker(sessionId: string, destination?: string): void;
+    clearAll(): void;
+}
+//# sourceMappingURL=AuthBrokerFactory.d.ts.map

package/dist/lib/servers/v2/factory/AuthBrokerFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthBrokerFactory.d.ts","sourceRoot":"","sources":["../../../../../src/lib/servers/v2/factory/AuthBrokerFactory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,UAAU,EAAyB,MAAM,2BAA2B,CAAC;AAC9E,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;;;GAIG;AACH,qBAAa,iBAAkB,YAAW,kBAAkB;IAUxD,OAAO,CAAC,aAAa,CAAC;IACtB,OAAO,CAAC,MAAM,CAAC;IAVjB,OAAO,CAAC,OAAO,CAAsC;IAGrD,SAAgB,eAAe,EAAE,gBAAgB,CAAC;IAClD,SAAgB,YAAY,EAAE,aAAa,CAAC;gBAG1C,eAAe,EAAE,gBAAgB,EACjC,YAAY,EAAE,aAAa,EACnB,aAAa,CAAC,EAAE,cAAc,YAAA,EAC9B,MAAM,CAAC,EAAE,OAAO,YAAA;IAMpB,iBAAiB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAsBpF,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAc1E,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAgB3D,QAAQ,IAAI,IAAI;CAGjB"}

package/dist/lib/servers/v2/factory/AuthBrokerFactory.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * AuthBrokerFactory implementation
+ *
+ * Creates and manages AuthBroker instances with injected dependencies
+ * (ServiceKeyStore, SessionStore, TokenProvider)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthBrokerFactory = void 0;
+const auth_broker_1 = require("@mcp-abap-adt/auth-broker");
+/**
+ * AuthBrokerFactory - creates AuthBroker instances with DI
+ *
+ * Manages AuthBroker instances per session/destination combination
+ */
+class AuthBrokerFactory {
+    tokenProvider;
+    logger;
+    brokers = new Map();
+    // Expose stores for LocalConnectionProvider to access connection config
+    serviceKeyStore;
+    sessionStore;
+    constructor(serviceKeyStore, sessionStore, tokenProvider, logger) {
+        this.tokenProvider = tokenProvider;
+        this.logger = logger;
+        this.serviceKeyStore = serviceKeyStore;
+        this.sessionStore = sessionStore;
+    }
+    async getOrCreateBroker(sessionId, destination) {
+        const key = `${sessionId}:${destination}`;
+        if (this.brokers.has(key)) {
+            return this.brokers.get(key);
+        }
+        // Create new AuthBroker with injected dependencies
+        const config = {
+            sessionStore: this.sessionStore,
+            serviceKeyStore: this.serviceKeyStore,
+            tokenProvider: this.tokenProvider,
+        };
+        // Use 'system' browser to open default browser for authentication
+        // This will trigger browser-based auth flow when needed
+        const broker = new auth_broker_1.AuthBroker(config, 'system', this.logger);
+        this.brokers.set(key, broker);
+        return broker;
+    }
+    getBroker(sessionId, destination) {
+        if (destination) {
+            const key = `${sessionId}:${destination}`;
+            return this.brokers.get(key);
+        }
+        // Try to find any broker for this session
+        for (const [key, broker] of this.brokers.entries()) {
+            if (key.startsWith(`${sessionId}:`)) {
+                return broker;
+            }
+        }
+        return undefined;
+    }
+    deleteBroker(sessionId, destination) {
+        if (destination) {
+            const key = `${sessionId}:${destination}`;
+            this.brokers.delete(key);
+        }
+        else {
+            // Delete all brokers for this session
+            const keysToDelete = [];
+            for (const key of this.brokers.keys()) {
+                if (key.startsWith(`${sessionId}:`)) {
+                    keysToDelete.push(key);
+                }
+            }
+            keysToDelete.forEach((key) => this.brokers.delete(key));
+        }
+    }
+    clearAll() {
+        this.brokers.clear();
+    }
+}
+exports.AuthBrokerFactory = AuthBrokerFactory;

package/dist/lib/servers/v2/factory/LocalModeFactory.d.ts

@@ -0,0 +1,38 @@
+/**
+ * LocalModeFactory
+ *
+ * Factory for creating all LOCAL mode components with proper DI
+ */
+import type { IServiceKeyStore, ISessionStore } from '@mcp-abap-adt/auth-broker';
+import type { ITokenProvider } from '@mcp-abap-adt/auth-broker';
+import { IAuthBrokerFactory, IConnectionProvider } from '../interfaces/connection.js';
+import { ILogger } from '@mcp-abap-adt/interfaces';
+/**
+ * Configuration for LOCAL mode factory
+ */
+export interface LocalModeConfig {
+    serviceKeyStore: IServiceKeyStore;
+    sessionStore: ISessionStore;
+    tokenProvider?: ITokenProvider;
+    logger?: ILogger;
+}
+/**
+ * LocalModeFactory - creates all LOCAL mode components
+ *
+ * Assembles ServiceKeyStore, SessionStore, TokenProvider into
+ * AuthBrokerFactory and LocalConnectionProvider
+ */
+export declare class LocalModeFactory {
+    private config;
+    private authBrokerFactory;
+    constructor(config: LocalModeConfig);
+    /**
+     * Creates LocalConnectionProvider
+     */
+    createConnectionProvider(): IConnectionProvider;
+    /**
+     * Gets AuthBrokerFactory (for direct access if needed)
+     */
+    getAuthBrokerFactory(): IAuthBrokerFactory;
+}
+//# sourceMappingURL=LocalModeFactory.d.ts.map

package/dist/lib/servers/v2/factory/LocalModeFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalModeFactory.d.ts","sourceRoot":"","sources":["../../../../../src/lib/servers/v2/factory/LocalModeFactory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACtF,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,eAAe,EAAE,gBAAgB,CAAC;IAClC,YAAY,EAAE,aAAa,CAAC;IAC5B,aAAa,CAAC,EAAE,cAAc,CAAC;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;GAKG;AACH,qBAAa,gBAAgB;IAGf,OAAO,CAAC,MAAM;IAF1B,OAAO,CAAC,iBAAiB,CAAqB;gBAE1B,MAAM,EAAE,eAAe;IAU3C;;OAEG;IACH,wBAAwB,IAAI,mBAAmB;IAI/C;;OAEG;IACH,oBAAoB,IAAI,kBAAkB;CAG3C"}

package/dist/lib/servers/v2/factory/LocalModeFactory.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * LocalModeFactory
+ *
+ * Factory for creating all LOCAL mode components with proper DI
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalModeFactory = void 0;
+const AuthBrokerFactory_js_1 = require("./AuthBrokerFactory.js");
+const LocalConnectionProvider_js_1 = require("../connection/LocalConnectionProvider.js");
+/**
+ * LocalModeFactory - creates all LOCAL mode components
+ *
+ * Assembles ServiceKeyStore, SessionStore, TokenProvider into
+ * AuthBrokerFactory and LocalConnectionProvider
+ */
+class LocalModeFactory {
+    config;
+    authBrokerFactory;
+    constructor(config) {
+        this.config = config;
+        // Create AuthBrokerFactory with injected dependencies
+        this.authBrokerFactory = new AuthBrokerFactory_js_1.AuthBrokerFactory(config.serviceKeyStore, config.sessionStore, config.tokenProvider, config.logger);
+    }
+    /**
+     * Creates LocalConnectionProvider
+     */
+    createConnectionProvider() {
+        return new LocalConnectionProvider_js_1.LocalConnectionProvider(this.authBrokerFactory);
+    }
+    /**
+     * Gets AuthBrokerFactory (for direct access if needed)
+     */
+    getAuthBrokerFactory() {
+        return this.authBrokerFactory;
+    }
+}
+exports.LocalModeFactory = LocalModeFactory;

package/dist/lib/servers/v2/factory/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Factory implementations exports
+ */
+export { AuthBrokerFactory } from './AuthBrokerFactory.js';
+export { LocalModeFactory, type LocalModeConfig } from './LocalModeFactory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/servers/v2/factory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/servers/v2/factory/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/lib/servers/v2/factory/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Factory implementations exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalModeFactory = exports.AuthBrokerFactory = void 0;
+var AuthBrokerFactory_js_1 = require("./AuthBrokerFactory.js");
+Object.defineProperty(exports, "AuthBrokerFactory", { enumerable: true, get: function () { return AuthBrokerFactory_js_1.AuthBrokerFactory; } });
+var LocalModeFactory_js_1 = require("./LocalModeFactory.js");
+Object.defineProperty(exports, "LocalModeFactory", { enumerable: true, get: function () { return LocalModeFactory_js_1.LocalModeFactory; } });

package/dist/lib/servers/v2/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * MCP Server v2 module exports
+ *
+ * Simplified architecture - only types and utilities
+ * Transports are used directly from @modelcontextprotocol/sdk
+ */
+export * from './types/index.js';
+export * from './utils/StdioLogger.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/servers/v2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/servers/v2/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,kBAAkB,CAAC;AAGjC,cAAc,wBAAwB,CAAC"}