@mhingston5/conduit 1.0.0

package/tests/deno.executor.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { DenoExecutor } from '../src/executors/deno.executor.js';
+import { ExecutionContext } from '../src/core/execution.context.js';
+import pino from 'pino';
+
+const logger = pino({ level: 'silent' });
+
+describe('DenoExecutor', () => {
+    let executor: DenoExecutor;
+    let context: ExecutionContext;
+
+    beforeEach(() => {
+        executor = new DenoExecutor();
+        context = new ExecutionContext({ logger });
+    });
+
+    it('should execute simple typescript code', async () => {
+        const result = await executor.execute('console.log("hello")', {
+            timeoutMs: 5000,
+            memoryLimitMb: 128,
+            maxOutputBytes: 1024,
+            maxLogEntries: 100,
+        }, context);
+
+        expect(result.stdout).toContain('hello');
+        expect(result.exitCode).toBe(0);
+    });
+
+    it('should timeout on infinite loops', async () => {
+        const startTime = Date.now();
+        const result = await executor.execute('while(true){}', {
+            timeoutMs: 500,
+            memoryLimitMb: 128,
+            maxOutputBytes: 1024,
+            maxLogEntries: 100,
+        }, context);
+
+        const duration = Date.now() - startTime;
+        expect(duration).toBeGreaterThanOrEqual(500);
+        expect(result.exitCode).toBe(null);
+    });
+
+    it('should enforce output limits', async () => {
+        const result = await executor.execute('console.log("A".repeat(2000))', {
+            timeoutMs: 5000,
+            memoryLimitMb: 128,
+            maxOutputBytes: 100,
+            maxLogEntries: 100,
+        }, context);
+
+        expect(result.stdout.length).toBeLessThanOrEqual(100);
+        expect(result.error?.code).toBe(-32013);
+    });
+
+    it('should enforce memory limits', async () => {
+        // Grow heap until it hits the limit
+        const result = await executor.execute('const a = []; while(true) a.push(new Array(10000).fill(0));', {
+            timeoutMs: 5000,
+            memoryLimitMb: 64,
+            maxOutputBytes: 1024,
+            maxLogEntries: 100,
+        }, context);
+
+        expect(result.exitCode).not.toBe(0);
+        // V8 might throw Out of Memory error on stderr
+        expect(result.stderr).toMatch(/out of memory|exhausted/i);
+    });
+});

package/tests/deno_hardening.test.ts

@@ -0,0 +1,45 @@
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { DenoExecutor } from '../src/executors/deno.executor.js'; // Adjust path if needed
+import { ConduitError } from '../src/core/request.controller.js';
+import { pino } from 'pino';
+
+// Need to match the imports in deno.executor; it uses relative paths. 
+// Assuming tests are in `tests/` and src in `src/`.
+// Imports in `deno.executor.ts` are `../core/...`
+
+describe('DenoExecutor Hardening', () => {
+    let executor: DenoExecutor;
+
+    beforeEach(() => {
+        executor = new DenoExecutor();
+    });
+
+    it.skip('should return LogLimitExceeded code when log limit is reached', async () => {
+        // Skipping because this requires `deno` to be installed and available in environment
+        // and we might not want to spawn processes in unit tests if avoidable.
+        // But for verification, we can run it once.
+
+        const context = {
+            logger: pino({ level: 'silent' }),
+            correlationId: 'test'
+        } as any;
+
+        const result = await executor.execute(
+            'for (let i = 0; i < 20; i++) console.log("line " + i);',
+            {
+                timeoutMs: 2000,
+                memoryLimitMb: 128,
+                maxOutputBytes: 1024,
+                maxLogEntries: 5 // Low limit
+            },
+            context
+        );
+
+        expect(result.error).toBeDefined();
+        if (result.error) {
+            expect(result.error.code).toBe(ConduitError.LogLimitExceeded); // -32014
+            expect(result.error.message).toBe('Log entry limit exceeded');
+        }
+    });
+});

package/tests/dynamic.tool.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
+import { SocketTransport } from '../src/transport/socket.transport.js';
+import { RequestController } from '../src/core/request.controller.js';
+import { GatewayService } from '../src/gateway/gateway.service.js';
+import { SecurityService } from '../src/core/security.service.js';
+import { ConcurrencyService } from '../src/core/concurrency.service.js';
+import pino from 'pino';
+import { ExecutionContext } from '../src/core/execution.context.js';
+import { ExecutionService } from '../src/core/execution.service.js';
+import { ExecutorRegistry } from '../src/core/registries/executor.registry.js';
+import { DenoExecutor } from '../src/executors/deno.executor.js';
+import { PyodideExecutor } from '../src/executors/pyodide.executor.js';
+import { IsolateExecutor } from '../src/executors/isolate.executor.js';
+import { buildDefaultMiddleware } from '../src/core/middleware/middleware.builder.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const logger = pino({ level: 'silent' });
+const defaultLimits = {
+    timeoutMs: 10000,
+    memoryLimitMb: 128,
+    maxOutputBytes: 1024 * 1024,
+    maxLogEntries: 100,
+};
+
+const LOG_FILE = path.join(os.tmpdir(), `conduit-test-debug-${process.pid}.log`);
+
+describe('Dynamic Tool Calling (E2E)', () => {
+    let transport: SocketTransport;
+    let requestController: RequestController;
+    let gatewayService: GatewayService;
+    let securityService: SecurityService;
+    let concurrencyService: ConcurrencyService;
+    const testToken = 'dynamic-test-token';
+    let ipcAddress: string;
+
+    beforeAll(async () => {
+        if (fs.existsSync(LOG_FILE)) fs.unlinkSync(LOG_FILE);
+
+        securityService = new SecurityService(logger, testToken);
+        gatewayService = new GatewayService(logger, securityService);
+
+        // Register a mock upstream tool
+        (gatewayService as any).clients.set('mock', {
+            call: vi.fn().mockImplementation((req) => {
+                if (req.method === 'call_tool' && req.params.name === 'hello') {
+                    return { jsonrpc: '2.0', id: req.id, result: { content: [{ type: 'text', text: `Hello ${req.params.arguments.name}` }] } };
+                }
+                if (req.method === 'list_tools') {
+                    return { jsonrpc: '2.0', id: req.id, result: { tools: [{ name: 'hello', inputSchema: {} }] } };
+                }
+                return { jsonrpc: '2.0', id: req.id, result: {} };
+            })
+        });
+
+        concurrencyService = new ConcurrencyService(logger, { maxConcurrent: 10 });
+
+        const executorRegistry = new ExecutorRegistry();
+        executorRegistry.register('deno', new DenoExecutor());
+        executorRegistry.register('python', new PyodideExecutor());
+        // For isolate test, we need IsolateExecutor. 
+        // It requires GatewayService.
+        executorRegistry.register('isolate', new IsolateExecutor(logger, gatewayService));
+
+        const executionService = new ExecutionService(
+            logger,
+            defaultLimits,
+            gatewayService,
+            securityService,
+            executorRegistry
+        );
+
+        requestController = new RequestController(logger, executionService, gatewayService, buildDefaultMiddleware(securityService));
+        transport = new SocketTransport(logger, requestController, concurrencyService);
+
+        ipcAddress = await transport.listen({ port: 0, host: '127.0.0.1' });
+        fs.appendFileSync(LOG_FILE, `IPC_ADDRESS: ${ipcAddress}\n`);
+        executionService.ipcAddress = ipcAddress;
+    });
+
+    afterAll(async () => {
+        await transport.close();
+    });
+
+    it('should allow Deno to discover and call tools via SDK', async () => {
+        const code = `
+            const toolList = await discoverMCPTools();
+            console.log('TOOLS:' + JSON.stringify(toolList));
+            // Use SDK to call tools - tools.mock.hello() or tools.$raw()
+            const result = await tools.$raw('mock__hello', { name: 'Deno' });
+            console.log('RESULT:' + JSON.stringify(result));
+        `;
+
+        const context = new ExecutionContext({ logger });
+        const response = await requestController.handleRequest({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'mcp.executeTypeScript',
+            params: { code },
+            auth: { bearerToken: testToken }
+        }, context);
+
+        fs.appendFileSync(LOG_FILE, `Deno Stdout: ${response.result?.stdout}\n`);
+        fs.appendFileSync(LOG_FILE, `Deno Stderr: ${response.result?.stderr}\n`);
+
+        expect(response.error).toBeUndefined();
+        expect(response.result.stdout).toContain('mock__hello');
+        expect(response.result.stdout).toContain('Hello Deno');
+    }, 15000);
+
+    it('should allow Python to discover and call tools via SDK', async () => {
+        const code = `
+tool_list = await discover_mcp_tools()
+print(f"TOOLS:{tool_list}")
+# Use SDK to call tools - must await async methods
+result = await tools.raw('mock__hello', {'name': 'Python'})
+print(f"RESULT:{result}")
+        `;
+
+        const context = new ExecutionContext({ logger });
+        const response = await requestController.handleRequest({
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'mcp.executePython',
+            params: { code },
+            auth: { bearerToken: testToken }
+        }, context);
+
+        fs.appendFileSync(LOG_FILE, `Python Stdout: ${response.result?.stdout}\n`);
+        fs.appendFileSync(LOG_FILE, `Python Stderr: ${response.result?.stderr}\n`);
+        if (response.error) fs.appendFileSync(LOG_FILE, `Python Error: ${JSON.stringify(response.error)}\n`);
+
+        expect(response.error).toBeUndefined();
+        expect(response.result.stdout).toContain('mock__hello');
+        expect(response.result.stdout).toContain('Hello Python');
+    }, 25000);
+
+    it('should reject tools not in allowlist via $raw()', async () => {
+        const code = `
+            try {
+                // Attempt to call a tool not in the allowlist
+                const result = await tools.$raw('other__forbidden', { arg: 'test' });
+                console.log('ERROR: Should have thrown');
+            } catch (e) {
+                console.log('REJECTED:' + e.message);
+            }
+        `;
+
+        const context = new ExecutionContext({ logger });
+        const response = await requestController.handleRequest({
+            jsonrpc: '2.0',
+            id: 3,
+            method: 'mcp.executeTypeScript',
+            params: {
+                code,
+                allowedTools: ['mock.hello']  // Only mock.hello allowed
+            },
+            auth: { bearerToken: testToken }
+        }, context);
+
+        fs.appendFileSync(LOG_FILE, `Allowlist Stdout: ${response.result?.stdout}\n`);
+        if (response.error) fs.appendFileSync(LOG_FILE, `Allowlist Error: ${JSON.stringify(response.error)}\n`);
+
+        expect(response.error).toBeUndefined();
+        expect(response.result.stdout).toContain('REJECTED');
+        expect(response.result.stdout).toContain('not in the allowlist');
+    }, 15000);
+
+    it('should allow tools matching wildcard pattern', async () => {
+        const code = `
+            // This should work because mock.* matches mock__hello
+            const result = await tools.$raw('mock.hello', { name: 'Wildcard' });
+            console.log('RESULT:' + JSON.stringify(result));
+        `;
+
+        const context = new ExecutionContext({ logger });
+        const response = await requestController.handleRequest({
+            jsonrpc: '2.0',
+            id: 4,
+            method: 'mcp.executeTypeScript',
+            params: {
+                code,
+                allowedTools: ['mock.*']  // Wildcard allows all mock tools
+            },
+            auth: { bearerToken: testToken }
+        }, context);
+
+        fs.appendFileSync(LOG_FILE, `Wildcard Stdout: ${response.result?.stdout}\n`);
+        if (response.error) fs.appendFileSync(LOG_FILE, `Wildcard Error: ${JSON.stringify(response.error)}\n`);
+
+        expect(response.error).toBeUndefined();
+        expect(response.result.stdout).toContain('Hello Wildcard');
+    }, 15000);
+
+    it('should allow isolated-vm to discover and call tools via typed SDK', async () => {
+        const mockClient = (gatewayService as any).clients.get('mock');
+        mockClient.call.mockClear();
+
+        const code = `
+            await tools.mock.hello({ name: 'Isolate' });
+            console.log('Isolate call done');
+        `;
+
+        const context = new ExecutionContext({ logger });
+        const response = await requestController.handleRequest({
+            jsonrpc: '2.0',
+            id: 5,
+            method: 'mcp.executeIsolate',
+            params: {
+                code,
+                allowedTools: ['mock.*'],
+                limits: { timeoutMs: 5000, memoryLimitMb: 128, maxOutputBytes: 1024, maxLogEntries: 100 }
+            },
+            auth: { bearerToken: testToken }
+        }, context);
+
+        fs.appendFileSync(LOG_FILE, `Isolate Stdout: ${response.result?.stdout}\n`);
+        if (response.error) fs.appendFileSync(LOG_FILE, `Isolate Error: ${JSON.stringify(response.error)}\n`);
+
+        expect(response.error).toBeUndefined();
+        expect(response.result.stdout).toContain('Isolate call done');
+
+        // Verify tool was called
+        expect(mockClient.call).toHaveBeenCalled();
+        const callArgs = mockClient.call.mock.calls[0];
+        const request = callArgs[0];
+
+        expect(request).toMatchObject({
+            method: 'call_tool',
+            params: {
+                name: 'hello',
+                arguments: { name: 'Isolate' }
+            }
+        });
+    }, 15000);
+});

package/tests/e2e_stdio_upstream.test.ts

@@ -0,0 +1,197 @@
+/**
+ * End-to-End Test: Client -> Conduit -> Stdio Upstream
+ *
+ * This test verifies the full flow:
+ * 1. Conduit starts with a stdio upstream configured
+ * 2. A client connects to Conduit
+ * 3. Client can discover tools from the upstream
+ * 4. Client can call tools on the upstream
+ */
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { ConfigService } from '../src/core/config.service.js';
+import { createLogger, loggerStorage } from '../src/core/logger.js';
+import { SocketTransport } from '../src/transport/socket.transport.js';
+import { OpsServer } from '../src/core/ops.server.js';
+import { ConcurrencyService } from '../src/core/concurrency.service.js';
+import { RequestController } from '../src/core/request.controller.js';
+import { GatewayService } from '../src/gateway/gateway.service.js';
+import { SecurityService } from '../src/core/security.service.js';
+import { DenoExecutor } from '../src/executors/deno.executor.js';
+import { PyodideExecutor } from '../src/executors/pyodide.executor.js';
+import { IsolateExecutor } from '../src/executors/isolate.executor.js';
+import { ExecutorRegistry } from '../src/core/registries/executor.registry.js';
+import { ExecutionService } from '../src/core/execution.service.js';
+import { buildDefaultMiddleware } from '../src/core/middleware/middleware.builder.js';
+import net from 'net';
+import path from 'path';
+
+describe('E2E: Stdio Upstream Integration', () => {
+    let transport: SocketTransport;
+    let opsServer: OpsServer;
+    let requestController: RequestController;
+    let serverAddress: string;
+    let ipcToken: string;
+
+    beforeAll(async () => {
+        // Configure Conduit with our test stdio server
+        const stioServerPath = path.resolve(__dirname, 'fixtures/stdio-server.ts');
+
+        const configService = new ConfigService({
+            port: 0, // Random port
+            upstreams: [
+                {
+                    id: 'test-stdio',
+                    type: 'stdio',
+                    command: 'npx',
+                    args: ['tsx', stioServerPath],
+                } as any,
+            ],
+        });
+
+        ipcToken = configService.get('ipcBearerToken');
+        const logger = createLogger(configService);
+
+        await loggerStorage.run({ correlationId: 'e2e-test' }, async () => {
+            const securityService = new SecurityService(logger, ipcToken);
+            const gatewayService = new GatewayService(logger, securityService);
+
+            const upstreams = configService.get('upstreams') || [];
+            for (const upstream of upstreams) {
+                gatewayService.registerUpstream(upstream);
+            }
+
+            const executorRegistry = new ExecutorRegistry();
+            executorRegistry.register('deno', new DenoExecutor());
+            executorRegistry.register('python', new PyodideExecutor());
+            const isolateExecutor = new IsolateExecutor(logger, gatewayService);
+            executorRegistry.register('isolate', isolateExecutor);
+
+            const executionService = new ExecutionService(
+                logger,
+                configService.get('resourceLimits'),
+                gatewayService,
+                securityService,
+                executorRegistry
+            );
+
+            requestController = new RequestController(
+                logger,
+                executionService,
+                gatewayService,
+                buildDefaultMiddleware(securityService)
+            );
+
+            opsServer = new OpsServer(logger, configService.all, gatewayService, requestController);
+            await opsServer.listen();
+
+            const concurrencyService = new ConcurrencyService(logger, {
+                maxConcurrent: configService.get('maxConcurrent'),
+            });
+
+            transport = new SocketTransport(logger, requestController, concurrencyService);
+            const address = await transport.listen({ port: 0 });
+            executionService.ipcAddress = address;
+            serverAddress = address;
+
+            await requestController.warmup();
+        });
+    }, 30000);
+
+    afterAll(async () => {
+        await transport?.close();
+        await opsServer?.close();
+        await requestController?.shutdown();
+    });
+
+    function sendRequest(request: object): Promise<any> {
+        return new Promise((resolve, reject) => {
+            // Parse address - could be TCP or Unix socket
+            let connectOptions: net.NetConnectOpts;
+            if (serverAddress.startsWith('/') || serverAddress.startsWith('\\\\.\\pipe\\')) {
+                connectOptions = { path: serverAddress };
+            } else {
+                const [host, portStr] = serverAddress.split(':');
+                connectOptions = { host, port: parseInt(portStr, 10) };
+            }
+
+            const client = net.createConnection(connectOptions, () => {
+                const payload = JSON.stringify(request) + '\n';
+                client.write(payload);
+            });
+
+            let data = '';
+            client.on('data', (chunk) => {
+                data += chunk.toString();
+                // Check for newline delimiter
+                if (data.includes('\n')) {
+                    const lines = data.split('\n').filter(Boolean);
+                    if (lines.length > 0) {
+                        try {
+                            const response = JSON.parse(lines[0]);
+                            client.end();
+                            resolve(response);
+                        } catch (e) {
+                            // Keep waiting for more data
+                        }
+                    }
+                }
+            });
+
+            client.on('error', reject);
+            client.setTimeout(10000, () => {
+                client.destroy();
+                reject(new Error('Timeout waiting for response'));
+            });
+        });
+    }
+
+    it('should discover tools from the stdio upstream', async () => {
+        const response = await sendRequest({
+            jsonrpc: '2.0',
+            id: '1',
+            method: 'mcp.discoverTools',
+            params: {},
+            auth: { bearerToken: ipcToken },
+        });
+
+        expect(response.error).toBeUndefined();
+        expect(response.result).toBeDefined();
+        expect(response.result.tools).toBeInstanceOf(Array);
+
+        // Find our echo tool from the stdio upstream
+        const echoTool = response.result.tools.find((t: any) => t.name.includes('echo'));
+        expect(echoTool).toBeDefined();
+        expect(echoTool.description).toBe('Echoes back the input');
+    }, 15000);
+
+    it('should call a tool on the stdio upstream', async () => {
+        // First discover tools to get the namespaced name
+        const discoverResponse = await sendRequest({
+            jsonrpc: '2.0',
+            id: '1',
+            method: 'mcp.discoverTools',
+            params: {},
+            auth: { bearerToken: ipcToken },
+        });
+
+        const echoTool = discoverResponse.result.tools.find((t: any) => t.name.includes('echo'));
+        expect(echoTool).toBeDefined();
+
+        // Call the tool
+        const callResponse = await sendRequest({
+            jsonrpc: '2.0',
+            id: '2',
+            method: 'mcp.callTool',
+            params: {
+                name: echoTool.name,
+                arguments: { message: 'Hello from E2E test!' },
+            },
+            auth: { bearerToken: ipcToken },
+        });
+
+        expect(callResponse.error).toBeUndefined();
+        expect(callResponse.result).toBeDefined();
+        expect(callResponse.result.content).toBeInstanceOf(Array);
+        expect(callResponse.result.content[0].text).toBe('Echo: Hello from E2E test!');
+    }, 15000);
+});

package/tests/fixtures/stdio-server.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+const server = new Server({
+    name: 'test-stdio-server',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [{
+        name: 'echo',
+        description: 'Echoes back the input',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                message: { type: 'string' },
+            },
+            required: ['message'],
+        },
+    }],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    if (request.params.name === 'echo') {
+        return {
+            content: [{
+                type: 'text',
+                text: `Echo: ${request.params.arguments?.message}`,
+            }],
+        };
+    }
+    throw new Error('Tool not found');
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/tests/gateway.manifest.test.ts

@@ -0,0 +1,82 @@
+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 { createLogger } from '../src/core/logger.js';
+import { ConfigService } from '../src/core/config.service.js';
+import { PolicyService } from '../src/core/policy.service.js';
+
+describe('GatewayService (Manifests)', () => {
+    let gateway: GatewayService;
+    let logger: any;
+    let mockClient: any;
+
+    beforeEach(() => {
+        logger = createLogger(new ConfigService());
+        gateway = new GatewayService(logger, { validateUrl: vi.fn().mockResolvedValue({ valid: true }) } as any, new PolicyService());
+
+        // Mock the clients map directly since it's private but we need to inject a specific client
+        mockClient = {
+            call: vi.fn(),
+            getManifest: vi.fn(),
+        };
+        (gateway as any).clients.set('test-upstream', mockClient);
+    });
+
+    it('should use manifest if available', async () => {
+        const context = new ExecutionContext({ logger });
+
+        mockClient.getManifest.mockResolvedValue({
+            version: '1.0.0',
+            tools: [
+                { name: 'tool1', description: 'desc1' },
+                { name: 'tool2', description: 'desc2' }
+            ]
+        });
+
+        const stubs = await gateway.listToolStubs('test-upstream', context);
+
+        expect(mockClient.getManifest).toHaveBeenCalled();
+        expect(mockClient.call).not.toHaveBeenCalled(); // Should NOT call RPC
+        expect(stubs).toHaveLength(2);
+        expect(stubs[0].id).toBe('test-upstream__tool1');
+    });
+
+    it('should fall back to RPC if manifest is null', async () => {
+        const context = new ExecutionContext({ logger });
+
+        mockClient.getManifest.mockResolvedValue(null);
+        mockClient.call.mockResolvedValue({
+            result: {
+                tools: [
+                    { name: 'tool_rpc', description: 'from rpc' }
+                ]
+            }
+        });
+
+        const stubs = await gateway.listToolStubs('test-upstream', context);
+
+        expect(mockClient.getManifest).toHaveBeenCalled();
+        expect(mockClient.call).toHaveBeenCalledWith(expect.objectContaining({ method: 'list_tools' }), context);
+        expect(stubs).toHaveLength(1);
+        expect(stubs[0].id).toBe('test-upstream__tool_rpc');
+    });
+
+    it('should fall back to RPC if manifest fetch throws', async () => {
+        const context = new ExecutionContext({ logger });
+
+        mockClient.getManifest.mockRejectedValue(new Error('Network error'));
+        mockClient.call.mockResolvedValue({
+            result: {
+                tools: [
+                    { name: 'tool_rpc', description: 'from rpc' }
+                ]
+            }
+        });
+
+        const stubs = await gateway.listToolStubs('test-upstream', context);
+
+        expect(mockClient.getManifest).toHaveBeenCalled();
+        expect(mockClient.call).toHaveBeenCalled();
+        expect(stubs).toHaveLength(1);
+    });
+});