@mhingston5/conduit 1.1.6 → 1.1.7

package/tests/upstream.transports.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const mcpClientMocks = {
+    connect: vi.fn(async () => undefined),
+    listTools: vi.fn(async () => ({ tools: [{ name: 'hello', description: 'hi', inputSchema: {} }] })),
+    callTool: vi.fn(async () => ({ content: [{ type: 'text', text: 'ok' }] })),
+    request: vi.fn(async () => ({ ok: true })),
+};
+
+const transportMocks = {
+    streamableHttpCtor: vi.fn(),
+    sseCtor: vi.fn(),
+};
+
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+    return {
+        Client: class {
+            connect = mcpClientMocks.connect;
+            listTools = mcpClientMocks.listTools;
+            callTool = mcpClientMocks.callTool;
+            request = mcpClientMocks.request;
+            constructor() {}
+        },
+    };
+});
+
+vi.mock('@modelcontextprotocol/sdk/client/streamableHttp.js', () => {
+    return {
+        StreamableHTTPClientTransport: class {
+            url: URL;
+            opts: any;
+            constructor(url: URL, opts: any) {
+                this.url = url;
+                this.opts = opts;
+                transportMocks.streamableHttpCtor(url, opts);
+            }
+        },
+    };
+});
+
+vi.mock('@modelcontextprotocol/sdk/client/sse.js', () => {
+    return {
+        SSEClientTransport: class {
+            url: URL;
+            opts: any;
+            constructor(url: URL, opts: any) {
+                this.url = url;
+                this.opts = opts;
+                transportMocks.sseCtor(url, opts);
+            }
+        },
+    };
+});
+
+// Not used directly but imported by UpstreamClient
+vi.mock('@modelcontextprotocol/sdk/client/stdio.js', () => {
+    return {
+        StdioClientTransport: class {},
+    };
+});
+
+describe('UpstreamClient (remote transports)', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('uses Streamable HTTP client transport for type=streamableHttp', async () => {
+        const { UpstreamClient } = await import('../src/gateway/upstream.client.js');
+
+        const logger: any = { child: () => logger, debug: vi.fn(), info: vi.fn(), error: vi.fn() };
+        const authService: any = { getAuthHeaders: vi.fn(async () => ({ Authorization: 'Bearer t' })) };
+        const urlValidator: any = { validateUrl: vi.fn(async () => ({ valid: true })) };
+
+        const client = new UpstreamClient(
+            logger,
+            { id: 'atl', type: 'streamableHttp', url: 'https://mcp.atlassian.com/v1/sse' } as any,
+            authService,
+            urlValidator
+        );
+
+        const res = await client.call({ jsonrpc: '2.0', id: '1', method: 'tools/list' } as any, { correlationId: 'c1' } as any);
+
+        expect(transportMocks.streamableHttpCtor).toHaveBeenCalled();
+        expect(urlValidator.validateUrl).toHaveBeenCalled();
+        expect(mcpClientMocks.connect).toHaveBeenCalled();
+        expect(mcpClientMocks.listTools).toHaveBeenCalled();
+        expect(res.result).toBeDefined();
+    });
+
+    it('lazily creates SSE transport for type=sse and attaches auth headers', async () => {
+        const { UpstreamClient } = await import('../src/gateway/upstream.client.js');
+
+        const logger: any = { child: () => logger, debug: vi.fn(), info: vi.fn(), error: vi.fn() };
+        const authService: any = { getAuthHeaders: vi.fn(async () => ({ Authorization: 'Bearer t' })) };
+        const urlValidator: any = { validateUrl: vi.fn(async () => ({ valid: true })) };
+
+        const client = new UpstreamClient(
+            logger,
+            {
+                id: 'atl',
+                type: 'sse',
+                url: 'https://mcp.atlassian.com/v1/sse',
+                credentials: { type: 'bearer', bearerToken: 't' },
+            } as any,
+            authService,
+            urlValidator
+        );
+
+        await client.call({ jsonrpc: '2.0', id: '1', method: 'tools/list' } as any, { correlationId: 'c1' } as any);
+
+        expect(authService.getAuthHeaders).toHaveBeenCalled();
+        expect(transportMocks.sseCtor).toHaveBeenCalled();
+        const [, opts] = transportMocks.sseCtor.mock.calls[0];
+        expect(opts.requestInit.headers).toMatchObject({ Authorization: 'Bearer t' });
+        expect(mcpClientMocks.connect).toHaveBeenCalled();
+    });
+});

package/tests/debug.fallback.test.ts

@@ -1,40 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { GatewayService } from '../src/gateway/gateway.service.js';
-import { ExecutionContext } from '../src/core/execution.context.js';
-import pino from 'pino';
-
-const logger = pino({ level: 'silent' });
-
-describe('GatewayService Namespace Fallback Debug', () => {
-    let gateway: GatewayService;
-    let context: ExecutionContext;
-
-    beforeEach(() => {
-        const securityService = {
-            validateUrl: vi.fn().mockReturnValue({ valid: true }),
-        } as any;
-        gateway = new GatewayService(logger, securityService);
-        context = new ExecutionContext({ logger });
-    });
-
-    it('should show detailed error when upstream not found', async () => {
-        const response = await gateway.callTool('nonexistent__tool', {}, context);
-        expect(response.error?.message).toContain("Upstream not found: 'nonexistent'");
-        expect(response.error?.message).toContain("Available: none");
-    });
-
-    it('should hit fallback for namespaceless tool', async () => {
-        // Register an upstream with a tool
-        gateway.registerUpstream({ id: 'fs', url: 'http://fs' });
-
-        // Mock discovery
-        vi.spyOn(gateway, 'discoverTools').mockResolvedValue([
-            { name: 'fs__list_directory', description: '', inputSchema: {} }
-        ] as any);
-
-        const response = await gateway.callTool('list_directory', {}, context);
-        // It should NOT return "Upstream not found: ''"
-        expect(response.error?.message).not.toContain("Upstream not found");
-        // It should try to call fs__list_directory (which will fail due to lack of axios mock here, but that's fine)
-    });
-});

package/tests/debug_upstream.ts

@@ -1,69 +0,0 @@
-/**
- * Debug script to verify the filesystem upstream is working correctly.
- * Run with: npx tsx tests/debug_upstream.ts
- */
-import { ConfigService } from '../src/core/config.service.js';
-import { createLogger } from '../src/core/logger.js';
-import { GatewayService } from '../src/gateway/gateway.service.js';
-import { SecurityService } from '../src/core/security.service.js';
-import { ExecutionContext } from '../src/core/execution.context.js';
-
-async function main() {
-    console.log('=== Conduit Upstream Debug ===\n');
-
-    const configService = new ConfigService();
-    const logger = createLogger(configService);
-
-    console.log('Config loaded from:', process.cwd());
-    console.log('Upstreams configured:', JSON.stringify(configService.get('upstreams'), null, 2));
-    console.log();
-
-    const securityService = new SecurityService(logger, undefined);
-    const gatewayService = new GatewayService(logger, securityService);
-
-    // Register upstreams from config
-    const upstreams = configService.get('upstreams') || [];
-    for (const upstream of upstreams) {
-        console.log(`Registering upstream: ${upstream.id} (${upstream.type})`);
-        gatewayService.registerUpstream(upstream);
-    }
-
-    console.log('\n=== Testing Tool Discovery ===\n');
-
-    const context = new ExecutionContext({ logger });
-
-    // Give the filesystem server a moment to start
-    console.log('Waiting 3 seconds for upstream servers to initialize...');
-    await new Promise(resolve => setTimeout(resolve, 3000));
-
-    try {
-        const tools = await gatewayService.discoverTools(context);
-        console.log(`\nDiscovered ${tools.length} tools:`);
-        for (const tool of tools) {
-            console.log(`  - ${tool.name}: ${tool.description || '(no description)'}`);
-        }
-
-        // Try to find list_directory
-        const listDirTool = tools.find(t => t.name.includes('list_directory') || t.name.includes('list_dir'));
-        if (listDirTool) {
-            console.log(`\n✅ Found list_directory tool: ${listDirTool.name}`);
-
-            // Try calling it
-            console.log('\n=== Testing Tool Call ===\n');
-            const result = await gatewayService.callTool(listDirTool.name, { path: '/private/tmp' }, context);
-            console.log('Result:', JSON.stringify(result, null, 2));
-        } else {
-            console.log('\n❌ list_directory tool NOT found in discovered tools');
-        }
-    } catch (error: any) {
-        console.error('Error during discovery:', error.message);
-    }
-
-    console.log('\n=== Debug Complete ===');
-    process.exit(0);
-}
-
-main().catch(err => {
-    console.error('Fatal error:', err);
-    process.exit(1);
-});