@nimrobo/mcporter-remote 0.1.0

package/tests/server-proxy.test.ts

@@ -0,0 +1,336 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import type { ServerDefinition } from '../src/config';
+import type { CallResult } from '../src/index.js';
+import type { Runtime, ServerToolInfo } from '../src/runtime';
+import { writeSchemaCache } from '../src/schema-cache';
+import { createServerProxy } from '../src/server-proxy';
+
+function createMockRuntime(
+  toolSchemas: Record<string, unknown> = {},
+  listToolsImpl?: () => Promise<ServerToolInfo[]>,
+  definitionOverrides: Partial<ServerDefinition> = {}
+) {
+  const listTools = listToolsImpl
+    ? vi.fn(listToolsImpl)
+    : vi.fn(async () =>
+        Object.entries(toolSchemas).map(([name, schema]) => ({
+          name,
+          description: '',
+          inputSchema: schema,
+        }))
+      );
+  const definition: ServerDefinition = {
+    name: definitionOverrides.name ?? 'mock',
+    description: definitionOverrides.description,
+    command: definitionOverrides.command ?? {
+      kind: 'stdio',
+      command: 'mock',
+      args: [],
+      cwd: process.cwd(),
+    },
+    env: definitionOverrides.env,
+    auth: definitionOverrides.auth,
+    tokenCacheDir: definitionOverrides.tokenCacheDir,
+    clientName: definitionOverrides.clientName,
+  };
+
+  return {
+    callTool: vi.fn(async (_, __, options) => options),
+    listTools,
+    getDefinition: vi.fn(() => definition),
+  };
+}
+
+describe('createServerProxy', () => {
+  it('maps camelCase property names to kebab-case tool names', async () => {
+    const runtime = createMockRuntime({
+      'resolve-library-id': {
+        type: 'object',
+        properties: {
+          libraryName: { type: 'string' },
+        },
+        required: ['libraryName'],
+      },
+    });
+    const context7 = createServerProxy(runtime as unknown as Runtime, 'context7') as Record<string, unknown>;
+
+    const resolver = context7.resolveLibraryId as (args: unknown) => Promise<CallResult>;
+    const result = await resolver({ libraryName: 'react' });
+
+    expect(runtime.callTool).toHaveBeenCalledWith('context7', 'resolve-library-id', { args: { libraryName: 'react' } });
+    expect(result.raw).toEqual({ args: { libraryName: 'react' } });
+  });
+
+  it('merges args and options when both are provided', async () => {
+    const runtime = createMockRuntime({
+      'some-tool': {
+        type: 'object',
+        properties: {
+          foo: { type: 'string' },
+        },
+        required: ['foo'],
+      },
+    });
+    const proxy = createServerProxy(runtime as unknown as Runtime, 'foo') as Record<string, unknown>;
+
+    const fn = proxy.someTool as (args: unknown, options: unknown) => Promise<CallResult>;
+    const result = await fn({ foo: 'bar' }, { tailLog: true });
+
+    expect(runtime.callTool).toHaveBeenCalledWith('foo', 'some-tool', {
+      args: { foo: 'bar' },
+      tailLog: true,
+    });
+    expect(result.raw).toEqual({ args: { foo: 'bar' }, tailLog: true });
+  });
+
+  it('supports passing full call options as the first argument', async () => {
+    const runtime = createMockRuntime();
+    const proxy = createServerProxy(runtime as unknown as Runtime, 'bar') as Record<string, unknown>;
+
+    const fn = proxy.otherTool as (options: unknown) => Promise<CallResult>;
+    const result = await fn({ args: { value: 1 }, tailLog: true });
+
+    expect(runtime.callTool).toHaveBeenCalledWith('bar', 'other-tool', {
+      args: { value: 1 },
+      tailLog: true,
+    });
+    expect(result.raw).toEqual({ args: { value: 1 }, tailLog: true });
+  });
+
+  it('hydrates schemas from disk cache without querying the server', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-schema-cache-'));
+    try {
+      const definition: ServerDefinition = {
+        name: 'cached',
+        description: '',
+        command: {
+          kind: 'stdio',
+          command: 'mock',
+          args: [],
+          cwd: process.cwd(),
+        },
+        tokenCacheDir: tmpDir,
+      };
+      await writeSchemaCache(definition, {
+        updatedAt: new Date().toISOString(),
+        tools: {
+          'some-tool': {
+            type: 'object',
+            properties: { foo: { type: 'string' } },
+            required: ['foo'],
+          },
+        },
+      });
+
+      const runtime = createMockRuntime({}, undefined, definition);
+
+      const proxy = createServerProxy(runtime as unknown as Runtime, 'cached') as Record<string, unknown>;
+
+      const fn = proxy.someTool as (args: unknown) => Promise<CallResult>;
+      const result = await fn({ foo: 'bar' });
+
+      expect(result.raw).toEqual({ args: { foo: 'bar' } });
+      expect(runtime.listTools).toHaveBeenCalled();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('persists schemas to disk after fetching', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-schema-write-'));
+    try {
+      const runtime = createMockRuntime(
+        {
+          'some-tool': {
+            type: 'object',
+            properties: { foo: { type: 'string' } },
+            required: ['foo'],
+          },
+        },
+        undefined,
+        {
+          name: 'persist',
+          tokenCacheDir: tmpDir,
+        }
+      );
+      const proxy = createServerProxy(runtime as unknown as Runtime, 'persist') as Record<string, unknown>;
+
+      const fn = proxy.someTool as (args: unknown) => Promise<CallResult>;
+      await fn({ foo: 'bar' });
+
+      const snapshotPath = path.join(tmpDir, 'schema.json');
+      const snapshotRaw = await fs.readFile(snapshotPath, 'utf8');
+      const snapshot = JSON.parse(snapshotRaw) as {
+        tools: Record<string, unknown>;
+      };
+      expect(Object.keys(snapshot.tools)).toContain('some-tool');
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('uses provided initial schemas without hitting listTools', async () => {
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-schema-initial-'));
+    try {
+      const runtime = createMockRuntime(
+        {},
+        async () => {
+          throw new Error('listTools should not run when initial schemas set');
+        },
+        {
+          name: 'initial',
+          tokenCacheDir: tmpDir,
+        }
+      );
+
+      const initial = {
+        'some-tool': {
+          type: 'object',
+          properties: { foo: { type: 'string' } },
+          required: ['foo'],
+        },
+      };
+
+      const proxy = createServerProxy(runtime as unknown as Runtime, 'initial', { initialSchemas: initial }) as Record<
+        string,
+        unknown
+      >;
+
+      const fn = proxy.someTool as (args: unknown) => Promise<CallResult>;
+      await fn({ foo: 'bar' });
+
+      const snapshotPath = path.join(tmpDir, 'schema.json');
+      const snapshotRaw = await fs.readFile(snapshotPath, 'utf8');
+      const snapshot = JSON.parse(snapshotRaw) as {
+        tools: Record<string, unknown>;
+      };
+      expect(Object.keys(snapshot.tools)).toContain('some-tool');
+      expect(runtime.listTools).not.toHaveBeenCalled();
+    } finally {
+      await fs.rm(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  it('applies schema defaults and validates required arguments', async () => {
+    const runtime = createMockRuntime({
+      someTool: {
+        type: 'object',
+        properties: {
+          foo: { type: 'number', default: 42 },
+          bar: { type: 'string' },
+        },
+        required: ['foo'],
+      },
+      otherTool: {
+        type: 'object',
+        required: ['value'],
+      },
+    });
+
+    const proxy = createServerProxy(runtime as unknown as Runtime, 'test') as Record<string, unknown>;
+
+    const someTool = proxy.someTool as (options?: unknown) => Promise<CallResult>;
+    const result = await someTool({ bar: 'baz' });
+
+    expect(runtime.callTool).toHaveBeenCalledWith('test', 'some-tool', {
+      args: { foo: 42, bar: 'baz' },
+    });
+    expect(result.raw).toEqual({ args: { foo: 42, bar: 'baz' } });
+
+    const otherTool = proxy.otherTool as () => Promise<CallResult>;
+    await expect(otherTool()).rejects.toThrow('Missing required arguments');
+    expect(runtime.callTool).toHaveBeenCalledTimes(1);
+  });
+
+  it('continues when metadata fetch fails', async () => {
+    const runtime = createMockRuntime({}, () => Promise.reject(new Error('metadata failure')));
+
+    const proxy = createServerProxy(runtime as unknown as Runtime, 'foo') as Record<string, unknown>;
+
+    const fn = proxy.someTool as (args: unknown) => Promise<CallResult>;
+    const result = await fn({ foo: 'bar' });
+
+    expect(runtime.callTool).toHaveBeenCalledWith('foo', 'some-tool', {
+      foo: 'bar',
+    });
+    expect(result.raw).toEqual({ foo: 'bar' });
+  });
+
+  it('maps primitive positional arguments onto required schema fields', async () => {
+    const runtime = createMockRuntime({
+      'get-library-docs': {
+        type: 'object',
+        properties: {
+          context7CompatibleLibraryID: { type: 'string' },
+          format: { type: 'string', default: 'markdown' },
+        },
+        required: ['context7CompatibleLibraryID'],
+      },
+    });
+
+    const context7 = createServerProxy(runtime as unknown as Runtime, 'context7') as Record<string, unknown>;
+
+    const fn = context7.getLibraryDocs as (arg: unknown) => Promise<CallResult>;
+    const result = await fn('/ids/react');
+
+    expect(runtime.callTool).toHaveBeenCalledWith('context7', 'get-library-docs', {
+      args: {
+        context7CompatibleLibraryID: '/ids/react',
+        format: 'markdown',
+      },
+    });
+    expect(result.raw).toEqual({
+      args: {
+        context7CompatibleLibraryID: '/ids/react',
+        format: 'markdown',
+      },
+    });
+  });
+
+  it('supports multi-field positional arguments with additional arg bags', async () => {
+    const runtime = createMockRuntime({
+      firecrawl_scrape: {
+        type: 'object',
+        properties: {
+          url: { type: 'string' },
+          formats: { type: ['string', 'array'], default: 'markdown' },
+          waitFor: { type: 'number' },
+          mobile: { type: 'boolean', default: false },
+        },
+        required: ['url'],
+      },
+    });
+
+    const firecrawl = createServerProxy(runtime as unknown as Runtime, 'firecrawl') as Record<string, unknown>;
+
+    const fn = firecrawl.firecrawlScrape as (
+      url: unknown,
+      formats: unknown,
+      args: unknown,
+      options: unknown
+    ) => Promise<CallResult>;
+    const result = await fn('https://example.com/docs', ['markdown', 'html'], { waitFor: 5000 }, { tailLog: true });
+
+    expect(runtime.callTool).toHaveBeenCalledWith('firecrawl', 'firecrawl_scrape', {
+      args: {
+        url: 'https://example.com/docs',
+        formats: ['markdown', 'html'],
+        waitFor: 5000,
+        mobile: false,
+      },
+      tailLog: true,
+    });
+    expect(result.raw).toEqual({
+      args: {
+        url: 'https://example.com/docs',
+        formats: ['markdown', 'html'],
+        waitFor: 5000,
+        mobile: false,
+      },
+      tailLog: true,
+    });
+  });
+});

package/tests/stdio-servers.integration.test.ts

@@ -0,0 +1,139 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+const CLI_ENTRY = fileURLToPath(new URL('../dist/cli.js', import.meta.url));
+const PNPM_COMMAND = process.platform === 'win32' ? 'cmd.exe' : 'pnpm';
+const PNPM_ARGS_PREFIX = process.platform === 'win32' ? ['/d', '/s', '/c', 'pnpm'] : [];
+
+function pnpmArgs(args: string[]): string[] {
+  return [...PNPM_ARGS_PREFIX, ...args];
+}
+
+async function ensureDistBuilt(): Promise<void> {
+  try {
+    await fs.access(CLI_ENTRY);
+  } catch {
+    await new Promise<void>((resolve, reject) => {
+      execFile(PNPM_COMMAND, pnpmArgs(['build']), { cwd: process.cwd(), env: process.env }, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+}
+
+async function runCli(args: string[], configPath: string): Promise<{ stdout: string; stderr: string }> {
+  return await new Promise((resolve, reject) => {
+    execFile(
+      process.execPath,
+      [CLI_ENTRY, '--config', configPath, ...args],
+      {
+        env: { ...process.env, MCPORTER_NO_FORCE_EXIT: '1' },
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          const wrapped = new Error(`${error.message}\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
+          reject(wrapped);
+          return;
+        }
+        resolve({ stdout, stderr });
+      }
+    );
+  });
+}
+
+describe('stdio MCP servers (filesystem + memory)', () => {
+  let tempDir: string;
+  let configPath: string;
+  let fsRoot: string;
+
+  const filesystemServerScript = fileURLToPath(new URL('./fixtures/stdio-filesystem-server.mjs', import.meta.url));
+  const memoryServerScript = fileURLToPath(new URL('./fixtures/stdio-memory-server.mjs', import.meta.url));
+
+  beforeAll(async () => {
+    await ensureDistBuilt();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-stdio-e2e-'));
+    fsRoot = path.join(tempDir, 'fs-root');
+    await fs.mkdir(fsRoot, { recursive: true });
+    await fs.writeFile(path.join(fsRoot, 'hello.txt'), 'hello from stdio mcp\n', 'utf8');
+    configPath = path.join(tempDir, 'stdio.config.json');
+    await fs.writeFile(
+      configPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            'fs-test': {
+              description: 'Filesystem MCP for stdio e2e tests',
+              command: process.execPath,
+              args: [filesystemServerScript, fsRoot],
+            },
+            'memory-test': {
+              description: 'Knowledge graph MCP for stdio e2e tests',
+              command: process.execPath,
+              args: [memoryServerScript],
+            },
+          },
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+  });
+
+  afterAll(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('lists filesystem tools and reads files via stdio MCP', async () => {
+    const listResult = await runCli(['list', 'fs-test'], configPath);
+    expect(listResult.stdout).toContain('Filesystem MCP for stdio e2e tests');
+    const callResult = await runCli(
+      [
+        'call',
+        'fs-test.read_text_file',
+        '--output',
+        'json',
+        '--args',
+        JSON.stringify({ path: path.join(fsRoot, 'hello.txt') }),
+      ],
+      configPath
+    );
+    expect(callResult.stdout).toContain('hello from stdio mcp');
+  }, 20000);
+
+  const memoryTest = process.platform === 'win32' ? it.skip : it;
+
+  memoryTest(
+    'creates entities with the memory stdio MCP server',
+    async () => {
+      const callResult = await runCli(
+        [
+          'call',
+          'memory-test.create_entities',
+          '--output',
+          'json',
+          '--args',
+          JSON.stringify({ entities: ['alpha', 'beta'] }),
+        ],
+        configPath
+      );
+      const stderrWithoutWarnings = callResult.stderr
+        .split('\n')
+        .filter((line) => !line.startsWith('(node:') && !line.startsWith('(Use `node'))
+        .join('\n')
+        .trim();
+      expect(stderrWithoutWarnings).toBe('');
+      expect(callResult.stdout).not.toContain('Error');
+    },
+    20000
+  );
+});

package/tests/tool-cache.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from 'vitest';
+import { loadToolMetadata } from '../src/cli/tool-cache.js';
+import type { Runtime } from '../src/runtime.js';
+import { demoTool } from './fixtures/tool-fixtures.js';
+
+function createRuntimeStub(listToolsImpl: Runtime['listTools']): Runtime {
+  return {
+    listServers: () => [],
+    getDefinitions: () => [],
+    getDefinition: () => {
+      throw new Error('not implemented');
+    },
+    registerDefinition: () => {},
+    listTools: listToolsImpl,
+    callTool: async () => ({}),
+    listResources: async () => ({}),
+    connect: async () => {
+      throw new Error('not implemented');
+    },
+    close: async () => {},
+  } as unknown as Runtime;
+}
+
+describe('loadToolMetadata', () => {
+  it('caches repeated calls per runtime/server/options', async () => {
+    const listTools = vi.fn(async () => [demoTool]);
+    const runtime = createRuntimeStub(listTools);
+    const first = await loadToolMetadata(runtime, 'integration', { includeSchema: true });
+    const second = await loadToolMetadata(runtime, 'integration', { includeSchema: true });
+    expect(listTools).toHaveBeenCalledTimes(1);
+    expect(first[0]?.tool.name).toBe('demo_tool');
+    expect(second).toBe(first);
+  });
+
+  it('differentiates cache entries by includeSchema flag', async () => {
+    const listTools = vi.fn(async () => [demoTool]);
+    const runtime = createRuntimeStub(listTools);
+    await loadToolMetadata(runtime, 'integration', { includeSchema: true });
+    await loadToolMetadata(runtime, 'integration', { includeSchema: false });
+    expect(listTools).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/version-consistency.test.ts

@@ -0,0 +1,11 @@
+import { createRequire } from 'node:module';
+import { describe, expect, it } from 'vitest';
+import { MCPORTER_VERSION } from '../src/runtime.js';
+
+const pkg = createRequire(import.meta.url)('../package.json');
+
+describe('version consistency', () => {
+  it('matches package.json', () => {
+    expect(MCPORTER_VERSION).toBe(pkg.version);
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noEmit": false
+  },
+  "exclude": ["tests", "docs", "scripts", "dist", "node_modules"]
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM"],
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": false,
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["node", "bun-types"]
+  },
+  "include": ["src", "tests", "scripts", "docs"]
+}

package/vitest.config.ts

@@ -0,0 +1,18 @@
+import { defineConfig } from 'vitest/config';
+
+const quietReporterEnabled = process.env.MCPORTER_TEST_REPORTER === 'quiet';
+
+const quietReporterOptions = quietReporterEnabled
+  ? {
+      reporters: ['dot'],
+      silent: 'passed-only' as const,
+    }
+  : {};
+
+export default defineConfig({
+  test: {
+    // Quiet mode hides console output for passing tests so CLI fixture logs
+    // (e.g., the full `mcporter list` banners) don't overwhelm the reporter.
+    ...quietReporterOptions,
+  },
+});