@mhingston5/conduit 1.1.5 → 1.1.7

package/tests/auth.service.test.ts

@@ -70,4 +70,61 @@ describe('AuthService', () => {
         expect(headers2['Authorization']).toBe('Bearer cached-access');
         expect(axios.post).toHaveBeenCalledTimes(1); // Still 1, not 2
     });
+
+    it('should send JSON token refresh for Atlassian token endpoint', async () => {
+        const creds: any = {
+            type: 'oauth2',
+            clientId: 'id',
+            clientSecret: 'secret',
+            tokenUrl: 'https://auth.atlassian.com/oauth/token',
+            refreshToken: 'refresh',
+        };
+
+        (axios.post as any).mockResolvedValue({
+            data: {
+                access_token: 'new-access',
+                expires_in: 0,
+            },
+        });
+
+        await authService.getAuthHeaders(creds);
+
+        const [, body, config] = (axios.post as any).mock.calls[0];
+        expect(body).toMatchObject({
+            grant_type: 'refresh_token',
+            refresh_token: 'refresh',
+            client_id: 'id',
+            client_secret: 'secret',
+        });
+        expect(config.headers['Content-Type']).toBe('application/json');
+    });
+
+    it('should include tokenParams and cache rotating refresh tokens', async () => {
+        const creds: any = {
+            type: 'oauth2',
+            clientId: 'id',
+            clientSecret: 'secret',
+            tokenUrl: 'https://auth.atlassian.com/oauth/token',
+            refreshToken: 'r1',
+            tokenRequestFormat: 'json',
+            tokenParams: { audience: 'api.atlassian.com' },
+        };
+
+        (axios.post as any)
+            .mockResolvedValueOnce({
+                data: { access_token: 'a1', expires_in: 0, refresh_token: 'r2' },
+            })
+            .mockResolvedValueOnce({
+                data: { access_token: 'a2', expires_in: 0 },
+            });
+
+        await authService.getAuthHeaders(creds);
+        await authService.getAuthHeaders(creds);
+
+        const firstBody = (axios.post as any).mock.calls[0][1];
+        expect(firstBody).toMatchObject({ refresh_token: 'r1', audience: 'api.atlassian.com' });
+
+        const secondBody = (axios.post as any).mock.calls[1][1];
+        expect(secondBody).toMatchObject({ refresh_token: 'r2', audience: 'api.atlassian.com' });
+    });
 });

package/tests/code-mode-lite-gateway.test.ts

@@ -36,11 +36,11 @@ describe('GatewayService (Code Mode Lite)', () => {
     });
 
     describe('listToolPackages', () => {
-        it('should return registered tool packages', async () => {
+        it('should return registered tool packages including built-ins', async () => {
             const packages = await gateway.listToolPackages();
-            expect(packages).toHaveLength(1);
-            expect(packages[0].id).toBe('mock-upstream');
-            expect(packages[0].description).toContain('Upstream mock-upstream');
+            expect(packages).toHaveLength(2); // conduit + mock-upstream
+            expect(packages.find(p => p.id === 'conduit')).toBeDefined();
+            expect(packages.find(p => p.id === 'mock-upstream')).toBeDefined();
         });
     });
 

package/tests/config.service.test.ts

@@ -81,6 +81,9 @@ upstreams:
       clientSecret: my-secret
       tokenUrl: http://token
       refreshToken: my-refresh
+      tokenRequestFormat: json
+      tokenParams:
+        audience: api.atlassian.com
 `);
 
         vi.stubEnv('CONFIG_FILE', 'conduit.test.yaml');
@@ -92,10 +95,35 @@ upstreams:
             clientId: 'my-id',
             clientSecret: 'my-secret',
             tokenUrl: 'http://token',
-            refreshToken: 'my-refresh'
+            refreshToken: 'my-refresh',
+            tokenRequestFormat: 'json',
+            tokenParams: { audience: 'api.atlassian.com' },
         });
 
         existsSpy.mockRestore();
         readSpy.mockRestore();
     });
+
+    it('should parse streamableHttp upstream correctly', () => {
+        const existsSpy = vi.spyOn(fs, 'existsSync').mockImplementation((p: any) => p.endsWith('conduit.test.yaml'));
+        const readSpy = vi.spyOn(fs, 'readFileSync').mockReturnValue(`
+upstreams:
+  - id: atlassian
+    type: streamableHttp
+    url: https://mcp.atlassian.com/v1/sse
+    credentials:
+      type: bearer
+      bearerToken: test-token
+`);
+
+        vi.stubEnv('CONFIG_FILE', 'conduit.test.yaml');
+        const configService = new ConfigService();
+        const upstreams = configService.get('upstreams');
+        expect(upstreams).toHaveLength(1);
+        expect(upstreams![0].type).toBe('streamableHttp');
+        expect((upstreams![0] as any).url).toBe('https://mcp.atlassian.com/v1/sse');
+
+        existsSpy.mockRestore();
+        readSpy.mockRestore();
+    });
 });

package/tests/gateway.service.test.ts

@@ -32,17 +32,17 @@ describe('GatewayService', () => {
 
         const tools = await gateway.discoverTools(context);
         expect(tools.length).toBeGreaterThanOrEqual(3);
-        expect(tools.find(t => t.name === 'mcp_execute_typescript')).toBeDefined();
-        expect(tools.find(t => t.name === 'mcp_execute_python')).toBeDefined();
-        expect(tools.find(t => t.name === 'mcp_execute_isolate')).toBeDefined();
+        expect(tools.find(t => t.name === 'conduit__mcp_execute_typescript')).toBeDefined();
+        expect(tools.find(t => t.name === 'conduit__mcp_execute_python')).toBeDefined();
+        expect(tools.find(t => t.name === 'conduit__mcp_execute_isolate')).toBeDefined();
         expect(tools.find(t => t.name === 'u1__t1')).toBeDefined();
         expect(tools.find(t => t.name === 'u2__t2')).toBeDefined();
     });
 
     it('should return schema for built-in tools', async () => {
-        const schema = await gateway.getToolSchema('mcp_execute_typescript', context);
+        const schema = await gateway.getToolSchema('conduit__mcp_execute_typescript', context);
         expect(schema).toBeDefined();
-        expect(schema?.name).toBe('mcp_execute_typescript');
+        expect(schema?.name).toBe('conduit__mcp_execute_typescript');
         expect(schema?.inputSchema.required).toContain('code');
     });
 

package/tests/routing.test.ts

@@ -21,6 +21,13 @@ describe('RequestController Routing', () => {
         mockGatewayService = {
             callTool: vi.fn(),
             discoverTools: vi.fn().mockResolvedValue([]),
+            policyService: {
+                parseToolName: (name: string) => {
+                    const idx = name.indexOf('__');
+                    if (idx === -1) return { namespace: '', name };
+                    return { namespace: name.substring(0, idx), name: name.substring(idx + 2) };
+                }
+            }
         };
         mockDenoExecutor = {
             execute: vi.fn().mockResolvedValue({ stdout: 'deno', stderr: '', exitCode: 0 }),

package/tests/sdk/sdk-generator.test.ts

@@ -43,7 +43,7 @@ describe('SDKGenerator', () => {
 
             const code = generator.generateTypeScript(bindings, undefined, false);
 
-            expect(code).not.toContain('$raw');
+            expect(code).not.toContain('async $raw(name, args)');
         });
 
         it('should include JSDoc comments from descriptions', () => {
@@ -74,10 +74,10 @@ describe('SDKGenerator', () => {
             const code = generator.generatePython(bindings);
 
             expect(code).toContain('class _Tools:');
-            expect(code).toContain('self.github = _ToolNamespace');
-            expect(code).toContain('"create_issue"');  // snake_case conversion
-            expect(code).toContain('self.slack = _ToolNamespace');
-            expect(code).toContain('"send_message"');  // snake_case conversion
+            expect(code).toContain('self.github = _github_Namespace');
+            expect(code).toContain('async def create_issue(self, args=None, **kwargs)');  // accepts dict or kwargs
+            expect(code).toContain('self.slack = _slack_Namespace');
+            expect(code).toContain('async def send_message(self, args=None, **kwargs)');  // accepts dict or kwargs
             expect(code).toContain('tools = _Tools()');
         });
 
@@ -88,8 +88,8 @@ describe('SDKGenerator', () => {
 
             const code = generator.generatePython(bindings);
 
-            expect(code).toContain('async def raw(self, name, args)');
-            expect(code).toContain('await _internal_call_tool(normalized, args)');
+            expect(code).toContain('async def raw(self, name, args=None)');
+            expect(code).toContain('await _internal_call_tool(normalized, args or {})');
         });
 
         it('should inject allowlist when provided', () => {

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();
+    });
+});