@nimrobo/mcporter-remote 0.1.0

package/tests/index-api.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, it } from 'vitest';
+import type { CallResult } from '../src/index.js';
+import { createServerProxy } from '../src/index.js';
+import type { Runtime, ServerToolInfo } from '../src/runtime.js';
+
+type CallLogEntry = {
+  server: string;
+  tool: string;
+  options: unknown;
+};
+
+function createComposableRuntime() {
+  const listCalls: Array<{ server: string; options?: unknown }> = [];
+  const callLog: CallLogEntry[] = [];
+
+  const schemas: Record<string, ServerToolInfo[]> = {
+    docs: [
+      {
+        name: 'lookup',
+        description: 'Lookup documentation entries',
+        inputSchema: {
+          type: 'object',
+          properties: { query: { type: 'string' } },
+          required: ['query'],
+        },
+      },
+    ],
+    summarize: [
+      {
+        name: 'summarize',
+        description: 'Summarize content',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            text: { type: 'string' },
+            style: { type: 'string', default: 'concise' },
+          },
+          required: ['text'],
+        },
+      },
+    ],
+  };
+
+  const runtime: Pick<Runtime, 'listTools' | 'callTool' | 'getDefinition'> & {
+    listCalls: typeof listCalls;
+    callLog: typeof callLog;
+  } = {
+    listCalls,
+    callLog,
+    async listTools(server, options) {
+      listCalls.push({ server, options });
+      return schemas[server] ?? [];
+    },
+    async callTool(server, toolName, options) {
+      callLog.push({ server, tool: toolName, options });
+
+      if (server === 'docs' && toolName === 'lookup') {
+        const query =
+          typeof options?.args === 'object' && options?.args !== null
+            ? (options.args as { query?: string }).query
+            : undefined;
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Reference entry for ${query ?? 'unknown topic'}`,
+            },
+          ],
+        };
+      }
+
+      if (server === 'summarize' && toolName === 'summarize') {
+        const args = (options?.args ?? {}) as { text?: string; style?: string };
+        return {
+          structuredContent: {
+            summary: `Summary: ${(args.text ?? '').slice(0, 24)}`,
+            style: args.style ?? 'concise',
+          },
+        };
+      }
+
+      throw new Error(`Unexpected call: ${server}.${toolName}`);
+    },
+    getDefinition(server) {
+      return {
+        name: server,
+        description: '',
+        command: {
+          kind: 'stdio' as const,
+          command: 'noop',
+          args: [],
+          cwd: process.cwd(),
+        },
+      };
+    },
+  };
+
+  return runtime;
+}
+
+describe('index exports integration', () => {
+  it('composes proxies across MCP servers using the TypeScript API', async () => {
+    const runtime = createComposableRuntime();
+    const docs = createServerProxy(runtime as unknown as Runtime, 'docs') as Record<string, unknown>;
+    const summarize = createServerProxy(runtime as unknown as Runtime, 'summarize') as Record<string, unknown>;
+
+    const lookup = docs.lookup as (query: string) => Promise<CallResult>;
+    const summarizeTool = summarize.summarize as (text: string) => Promise<CallResult>;
+
+    const lookupResult = await lookup('TypeScript decorators');
+    expect(lookupResult.text()).toBe('Reference entry for TypeScript decorators');
+
+    const summaryResult = await summarizeTool(lookupResult.text() ?? '');
+    const structured = summaryResult.structuredContent() as { summary?: string; style?: string };
+    expect(structured?.style).toBe('concise');
+    expect(structured?.summary).toMatch(/^Summary: Reference entry/);
+
+    expect(runtime.listCalls).toEqual([
+      { server: 'docs', options: { includeSchema: true } },
+      { server: 'summarize', options: { includeSchema: true } },
+    ]);
+
+    expect(runtime.callLog).toEqual([
+      {
+        server: 'docs',
+        tool: 'lookup',
+        options: { args: { query: 'TypeScript decorators' } },
+      },
+      {
+        server: 'summarize',
+        tool: 'summarize',
+        options: { args: { text: 'Reference entry for TypeScript decorators', style: 'concise' } },
+      },
+    ]);
+  });
+});

package/tests/keep-alive-runtime.test.ts

@@ -0,0 +1,152 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { describe, expect, it, vi } from 'vitest';
+import type { ServerDefinition } from '../src/config.js';
+import { createKeepAliveRuntime } from '../src/daemon/runtime-wrapper.js';
+import type { CallOptions, ListToolsOptions, Runtime } from '../src/runtime.js';
+
+class FakeRuntime implements Runtime {
+  private readonly definitions: ServerDefinition[];
+  public readonly callToolMock = vi.fn().mockResolvedValue('local-call');
+  public readonly listToolsMock = vi.fn().mockResolvedValue([{ name: 'local-tool' }]);
+  public readonly listResourcesMock = vi.fn().mockResolvedValue([]);
+  public readonly closeMock = vi.fn().mockResolvedValue(undefined);
+
+  constructor(definitions: ServerDefinition[]) {
+    this.definitions = definitions;
+  }
+
+  listServers(): string[] {
+    return this.definitions.map((definition) => definition.name);
+  }
+
+  getDefinitions(): ServerDefinition[] {
+    return this.definitions;
+  }
+
+  getDefinition(server: string): ServerDefinition {
+    const definition = this.definitions.find((entry) => entry.name === server);
+    if (!definition) {
+      throw new Error(`Unknown server ${server}`);
+    }
+    return definition;
+  }
+
+  registerDefinition(): void {
+    // no-op for tests
+  }
+
+  async listTools(server: string, options?: ListToolsOptions): Promise<Awaited<ReturnType<Runtime['listTools']>>> {
+    return await this.listToolsMock(server, options);
+  }
+
+  async callTool(server: string, toolName: string, options?: CallOptions): Promise<unknown> {
+    return await this.callToolMock(server, toolName, options);
+  }
+
+  async listResources(server: string, options?: unknown): Promise<unknown> {
+    return await this.listResourcesMock(server, options);
+  }
+
+  async connect(): Promise<never> {
+    throw new Error('not implemented');
+  }
+
+  async close(server?: string): Promise<void> {
+    await this.closeMock(server);
+  }
+}
+
+describe('createKeepAliveRuntime', () => {
+  const definitions: ServerDefinition[] = [
+    {
+      name: 'alpha',
+      description: 'keep alive server',
+      command: { kind: 'http', url: new URL('https://alpha.example.com') },
+      lifecycle: { mode: 'keep-alive' },
+      source: { kind: 'local', path: '/tmp' },
+    },
+    {
+      name: 'beta',
+      description: 'ephemeral server',
+      command: { kind: 'http', url: new URL('https://beta.example.com') },
+      source: { kind: 'local', path: '/tmp' },
+    },
+  ];
+
+  it('routes keep-alive servers through the daemon client', async () => {
+    const runtime = new FakeRuntime(definitions);
+    const daemon = {
+      callTool: vi.fn().mockResolvedValue('daemon-call'),
+      listTools: vi.fn().mockResolvedValue([{ name: 'remote-tool' }]),
+      listResources: vi.fn().mockResolvedValue(['resource']),
+      closeServer: vi.fn().mockResolvedValue(undefined),
+    };
+    const keepAliveRuntime = createKeepAliveRuntime(runtime as unknown as Runtime, {
+      daemonClient: daemon as never,
+      keepAliveServers: new Set(['alpha']),
+    });
+
+    await keepAliveRuntime.callTool('alpha', 'ping', { args: { value: 1 }, timeoutMs: 4_200 });
+    expect(daemon.callTool).toHaveBeenCalledWith({
+      server: 'alpha',
+      tool: 'ping',
+      args: { value: 1 },
+      timeoutMs: 4_200,
+    });
+
+    await keepAliveRuntime.listTools('alpha', { includeSchema: true });
+    expect(daemon.listTools).toHaveBeenCalledWith({ server: 'alpha', includeSchema: true, autoAuthorize: undefined });
+
+    await keepAliveRuntime.listResources('alpha', { cursor: '1' });
+    expect(daemon.listResources).toHaveBeenCalledWith({ server: 'alpha', params: { cursor: '1' } });
+
+    await keepAliveRuntime.close('alpha');
+    expect(daemon.closeServer).toHaveBeenCalledWith({ server: 'alpha' });
+
+    await keepAliveRuntime.callTool('beta', 'pong', {});
+    expect(runtime.callToolMock).toHaveBeenCalledWith('beta', 'pong', {});
+
+    await keepAliveRuntime.close();
+    expect(runtime.closeMock).toHaveBeenCalledWith(undefined);
+  });
+
+  it('restarts daemon servers after fatal errors and retries the operation', async () => {
+    const runtime = new FakeRuntime(definitions);
+    const daemon = {
+      callTool: vi.fn().mockRejectedValueOnce(new Error('transport hung up')).mockResolvedValueOnce('daemon-call'),
+      closeServer: vi.fn().mockResolvedValue(undefined),
+      listTools: vi.fn(),
+      listResources: vi.fn(),
+    };
+    const keepAliveRuntime = createKeepAliveRuntime(runtime as unknown as Runtime, {
+      daemonClient: daemon as never,
+      keepAliveServers: new Set(['alpha']),
+    });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await expect(keepAliveRuntime.callTool('alpha', 'ping', {})).resolves.toBe('daemon-call');
+    expect(daemon.callTool).toHaveBeenCalledTimes(2);
+    expect(daemon.closeServer).toHaveBeenCalledWith({ server: 'alpha' });
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("Restarting 'alpha'"));
+    logSpy.mockRestore();
+  });
+
+  it('does not restart daemon servers for InvalidParams errors', async () => {
+    const runtime = new FakeRuntime(definitions);
+    const error = new McpError(ErrorCode.InvalidParams, 'Tool not found');
+    const daemon = {
+      callTool: vi.fn().mockRejectedValue(error),
+      closeServer: vi.fn().mockResolvedValue(undefined),
+      listTools: vi.fn(),
+      listResources: vi.fn(),
+    };
+    const keepAliveRuntime = createKeepAliveRuntime(runtime as unknown as Runtime, {
+      daemonClient: daemon as never,
+      keepAliveServers: new Set(['alpha']),
+    });
+
+    await expect(keepAliveRuntime.callTool('alpha', 'ping', {})).rejects.toThrow('Tool not found');
+    expect(daemon.callTool).toHaveBeenCalledTimes(1);
+    expect(daemon.closeServer).not.toHaveBeenCalled();
+  });
+});

package/tests/lifecycle.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import type { CommandSpec } from '../src/config-schema.js';
+import { resolveLifecycle } from '../src/lifecycle.js';
+
+const CHROME_COMMAND: CommandSpec = {
+  kind: 'stdio',
+  command: 'npx',
+  args: ['-y', 'chrome-devtools-mcp@latest', '--browserUrl', String.raw`\${CHROME_DEVTOOLS_URL}`],
+  cwd: process.cwd(),
+};
+
+const CHROME_COMMAND_ENV: CommandSpec = {
+  kind: 'stdio',
+  command: 'npx',
+  args: ['-y', 'chrome-devtools-mcp@latest', '--browserUrl', '$env:CHROME_DEVTOOLS_URL'],
+  cwd: process.cwd(),
+};
+
+describe('resolveLifecycle', () => {
+  it('forces chrome-devtools placeholder runs to be ephemeral', () => {
+    const lifecycle = resolveLifecycle('chrome-devtools', undefined, CHROME_COMMAND);
+    expect(lifecycle?.mode).toBe('ephemeral');
+  });
+
+  it('forces chrome-devtools $env placeholder runs to be ephemeral', () => {
+    const lifecycle = resolveLifecycle('chrome-devtools', undefined, CHROME_COMMAND_ENV);
+    expect(lifecycle?.mode).toBe('ephemeral');
+  });
+});

package/tests/list-detail-helpers.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, it } from 'vitest';
+import type { GeneratedOption } from '../src/cli/generate/tools.js';
+import { buildToolDoc, selectDisplayOptions } from '../src/cli/list-detail-helpers.js';
+import { buildDocComment, wrapCommentText } from '../src/cli/list-doc-comments.js';
+import {
+  formatCallExpressionExample,
+  formatExampleBlock,
+  formatFlagUsage,
+  formatFunctionSignature,
+  formatOptionalSummary,
+} from '../src/cli/list-signature.js';
+
+const baseOption = (overrides: Partial<GeneratedOption> = {}): GeneratedOption => ({
+  property: 'field',
+  cliName: 'field',
+  description: 'desc',
+  required: true,
+  type: 'string',
+  placeholder: '<field>',
+  ...overrides,
+});
+
+describe('wrapCommentText', () => {
+  it('wraps long sentences across multiple lines', () => {
+    const text = 'This is a very long sentence designed to exceed the width limit and therefore wrap neatly.';
+    const lines = wrapCommentText(text, 40);
+    expect(lines.length).toBeGreaterThan(1);
+    expect(lines.join(' ')).toBe(text.trim());
+    expect(lines.every((line) => line.length <= 40)).toBe(true);
+  });
+});
+
+describe('selectDisplayOptions', () => {
+  it('always shows at least five parameters even when optional', () => {
+    const options = Array.from({ length: 6 }, (_, index) => baseOption({ property: `opt${index}`, required: false }));
+    const { displayOptions, hiddenOptions } = selectDisplayOptions(options, true, 5);
+    expect(displayOptions).toHaveLength(5);
+    expect(hiddenOptions).toHaveLength(1);
+  });
+});
+
+describe('buildDocComment', () => {
+  it('inserts a blank line between description and parameter docs and wraps content', () => {
+    const options = [
+      baseOption({
+        property: 'teamId',
+        description:
+          'The team ID to get the deployment events for. Alternatively the team slug can be used. Team IDs start with "team_". If you do not know the team ID or slug, it can be found through these mechanism: Read the file .vercel/project.json, Use the list_teams tool',
+      }),
+    ];
+    const lines = buildDocComment('List Vercel projects with lots of details.', options);
+    expect(lines).toBeDefined();
+    const printable = (lines ?? []).map(stripAnsi);
+    const separatorIndex = printable.findIndex((line) => line.trim() === '*');
+    expect(separatorIndex).toBeGreaterThan(0);
+    const paramLine = printable.find((line) => line.includes('@param teamId'));
+    expect(paramLine).toBeDefined();
+    const continuationLine = printable.find((line) => line.includes('Team IDs start with'));
+    expect(continuationLine).toBeDefined();
+  });
+});
+
+describe('formatOptionalSummary', () => {
+  it('shows at most five names and appends ellipsis for the rest', () => {
+    const hidden = Array.from({ length: 7 }, (_, index) => baseOption({ property: `param${index}` }));
+    const summary = stripAnsi(formatOptionalSummary(hidden));
+    expect(summary).toContain('optional (7)');
+    expect(summary).toContain('param0');
+    expect(summary.trim().endsWith('...')).toBe(true);
+  });
+});
+
+describe('formatFlagUsage', () => {
+  it('renders required, optional, and extra flags consistently', () => {
+    const options = [
+      baseOption({ property: 'title', cliName: 'title', required: true, placeholder: '<title>' }),
+      baseOption({ property: 'body', cliName: 'body', required: false, placeholder: '<body>' }),
+    ];
+    const usage = formatFlagUsage(options, [{ text: '--raw <json>' }], { colorize: false });
+    expect(usage).toBe('--title <title> [--body <body>] [--raw <json>]');
+  });
+});
+
+describe('formatFunctionSignature', () => {
+  it('renders uncolored TypeScript-style signatures when colorize is false', () => {
+    const signature = formatFunctionSignature(
+      'create_comment',
+      [
+        baseOption({ property: 'issueId', description: 'Issue identifier', required: true }),
+        baseOption({ property: 'parentId', required: false, description: 'Optional parent' }),
+      ],
+      { title: 'Comment' },
+      { colorize: false }
+    );
+    expect(signature).toBe('function create_comment(issueId: string, parentId?: string): Comment;');
+  });
+
+  it('falls back to unknown return types when schema is empty', () => {
+    const signature = stripAnsi(formatFunctionSignature('list_docs', [], undefined));
+    expect(signature).toBe('function list_docs();');
+  });
+});
+
+describe('formatCallExpressionExample', () => {
+  it('uses example literals when provided and falls back for ids', () => {
+    const example = formatCallExpressionExample('linear', 'create_issue', [
+      baseOption({ property: 'title', required: true, exampleValue: 'Bug' }),
+      baseOption({ property: 'teamId', required: true }),
+      baseOption({ property: 'parentId', required: false }),
+    ]);
+    expect(example).toBe('mcporter call linear.create_issue(title: "Bug", teamId: "example-id")');
+  });
+
+  it('wraps expressions when requested', () => {
+    const example = formatCallExpressionExample(
+      'adhoc-sentry',
+      'use_sentry',
+      [baseOption({ property: 'request', required: true })],
+      { callSelector: 'https://mcp.sentry.dev/mcp?agent=1', wrapExpression: true }
+    );
+    expect(example).toBe('mcporter call \'https://mcp.sentry.dev/mcp?agent=1.use_sentry(request: "value")\'');
+  });
+});
+
+describe('formatExampleBlock', () => {
+  it('dedupes and truncates long call hints', () => {
+    const lines = formatExampleBlock(
+      [
+        'mcporter call linear.create_issue(title: "Bug", teamId: "ENG", description: "Long description goes here")',
+        'mcporter call linear.create_issue(title: "Bug", teamId: "ENG", description: "Long description goes here")',
+        'mcporter call linear.create_issue(title: "Bug", teamId: "ENG")',
+      ],
+      { maxExamples: 2, maxLength: 60 }
+    );
+    expect(lines).toHaveLength(2);
+    expect(lines[0]).toContain('...');
+    expect(lines[1]).toContain('create_issue(');
+  });
+});
+
+describe('buildToolDoc', () => {
+  it('produces reusable doc blocks and summaries', () => {
+    const options = [
+      baseOption({
+        property: 'issueId',
+        cliName: 'issue-id',
+        placeholder: '<issue-id>',
+        description: 'Issue identifier',
+        required: true,
+      }),
+      baseOption({
+        property: 'body',
+        cliName: 'body',
+        placeholder: '<body>',
+        description: 'Markdown body',
+        required: true,
+      }),
+      baseOption({
+        property: 'parentId',
+        cliName: 'parent-id',
+        placeholder: '<parent-id>',
+        description: 'Optional parent',
+        required: false,
+      }),
+    ];
+    const doc = buildToolDoc({
+      serverName: 'linear',
+      toolName: 'create_comment',
+      description: 'Create a comment',
+      outputSchema: { title: 'Comment' },
+      options,
+      requiredOnly: true,
+      colorize: false,
+    });
+    expect(doc.signature).toBe('function create_comment(issueId: string, body: string, parentId?: string): Comment;');
+    expect(doc.tsSignature).toBe('function create_comment(issueId: string, body: string, parentId?: string): Comment;');
+    expect(stripAnsi(doc.flagUsage)).toBe('--issue-id <issue-id> --body <body> [--parent-id <parent-id>]');
+    expect(doc.optionalSummary).toBeUndefined();
+    expect(doc.examples[0]).toContain('mcporter call linear.create_comment');
+    expect(doc.optionDocs.map((entry) => entry.flagLabel)).toEqual([
+      '--issue-id <issue-id>',
+      '--body <body>',
+      '--parent-id <parent-id>',
+    ]);
+    expect(doc.optionDocs[0]?.description).toContain('Issue identifier');
+    expect(doc.hiddenOptions).toHaveLength(0);
+  });
+});
+
+function stripAnsi(value: string): string {
+  let result = '';
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === '\u001B') {
+      index += 1;
+      while (index < value.length && value[index] !== 'm') {
+        index += 1;
+      }
+      continue;
+    }
+    result += char;
+  }
+  return result;
+}

package/tests/list-format.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { formatSourceSuffix } from '../src/cli/list-format.js';
+import { stripAnsi } from './fixtures/ansi.js';
+
+describe('list format helpers', () => {
+  it('shows only primary import path by default', () => {
+    const suffix = formatSourceSuffix({ kind: 'import', path: '/home/user/.cursor/mcp.json' });
+    expect(stripAnsi(suffix)).toContain('[source: /home/user/.cursor/mcp.json]');
+  });
+
+  it('shows all sources when verbose is enabled and preserves order', () => {
+    const suffix = formatSourceSuffix(
+      [
+        { kind: 'import', path: '/project/config/mcporter.json', importKind: 'vscode' },
+        { kind: 'import', path: '/home/user/.cursor/mcp.json', importKind: 'cursor' },
+      ],
+      false,
+      { verbose: true }
+    );
+    const plain = stripAnsi(suffix);
+    expect(plain).toContain(
+      '[sources: /project/config/mcporter.json (primary, vscode) · /home/user/.cursor/mcp.json (shadowed, cursor)]'
+    );
+  });
+
+  it('tags imports shadowed by a local primary', () => {
+    const suffix = formatSourceSuffix(
+      [
+        { kind: 'local', path: '/project/config/mcporter.json' },
+        { kind: 'import', path: '/home/user/.cursor/mcp.json', importKind: 'cursor' },
+      ],
+      false,
+      { verbose: true }
+    );
+    const plain = stripAnsi(suffix);
+    expect(plain).toContain(
+      '[sources: /project/config/mcporter.json (primary) · /home/user/.cursor/mcp.json (shadowed by local, cursor)]'
+    );
+  });
+});

package/tests/list-inline-stdio.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleList } from '../src/cli/list-command.js';
+import type { ServerDefinition } from '../src/config.js';
+import type { Runtime, ServerToolInfo } from '../src/runtime.js';
+
+function createRuntimeStub() {
+  const definitions: ServerDefinition[] = [];
+  const listTools = vi.fn(
+    async (_server: string, _options?: unknown): Promise<ServerToolInfo[]> => [
+      {
+        name: 'doctor',
+        description: 'Runs diagnostics',
+        inputSchema: { type: 'object', properties: {}, required: [] },
+        outputSchema: undefined,
+      },
+    ]
+  );
+
+  const getDefinition = (name: string): ServerDefinition => {
+    const found = definitions.find((entry) => entry.name === name);
+    if (!found) {
+      throw new Error(`Unknown MCP server '${name}'.`);
+    }
+    return found;
+  };
+
+  const runtime: Runtime = {
+    listServers: () => definitions.map((entry) => entry.name).sort(),
+    getDefinitions: () => definitions,
+    getDefinition,
+    registerDefinition: (definition: ServerDefinition, _options?: { overwrite?: boolean }): void => {
+      const index = definitions.findIndex((entry) => entry.name === definition.name);
+      if (index === -1) {
+        definitions.push(definition);
+      } else {
+        definitions[index] = definition;
+      }
+    },
+    listTools,
+    callTool: vi.fn(async () => undefined),
+    listResources: vi.fn(async () => undefined),
+    connect: vi.fn(async () => {
+      throw new Error('connect not implemented');
+    }),
+    close: vi.fn(async () => undefined),
+  };
+
+  return { runtime, listTools };
+}
+
+describe('handleList inline STDIO detection', () => {
+  it('treats quoted npx commands as ad-hoc STDIO servers', async () => {
+    const { runtime, listTools } = createRuntimeStub();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    let logCalls: unknown[][] = [];
+    try {
+      await handleList(runtime, ['--json', 'npx -y xcodebuildmcp']);
+      logCalls = [...logSpy.mock.calls];
+    } finally {
+      logSpy.mockRestore();
+    }
+    expect(listTools).toHaveBeenCalledWith('xcodebuildmcp', expect.objectContaining({ includeSchema: true }));
+    expect(runtime.getDefinitions()).toHaveLength(1);
+    expect(logCalls.length).toBeGreaterThan(0);
+    const lastCall = logCalls.at(-1)?.[0];
+    expect(lastCall).toBeDefined();
+    const payload = JSON.parse(String(lastCall));
+    expect(payload.name).toBe('xcodebuildmcp');
+    expect(payload.transport).toContain('STDIO npx -y xcodebuildmcp');
+  });
+});