@mhingston5/conduit 1.1.5 → 1.1.6

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;
     }
@@ -61,6 +72,13 @@ class _Tools:
             "create_issue": lambda args, n="github__create_issue": _internal_call_tool(n, args)
         })
 
+    def __getattr__(self, name):
+        # Flat access fallback: search all namespaces
+        for ns in self.__dict__.values():
+            if isinstance(ns, _ToolNamespace) and hasattr(ns, name):
+                return getattr(ns, name)
+        raise AttributeError(f"Namespace or Tool '{name}' not found")
+
     async def raw(self, name, args):
         """Call a tool by its full name (escape hatch for dynamic/unknown tools)"""
         normalized = name.replace(".", "__")
@@ -111,7 +129,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;
     }

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/debug.fallback.test.ts

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,69 @@
+/**
+ * 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);
+});

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', () => {