@mhingston5/conduit 1.1.5 → 1.1.7

package/src/gateway/host.client.ts

@@ -0,0 +1,65 @@
+import { Logger } from 'pino';
+import { JSONRPCRequest, JSONRPCResponse } from '../core/types.js';
+import { ExecutionContext } from '../core/execution.context.js';
+import { StdioTransport } from '../transport/stdio.transport.js';
+
+/**
+ * HostClient - Proxies tool calls back to the MCP client (e.g. VS Code)
+ * that is hosting this Conduit process.
+ */
+export class HostClient {
+    constructor(
+        private logger: Logger,
+        private transport: StdioTransport
+    ) { }
+
+    async call(request: JSONRPCRequest, context: ExecutionContext): Promise<JSONRPCResponse> {
+        try {
+            this.logger.debug({ method: request.method }, 'Forwarding request to host');
+
+            let method = request.method;
+            let params = request.params;
+
+            // Bridge mcp_* calls to standard MCP calls for the host
+            if (method === 'mcp_call_tool' || method === 'call_tool') {
+                method = 'tools/call';
+            } else if (method === 'mcp_discover_tools' || method === 'discover_tools') {
+                method = 'tools/list';
+                params = {};
+            }
+
+            const result = await this.transport.callHost(method, params);
+
+            return {
+                jsonrpc: '2.0',
+                id: request.id,
+                result
+            };
+        } catch (error: any) {
+            this.logger.error({ err: error.message }, 'Host call failed');
+            return {
+                jsonrpc: '2.0',
+                id: request.id,
+                error: {
+                    code: -32008,
+                    message: `Host error: ${error.message}`,
+                },
+            };
+        }
+    }
+
+    async listTools(): Promise<any[]> {
+        try {
+            this.logger.debug('Fetching tool list from host');
+            const result = await this.transport.callHost('tools/list', {});
+            return result.tools || [];
+        } catch (error: any) {
+            this.logger.warn({ err: error.message }, 'Failed to fetch tools from host');
+            return [];
+        }
+    }
+
+    async getManifest() {
+        return null;
+    }
+}

package/src/gateway/upstream.client.ts

@@ -7,6 +7,8 @@ import { IUrlValidator } from '../core/interfaces/url.validator.interface.js';
 
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { z } from 'zod';
 
 export type UpstreamInfo = {
@@ -14,6 +16,8 @@ export type UpstreamInfo = {
     credentials?: UpstreamCredentials;
 } & (
         | { type?: 'http'; url: string }
+        | { type: 'streamableHttp'; url: string }
+        | { type: 'sse'; url: string }
         | { type: 'stdio'; command: string; args?: string[]; env?: Record<string, string> }
     );
 
@@ -23,7 +27,8 @@ export class UpstreamClient {
     private authService: AuthService;
     private urlValidator: IUrlValidator;
     private mcpClient?: Client;
-    private transport?: StdioClientTransport;
+    private transport?: StdioClientTransport | StreamableHTTPClientTransport | SSEClientTransport;
+    private connected: boolean = false;
 
     constructor(logger: Logger, info: UpstreamInfo, authService: AuthService, urlValidator: IUrlValidator) {
         this.logger = logger.child({ upstreamId: info.id });
@@ -50,40 +55,101 @@ export class UpstreamClient {
             }, {
                 capabilities: {},
             });
+            return;
+        }
+
+        if (this.info.type === 'streamableHttp') {
+            this.transport = new StreamableHTTPClientTransport(new URL(this.info.url), {
+                fetch: this.createAuthedFetch(),
+            });
+            this.mcpClient = new Client({
+                name: 'conduit-gateway',
+                version: '1.0.0',
+            }, {
+                capabilities: {},
+            });
+            return;
+        }
+
+        if (this.info.type === 'sse') {
+            this.mcpClient = new Client({
+                name: 'conduit-gateway',
+                version: '1.0.0',
+            }, {
+                capabilities: {},
+            });
         }
     }
 
-    private async ensureConnected() {
-        if (!this.mcpClient || !this.transport) return;
-        // There isn't a public isConnected property easily accessible, 
-        // usually we just connect once.
-        // We can track connected state or just try/catch connect.
-        // For simplicity, we connect once and existing sdk handles reconnection or errors usually kill it.
-        // Actually SDK Client.connect() is for the transport.
-        try {
-            // @ts-ignore - Check internal state or just attempt connect if we haven't
-            if (!this.transport.connection) {
-                await this.mcpClient.connect(this.transport);
+    private createAuthedFetch() {
+        const creds = this.info.credentials;
+        if (!creds) return fetch;
+
+        return async (input: any, init: any = {}) => {
+            const headers = new Headers(init.headers || {});
+            const authHeaders = await this.authService.getAuthHeaders(creds);
+            for (const [k, v] of Object.entries(authHeaders)) {
+                headers.set(k, v);
             }
-        } catch (e) {
-            // connection might already be active
+            return fetch(input, { ...init, headers });
+        };
+    }
+
+    private async ensureConnected() { 
+        if (!this.mcpClient) return;
+
+        if (!this.transport && this.info.type === 'sse') {
+            const authHeaders = this.info.credentials
+                ? await this.authService.getAuthHeaders(this.info.credentials)
+                : {};
+
+            this.transport = new SSEClientTransport(new URL(this.info.url), {
+                fetch: this.createAuthedFetch(),
+                eventSourceInit: { headers: authHeaders } as any,
+                requestInit: { headers: authHeaders },
+            });
+        }
+
+        if (!this.transport) return;
+        if (this.connected) return;
+
+        if (this.info.type === 'streamableHttp' || this.info.type === 'sse') {
+            const securityResult = await this.urlValidator.validateUrl(this.info.url);
+            if (!securityResult.valid) {
+                this.logger.error({ url: this.info.url }, 'Blocked upstream URL (SSRF)');
+                throw new Error(securityResult.message || 'Forbidden URL');
+            }
+        }
+
+        try {
+            this.logger.debug('Connecting to upstream transport...');
+            await this.mcpClient.connect(this.transport);
+            this.connected = true;
+            this.logger.info('Connected to upstream MCP');
+        } catch (e: any) {
+            this.logger.error({ err: e.message }, 'Failed to connect to upstream');
+            throw e;
         }
     }
 
     async call(request: JSONRPCRequest, context: ExecutionContext): Promise<JSONRPCResponse> {
-        // Helper to determine type safely
-        const isStdio = (info: UpstreamInfo): info is { type: 'stdio'; command: string; args?: string[]; env?: Record<string, string>; id: string; credentials?: UpstreamCredentials } => info.type === 'stdio';
+        const usesMcpClientTransport = (info: UpstreamInfo): info is (
+            | { type: 'stdio'; command: string; args?: string[]; env?: Record<string, string> }
+            | { type: 'streamableHttp'; url: string }
+            | { type: 'sse'; url: string }
+        ) & { id: string; credentials?: UpstreamCredentials } =>
+            info.type === 'stdio' || info.type === 'streamableHttp' || info.type === 'sse';
 
-        if (isStdio(this.info)) {
-            return this.callStdio(request);
-        } else {
-            return this.callHttp(request, context as ExecutionContext);
+        if (usesMcpClientTransport(this.info)) {
+            return this.callMcpClient(request);
         }
+
+        return this.callHttp(request, context as ExecutionContext);
     }
 
-    private async callStdio(request: JSONRPCRequest): Promise<JSONRPCResponse> {
+    private async callMcpClient(request: JSONRPCRequest): Promise<JSONRPCResponse> {
         if (!this.mcpClient) {
-            return { jsonrpc: '2.0', id: request.id, error: { code: -32603, message: 'Stdio client not initialized' } };
+            return { jsonrpc: '2.0', id: request.id, error: { code: -32603, message: 'MCP client not initialized' } };
         }
 
         try {
@@ -129,13 +195,13 @@ export class UpstreamClient {
                 };
             }
         } catch (error: any) {
-            this.logger.error({ err: error }, 'Stdio call failed');
+            this.logger.error({ err: error }, 'MCP call failed');
             return {
                 jsonrpc: '2.0',
                 id: request.id,
                 error: {
                     code: error.code || -32603,
-                    message: error.message || 'Internal error in stdio transport'
+                    message: error.message || 'Internal error in MCP transport'
                 }
             };
         }
@@ -143,7 +209,9 @@ export class UpstreamClient {
 
     private async callHttp(request: JSONRPCRequest, context: ExecutionContext): Promise<JSONRPCResponse> {
         // Narrowing for TS
-        if (this.info.type === 'stdio') throw new Error('Unreachable');
+        if (this.info.type === 'stdio' || this.info.type === 'streamableHttp' || this.info.type === 'sse') {
+            throw new Error('Unreachable');
+        }
         const url = this.info.url;
 
         const headers: Record<string, string> = {
@@ -205,7 +273,7 @@ export class UpstreamClient {
         }
     }
     async getManifest(context: ExecutionContext): Promise<ToolManifest | null> {
-        if (this.info.type !== 'http') return null;
+        if (this.info.type && this.info.type !== 'http') return null;
 
         try {
             const baseUrl = this.info.url.replace(/\/$/, ''); // Remove trailing slash

package/src/index.ts

@@ -29,9 +29,10 @@ program
     .command('serve', { isDefault: true })
     .description('Start the Conduit server')
     .option('--stdio', 'Use stdio transport')
+    .option('--config <path>', 'Path to config file')
     .action(async (options) => {
         try {
-            await startServer();
+            await startServer(options);
         } catch (err) {
             console.error('Failed to start Conduit:', err);
             process.exit(1);
@@ -68,8 +69,13 @@ program
         }
     });
 
-async function startServer() {
-    const configService = new ConfigService();
+async function startServer(options: any = {}) {
+    // Merge command line options into config overrides
+    const overrides: any = {};
+    if (options.stdio) overrides.transport = 'stdio';
+    if (options.config) process.env.CONFIG_FILE = options.config;
+
+    const configService = new ConfigService(overrides);
     const logger = createLogger(configService);
 
     const otelService = new OtelService(logger);
@@ -84,6 +90,7 @@ async function startServer() {
 
         const gatewayService = new GatewayService(logger, securityService);
         const upstreams = configService.get('upstreams') || [];
+        logger.info({ upstreamCount: upstreams.length, upstreamIds: upstreams.map((u: any) => u.id) }, 'Registering upstreams from config');
         for (const upstream of upstreams) {
             gatewayService.registerUpstream(upstream);
         }
@@ -122,8 +129,10 @@ async function startServer() {
         let address: string;
 
         if (configService.get('transport') === 'stdio') {
-            transport = new StdioTransport(logger, requestController, concurrencyService);
+            const stdioTransport = new StdioTransport(logger, requestController, concurrencyService);
+            transport = stdioTransport;
             await transport.start();
+            gatewayService.registerHost(stdioTransport);
             address = 'stdio';
 
             // IMPORTANT: Even in stdio mode, we need a local socket for sandboxes to talk to

package/src/sdk/sdk-generator.ts

@@ -10,7 +10,9 @@ export class SDKGenerator {
      * Convert camelCase to snake_case for Python
      */
     private toSnakeCase(str: string): string {
-        return str.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '');
+        const snake = str.replace(/([A-Z])/g, '_$1').toLowerCase().replace(/^_/, '').replace(/[^a-z0-9_]/g, '_');
+        // Ensure it doesn't start with a number
+        return /^[0-9]/.test(snake) ? `_${snake}` : snake;
     }
 
     /**
@@ -98,7 +100,18 @@ const tools = new Proxy(_tools, {
         if (prop in target) return target[prop];
         if (prop === 'then') return undefined;
         if (typeof prop === 'string') {
-            throw new Error(\`Namespace '\${prop}' not found. It might be invalid, or all tools in it were disallowed.\`);
+            // Flat tool access fallback: search all namespaces for a matching tool
+            for (const nsName of Object.keys(target)) {
+                if (nsName === '$raw') continue;
+                const ns = target[nsName];
+                if (ns && typeof ns === 'object' && ns[prop]) {
+                    return ns[prop];
+                }
+            }
+
+            const forbidden = ['\x24raw'];
+            const namespaces = Object.keys(target).filter(k => !forbidden.includes(k));
+            throw new Error(\`Namespace or Tool '\${prop}' not found. Available namespaces: \${namespaces.join(', ') || 'none'}. Use tools.$raw(name, args) for dynamic calls.\`);
         }
         return undefined;
     }
@@ -131,35 +144,47 @@ const tools = new Proxy(_tools, {
         }
 
         lines.push('');
-        lines.push('class _ToolNamespace:');
-        lines.push('    def __init__(self, methods):');
-        lines.push('        for name, fn in methods.items():');
-        lines.push('            setattr(self, name, fn)');
-        lines.push('');
-        lines.push('class _Tools:');
-        lines.push('    def __init__(self):');
 
+        // Generate namespace classes
         for (const [namespace, tools] of grouped.entries()) {
             const safeNamespace = this.toSnakeCase(namespace);
-            const methodsDict: string[] = [];
+            lines.push(`class _${safeNamespace}_Namespace:`);
 
             for (const tool of tools) {
                 const methodName = this.toSnakeCase(tool.methodName);
                 const fullName = tool.name;
-                // Use async lambda - Python doesn't have async lambdas natively,
-                // so we define methods that return awaitable coroutines
-                methodsDict.push(`            "${methodName}": lambda args, n="${this.escapeString(fullName)}": _internal_call_tool(n, args)`);
+                // Accept both dict as first arg OR kwargs for flexibility
+                lines.push(`    async def ${methodName}(self, args=None, **kwargs):`);
+                lines.push(`        params = args if args is not None else kwargs`);
+                lines.push(`        return await _internal_call_tool("${this.escapeString(fullName)}", params)`);
             }
+            lines.push('');
+        }
 
-            lines.push(`        self.${safeNamespace} = _ToolNamespace({`);
-            lines.push(methodsDict.join(',\n'));
-            lines.push(`        })`);
+        // Generate the main Tools class
+        lines.push('class _Tools:');
+        lines.push('    def __init__(self):');
+        if (grouped.size === 0) {
+            lines.push('        pass');
+        } else {
+            for (const [namespace] of grouped.entries()) {
+                const safeNamespace = this.toSnakeCase(namespace);
+                lines.push(`        self.${safeNamespace} = _${safeNamespace}_Namespace()`);
+            }
         }
 
-        // Add raw escape hatch with allowlist validation
+        lines.push('');
+        lines.push('    def __getattr__(self, name):');
+        lines.push('        # Flat access fallback: search all namespaces');
+        lines.push('        for attr_name in dir(self):');
+        lines.push('            attr = getattr(self, attr_name, None)');
+        lines.push('            if attr and hasattr(attr, name):');
+        lines.push('                return getattr(attr, name)');
+        lines.push('        raise AttributeError(f"Namespace or Tool \'{name}\' not found")');
+
         if (enableRawFallback) {
             lines.push('');
-            lines.push('    async def raw(self, name, args):');
+            lines.push('    async def raw(self, name, args=None):');
             lines.push('        """Call a tool by its full name (escape hatch for dynamic/unknown tools)"""');
             lines.push('        normalized = name.replace(".", "__")');
             lines.push('        if _allowed_tools is not None:');
@@ -169,7 +194,7 @@ const tools = new Proxy(_tools, {
             lines.push('            )');
             lines.push('            if not allowed:');
             lines.push('                raise PermissionError(f"Tool {name} is not in the allowlist")');
-            lines.push('        return await _internal_call_tool(normalized, args)');
+            lines.push('        return await _internal_call_tool(normalized, args or {})');
         }
 
         lines.push('');
@@ -224,23 +249,23 @@ const tools = new Proxy(_tools, {
                 lines.push(`    },`);
             }
 
-            lines.push(`  },`);
+            lines.push('  },');
         }
 
         // Add $raw escape hatch
         if (enableRawFallback) {
-            lines.push(`  async $raw(name, args) {`);
+            lines.push('  async $raw(name, args) {');
             lines.push(`    const normalized = name.replace(/\\./g, '__');`);
-            lines.push(`    if (__allowedTools) {`);
+            lines.push('    if (__allowedTools) {');
             lines.push(`      const allowed = __allowedTools.some(p => {`);
             lines.push(`        if (p.endsWith('__*')) return normalized.startsWith(p.slice(0, -1));`);
-            lines.push(`        return normalized === p;`);
-            lines.push(`      });`);
-            lines.push(`      if (!allowed) throw new Error(\`Tool \${name} is not in the allowlist\`);`);
-            lines.push(`    }`);
-            lines.push(`    const resStr = await __callTool(normalized, JSON.stringify(args || {}));`);
-            lines.push(`    return JSON.parse(resStr);`);
-            lines.push(`  },`);
+            lines.push('        return normalized === p;');
+            lines.push('      });');
+            lines.push('      if (!allowed) throw new Error(`Tool ${name} is not in the allowlist`);');
+            lines.push('    }');
+            lines.push('    const resStr = await __callTool(normalized, JSON.stringify(args || {}));');
+            lines.push('    return JSON.parse(resStr);');
+            lines.push('  },');
         }
 
         lines.push('};');
@@ -250,7 +275,18 @@ const tools = new Proxy(_tools, {
         if (prop in target) return target[prop];
         if (prop === 'then') return undefined;
         if (typeof prop === 'string') {
-            throw new Error(\`Namespace '\${prop}' not found. It might be invalid, or all tools in it were disallowed.\`);
+            // Flat tool access fallback: search all namespaces for a matching tool
+            for (const nsName of Object.keys(target)) {
+                if (nsName === '$raw') continue;
+                const ns = target[nsName];
+                if (ns && typeof ns === 'object' && ns[prop]) {
+                    return ns[prop];
+                }
+            }
+
+            const forbidden = ['\x24raw'];
+            const namespaces = Object.keys(target).filter(k => !forbidden.includes(k));
+            throw new Error(\`Namespace or Tool '\${prop}' not found. Available namespaces: \${namespaces.join(', ') || 'none'}. Use tools.$raw(name, args) for dynamic calls.\`);
         }
         return undefined;
     }

package/src/transport/stdio.transport.ts

@@ -10,6 +10,7 @@ export class StdioTransport {
     private requestController: RequestController;
     private concurrencyService: ConcurrencyService;
     private buffer: string = '';
+    private pendingRequests = new Map<string | number, (response: any) => void>();
 
     constructor(
         logger: Logger,
@@ -33,6 +34,34 @@ export class StdioTransport {
         });
     }
 
+    async callHost(method: string, params: any): Promise<any> {
+        const id = Math.random().toString(36).substring(7);
+        const request = {
+            jsonrpc: '2.0',
+            id,
+            method,
+            params
+        };
+
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error(`Timeout waiting for host response to ${method}`));
+            }, 30000);
+
+            this.pendingRequests.set(id, (response) => {
+                clearTimeout(timeout);
+                if (response.error) {
+                    reject(new Error(response.error.message));
+                } else {
+                    resolve(response.result);
+                }
+            });
+
+            this.sendResponse(request);
+        });
+    }
+
     private handleData(chunk: string) {
         this.buffer += chunk;
 
@@ -48,11 +77,11 @@ export class StdioTransport {
     }
 
     private async processLine(line: string) {
-        let request: JSONRPCRequest;
+        let message: any;
         try {
-            request = JSON.parse(line) as JSONRPCRequest;
+            message = JSON.parse(line);
         } catch (err) {
-            this.logger.error({ err, line }, 'Failed to parse JSON-RPC request');
+            this.logger.error({ err, line }, 'Failed to parse JSON-RPC message');
             const errorResponse = {
                 jsonrpc: '2.0',
                 id: null,
@@ -65,6 +94,18 @@ export class StdioTransport {
             return;
         }
 
+        // Handle Response
+        if (message.id !== undefined && (message.result !== undefined || message.error !== undefined)) {
+            const pending = this.pendingRequests.get(message.id);
+            if (pending) {
+                this.pendingRequests.delete(message.id);
+                pending(message);
+                return;
+            }
+        }
+
+        // Handle Request
+        const request = message as JSONRPCRequest;
         const context = new ExecutionContext({
             logger: this.logger,
             remoteAddress: 'stdio',

package/tests/__snapshots__/assets.test.ts.snap

@@ -35,7 +35,18 @@ const tools = new Proxy(_tools, {
         if (prop in target) return target[prop];
         if (prop === 'then') return undefined;
         if (typeof prop === 'string') {
-            throw new Error(\`Namespace '\${prop}' not found. It might be invalid, or all tools in it were disallowed.\`);
+            // Flat tool access fallback: search all namespaces for a matching tool
+            for (const nsName of Object.keys(target)) {
+                if (nsName === '$raw') continue;
+                const ns = target[nsName];
+                if (ns && typeof ns === 'object' && ns[prop]) {
+                    return ns[prop];
+                }
+            }
+
+            const forbidden = ['$raw'];
+            const namespaces = Object.keys(target).filter(k => !forbidden.includes(k));
+            throw new Error(\`Namespace or Tool '\${prop}' not found. Available namespaces: \${namespaces.join(', ') || 'none'}. Use tools.$raw(name, args) for dynamic calls.\`);
         }
         return undefined;
     }
@@ -47,21 +58,30 @@ exports[`Asset Integrity (Golden Tests) > should match Python SDK snapshot 1`] =
 "# Generated SDK - Do not edit
 _allowed_tools = ["test__*","github__*"]
 
-class _ToolNamespace:
-    def __init__(self, methods):
-        for name, fn in methods.items():
-            setattr(self, name, fn)
+class _test_Namespace:
+    async def hello(self, args=None, **kwargs):
+        params = args if args is not None else kwargs
+        return await _internal_call_tool("test__hello", params)
+
+class _github_Namespace:
+    async def create_issue(self, args=None, **kwargs):
+        params = args if args is not None else kwargs
+        return await _internal_call_tool("github__create_issue", params)
 
 class _Tools:
     def __init__(self):
-        self.test = _ToolNamespace({
-            "hello": lambda args, n="test__hello": _internal_call_tool(n, args)
-        })
-        self.github = _ToolNamespace({
-            "create_issue": lambda args, n="github__create_issue": _internal_call_tool(n, args)
-        })
+        self.test = _test_Namespace()
+        self.github = _github_Namespace()
 
-    async def raw(self, name, args):
+    def __getattr__(self, name):
+        # Flat access fallback: search all namespaces
+        for attr_name in dir(self):
+            attr = getattr(self, attr_name, None)
+            if attr and hasattr(attr, name):
+                return getattr(attr, name)
+        raise AttributeError(f"Namespace or Tool '{name}' not found")
+
+    async def raw(self, name, args=None):
         """Call a tool by its full name (escape hatch for dynamic/unknown tools)"""
         normalized = name.replace(".", "__")
         if _allowed_tools is not None:
@@ -71,7 +91,7 @@ class _Tools:
             )
             if not allowed:
                 raise PermissionError(f"Tool {name} is not in the allowlist")
-        return await _internal_call_tool(normalized, args)
+        return await _internal_call_tool(normalized, args or {})
 
 tools = _Tools()"
 `;
@@ -111,7 +131,18 @@ const tools = new Proxy(_tools, {
         if (prop in target) return target[prop];
         if (prop === 'then') return undefined;
         if (typeof prop === 'string') {
-            throw new Error(\`Namespace '\${prop}' not found. It might be invalid, or all tools in it were disallowed.\`);
+            // Flat tool access fallback: search all namespaces for a matching tool
+            for (const nsName of Object.keys(target)) {
+                if (nsName === '$raw') continue;
+                const ns = target[nsName];
+                if (ns && typeof ns === 'object' && ns[prop]) {
+                    return ns[prop];
+                }
+            }
+
+            const forbidden = ['$raw'];
+            const namespaces = Object.keys(target).filter(k => !forbidden.includes(k));
+            throw new Error(\`Namespace or Tool '\${prop}' not found. Available namespaces: \${namespaces.join(', ') || 'none'}. Use tools.$raw(name, args) for dynamic calls.\`);
         }
         return undefined;
     }