@nimrobo/mcporter-remote 0.1.0

package/tests/cli-generate-runner.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it } from 'vitest';
+import { parseGenerateFlags } from '../src/cli/generate/flags.js';
+import { inferNameFromCommand } from '../src/cli/generate/name-utils.js';
+import { buildGenerateCliCommand } from '../src/cli/generate/template-data.js';
+import type { SerializedServerDefinition } from '../src/cli-metadata.js';
+
+describe('generate-cli runner internals', () => {
+  it('parses generate-cli flags including bundle/compile toggles', () => {
+    const args = [
+      '--server',
+      'linear',
+      '--command',
+      'https://example.com/mcp.getComponents()',
+      '--bundle',
+      '--compile',
+      '--minify',
+    ];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.server).toBe('linear');
+    expect(parsed.command).toBe('https://example.com/mcp');
+    expect(parsed.bundle).toBe(true);
+    expect(parsed.compile).toBe(true);
+    expect(parsed.minify).toBe(true);
+  });
+
+  it('normalizes inferred names from URLs', () => {
+    const args = ['--command', 'https://api.linear.app/mcp.getComponents'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.command).toContain('https://');
+    const inferred = inferNameFromCommand(parsed.command ?? '');
+    expect(inferred).toBe('linear');
+  });
+
+  it('splits stdio commands and infers names from args', () => {
+    const args = ['--command', 'npx -y chrome-devtools-mcp@latest'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.command).toBeDefined();
+    expect(typeof parsed.command).toBe('object');
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec.command).toBe('npx');
+    expect(spec.args).toEqual(['-y', 'chrome-devtools-mcp@latest']);
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toContain('chrome-devtools');
+  });
+
+  it('parses local script commands with extra args', () => {
+    const args = ['--command', 'bun run ./servers/local-cli.ts --stdio --name local'];
+    const parsed = parseGenerateFlags([...args]);
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec.command).toBe('bun');
+    expect(spec.args).toEqual(['run', './servers/local-cli.ts', '--stdio', '--name', 'local']);
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toBe('local-cli');
+  });
+
+  it('infers package names from scoped arguments', () => {
+    const args = ['--command', 'npx -y @demo/tools@latest serve'];
+    const parsed = parseGenerateFlags([...args]);
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec.args).toEqual(['-y', '@demo/tools@latest', 'serve']);
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toBe('demo-tools');
+  });
+
+  it('infers npm package names without version specifiers in inline commands', () => {
+    const args = ['--command', 'npx -y chrome-devtools-mcp'];
+    const parsed = parseGenerateFlags([...args]);
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec.args).toEqual(['-y', 'chrome-devtools-mcp']);
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toBe('chrome-devtools-mcp');
+  });
+
+  it('normalizes scheme-less HTTP selectors passed to --command', () => {
+    const args = ['--command', 'shadcn.io/api/mcp.getComponents'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(typeof parsed.command).toBe('string');
+    expect((parsed.command as string).startsWith('https://')).toBe(true);
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toBe('shadcn');
+  });
+
+  it('wraps single-token stdio commands when passed via --command', () => {
+    const args = ['--command', './scripts/mcp-server.ts'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.command).toBeDefined();
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec).toEqual({ command: './scripts/mcp-server.ts' });
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toBe('mcp-server');
+  });
+
+  it('treats positional inline commands as generate-cli targets', () => {
+    const args = ['npx -y chrome-devtools-mcp@latest'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.command).toBeDefined();
+    expect(parsed.server).toBeUndefined();
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec.command).toBe('npx');
+    expect(spec.args).toEqual(['-y', 'chrome-devtools-mcp@latest']);
+  });
+
+  it('keeps bare names positional when no whitespace is present', () => {
+    const args = ['linear'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.server).toBe('linear');
+    expect(parsed.command).toBeUndefined();
+  });
+
+  it('handles inline commands with extra interior whitespace', () => {
+    const args = ['  bun   run   ./cli.ts   --stdio  '];
+    const parsed = parseGenerateFlags([...args]);
+    const spec = parsed.command as { command: string; args?: string[] };
+    expect(spec.command).toBe('bun');
+    expect(spec.args).toEqual(['run', './cli.ts', '--stdio']);
+  });
+
+  it('treats positional HTTPS URLs as ad-hoc servers and infers names', () => {
+    const args = ['https://mcp.context7.com/mcp'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.command).toBe('https://mcp.context7.com/mcp');
+    expect(parsed.server).toBeUndefined();
+    const inferred = parsed.command !== undefined ? inferNameFromCommand(parsed.command) : undefined;
+    expect(inferred).toBe('context7');
+  });
+
+  it('builds regenerate commands honoring global flags and invocation overrides', () => {
+    const definition: SerializedServerDefinition = {
+      name: 'demo',
+      description: 'Demo server',
+      command: { kind: 'http', url: 'https://demo.mcp' },
+    };
+    const invocation = {
+      outputPath: 'out.ts',
+      runtime: 'bun' as const,
+      timeoutMs: 45_000,
+      minify: true,
+      bundle: 'out.bundle.js',
+      includeTools: ['alpha', 'beta'],
+    };
+    const command = buildGenerateCliCommand(invocation, definition, { '--config': '/tmp/mcporter.json' });
+    expect(command).toContain('--config /tmp/mcporter.json');
+    expect(command).toContain('--server demo');
+    expect(command).toContain('--bundle out.bundle.js');
+    expect(command).toContain('--timeout 45000');
+    expect(command).toContain('--minify');
+    expect(command).toContain("--include-tools 'alpha,beta'");
+  });
+
+  it('parses include/exclude tool lists', () => {
+    const args = ['--include-tools', 'a,b', '--include-tools', 'b,c', '--exclude-tools', 'x, y'];
+    const parsed = parseGenerateFlags([...args]);
+    expect(parsed.includeTools).toEqual(['a', 'b', 'c']);
+    expect(parsed.excludeTools).toEqual(['x', 'y']);
+  });
+});

package/tests/cli-global-flags.test.ts

@@ -0,0 +1,61 @@
+import fsPromises from 'node:fs/promises';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+const packageJsonPath = new URL('../package.json', import.meta.url);
+async function readPackageVersion(): Promise<string> {
+  const buffer = await fsPromises.readFile(packageJsonPath, 'utf8');
+  const pkg = JSON.parse(buffer) as { version?: string };
+  return pkg.version ?? '0.0.0';
+}
+
+describe('mcporter global shortcuts', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+  });
+
+  it('prints global help before inference when --help is provided', async () => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(['--help']);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage: mcporter'));
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('prints global help when the bare help token is provided', async () => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(['help']);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage: mcporter'));
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('prints the package version when --version is provided', async () => {
+    const { runCli } = await cliModulePromise;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const expectedVersion = await readPackageVersion();
+
+    await runCli(['--version']);
+
+    expect(logSpy).toHaveBeenCalledWith(expectedVersion);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it('prints the package version when -v is provided', async () => {
+    const { runCli } = await cliModulePromise;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const expectedVersion = await readPackageVersion();
+
+    await runCli(['-v']);
+
+    expect(logSpy).toHaveBeenCalledWith(expectedVersion);
+    expect(process.exitCode).toBeUndefined();
+  });
+});

package/tests/cli-help-shortcuts.test.ts

@@ -0,0 +1,42 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('mcporter help shortcuts (hidden)', () => {
+  let previousNoForceExit: string | undefined;
+
+  beforeEach(() => {
+    previousNoForceExit = process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.exitCode = undefined;
+    if (previousNoForceExit === undefined) {
+      delete process.env.MCPORTER_NO_FORCE_EXIT;
+    } else {
+      process.env.MCPORTER_NO_FORCE_EXIT = previousNoForceExit;
+    }
+  });
+
+  const cases: Array<{ args: string[]; expectSnippet: string }> = [
+    { args: ['call', '--help'], expectSnippet: 'Usage: mcporter call' },
+    { args: ['call', 'help'], expectSnippet: 'Usage: mcporter call' },
+    { args: ['auth', '--help'], expectSnippet: 'Usage: mcporter auth' },
+    { args: ['auth', 'help'], expectSnippet: 'Usage: mcporter auth' },
+    { args: ['list', '--help'], expectSnippet: 'Usage: mcporter list' },
+    { args: ['list', 'help'], expectSnippet: 'Usage: mcporter list' },
+  ];
+
+  it.each(cases)('prints help for %j', async ({ args, expectSnippet }) => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(args);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(expectSnippet));
+    expect(process.exitCode).toBe(0);
+  });
+});

package/tests/cli-image-output.test.ts

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { saveCallImagesIfRequested } from '../src/cli/image-output.js';
+import { printCallOutput } from '../src/cli/output-utils.js';
+import { createCallResult } from '../src/result-utils.js';
+
+describe('saveCallImagesIfRequested', () => {
+  it('does nothing when no output directory is provided', () => {
+    const wrapped = createCallResult({
+      content: [{ type: 'image', mimeType: 'image/png', data: 'aGVsbG8=' }],
+    });
+    const writeSpy = vi.spyOn(fs, 'writeFileSync');
+    try {
+      saveCallImagesIfRequested(wrapped, undefined);
+      expect(writeSpy).not.toHaveBeenCalled();
+    } finally {
+      writeSpy.mockRestore();
+    }
+  });
+
+  it('saves image content blocks to the requested directory', () => {
+    const wrapped = createCallResult({
+      content: [{ type: 'image', mimeType: 'image/png', data: 'aGVsbG8=' }],
+    });
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcporter-images-'));
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      saveCallImagesIfRequested(wrapped, tempDir);
+      const files = fs.readdirSync(tempDir);
+      expect(files.length).toBe(1);
+      const first = files[0];
+      expect(first?.endsWith('.png')).toBe(true);
+      const outputPath = path.join(tempDir, first ?? '');
+      expect(fs.readFileSync(outputPath, 'utf8')).toBe('hello');
+    } finally {
+      errorSpy.mockRestore();
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('keeps json output on stdout unchanged when saving images', () => {
+    const raw = {
+      content: [
+        { type: 'json', json: { id: 1 } },
+        { type: 'image', mimeType: 'image/png', data: 'aGVsbG8=' },
+      ],
+    };
+    const wrapped = createCallResult(raw);
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcporter-images-'));
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    try {
+      printCallOutput(wrapped, raw, 'json');
+      saveCallImagesIfRequested(wrapped, tempDir);
+      expect(logSpy).toHaveBeenCalledTimes(1);
+      expect(JSON.parse(String(logSpy.mock.calls[0]?.[0]))).toEqual({ id: 1 });
+    } finally {
+      logSpy.mockRestore();
+      errorSpy.mockRestore();
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/tests/cli-inspect-command.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { __test as inspectInternals } from '../src/cli/inspect-cli-command.js';
+
+describe('inspect-cli flag parsing', () => {
+  it('supports --json shorthand', () => {
+    const args = ['--json', '/tmp/artifact'];
+    const parsed = inspectInternals.parseInspectFlags(args);
+    expect(parsed.format).toBe('json');
+    expect(parsed.artifactPath).toBe('/tmp/artifact');
+  });
+
+  it('validates explicit format values', () => {
+    expect(() => inspectInternals.parseInspectFlags(['--format', 'xml', 'artifact'])).toThrow(/format/);
+  });
+});

package/tests/cli-list-classification.test.ts

@@ -0,0 +1,291 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { ServerDefinition } from '../src/config.js';
+import { cliModulePromise, linearDefinition } from './fixtures/cli-list-fixtures.js';
+
+describe('CLI list classification and routing', () => {
+  it('identifies auth and offline failures and suggests remediation', async () => {
+    const originalCI = process.env.CI;
+    process.env.CI = '1';
+
+    const { handleList } = await cliModulePromise;
+    const definitions: ServerDefinition[] = [
+      {
+        name: 'healthy',
+        command: { kind: 'stdio', command: 'noop', args: [], cwd: process.cwd() },
+        source: { kind: 'local', path: '/tmp/config.json' },
+      },
+      {
+        name: 'vercel',
+        description: 'Vercel MCP',
+        command: { kind: 'http', url: new URL('https://example.com') },
+      },
+      {
+        name: 'github',
+        command: { kind: 'http', url: new URL('https://example.com') },
+        source: { kind: 'import', path: '/tmp/import.json' },
+      },
+      {
+        name: 'next-devtools',
+        command: { kind: 'http', url: new URL('https://localhost') },
+      },
+      {
+        name: 'obsidian',
+        command: { kind: 'http', url: new URL('https://localhost') },
+      },
+    ];
+
+    const runtime = {
+      getDefinitions: () => definitions,
+      listTools: (name: string) => {
+        switch (name) {
+          case 'healthy':
+            return Promise.resolve([{ name: 'ok' }]);
+          case 'vercel':
+            return Promise.reject(new Error('SSE error: Non-200 status code (401)'));
+          case 'github':
+            return Promise.reject(new Error('SSE error: Non-200 status code (405)'));
+          case 'next-devtools':
+            return Promise.reject(new Error('SSE error: fetch failed: connect ECONNREFUSED 127.0.0.1:3000'));
+          case 'obsidian':
+            return Promise.reject(new Error('MCP error -32000: Connection closed'));
+          default:
+            return Promise.resolve([]);
+        }
+      },
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await handleList(runtime, []);
+
+    const logLines = logSpy.mock.calls.map((call) => call.join(' '));
+    expect(
+      logLines.some((line) => line.includes("vercel — Vercel MCP (auth required — run 'mcporter auth vercel'"))
+    ).toBe(true);
+    expect(logLines.some((line) => line.includes('github') && line.includes('HTTP 405'))).toBe(true);
+    const nextDevtoolsLineFound = logLines.some(
+      (line) => line.startsWith('- next-devtools') && line.includes('offline — unable to reach server')
+    );
+    expect(nextDevtoolsLineFound).toBe(true);
+    expect(
+      logLines.some((line) => line.includes('obsidian') && line.includes('offline — unable to reach server'))
+    ).toBe(true);
+
+    const summaryLine = logLines.find((line) => line.startsWith('✔ Listed'));
+    expect(summaryLine).toBeDefined();
+    expect(summaryLine).toContain('auth required');
+    expect(summaryLine).toContain('http errors');
+    expect(summaryLine).toContain('offline');
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+    process.env.CI = originalCI;
+  });
+
+  it('suggests URL-based auth for ad-hoc HTTP servers', async () => {
+    const { handleList } = await cliModulePromise;
+    const definitions = new Map<string, ServerDefinition>();
+    const runtime = {
+      registerDefinition: vi.fn((definition: ServerDefinition) => {
+        definitions.set(definition.name, definition);
+      }),
+      getDefinition: vi.fn((name: string) => {
+        const entry = definitions.get(name);
+        if (!entry) {
+          throw new Error(`Unknown MCP server '${name}'.`);
+        }
+        return entry;
+      }),
+      getDefinitions: () => Array.from(definitions.values()),
+      listTools: vi.fn().mockRejectedValue(new Error('SSE error: Non-200 status code (401)')),
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['https://mcp.supabase.com/mcp']);
+
+    const hinted = warnSpy.mock.calls.some((call) =>
+      (call[0]?.toString() ?? '').includes("Next: run 'mcporter auth https://mcp.supabase.com/mcp'")
+    );
+    expect(hinted).toBe(true);
+
+    warnSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('reuses configured servers when listing by URL', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition: ServerDefinition = {
+      name: 'vercel',
+      description: 'Vercel MCP',
+      command: { kind: 'http', url: new URL('https://mcp.vercel.com') },
+      source: { kind: 'local', path: '/tmp/config.json' },
+    };
+    const registerDefinition = vi.fn();
+    const listTools = vi.fn().mockResolvedValue([{ name: 'ok' }]);
+    const runtime = {
+      getDefinitions: () => [definition],
+      registerDefinition,
+      getDefinition: () => definition,
+      listTools,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    await handleList(runtime, ['https://mcp.vercel.com']);
+
+    expect(listTools).toHaveBeenCalledWith('vercel', expect.anything());
+    expect(registerDefinition).not.toHaveBeenCalled();
+  });
+
+  it('reuses configured servers when listing by HTTP tool selector', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition: ServerDefinition = {
+      name: 'shadcn',
+      description: 'shadcn/ui registry MCP',
+      command: { kind: 'http', url: new URL('https://shadcn.io/api/mcp') },
+      source: { kind: 'local', path: '/tmp/config.json' },
+    };
+    const registerDefinition = vi.fn();
+    const listTools = vi.fn().mockResolvedValue([{ name: 'getComponents' }]);
+    const runtime = {
+      getDefinitions: () => [definition],
+      registerDefinition,
+      getDefinition: () => definition,
+      listTools,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    await handleList(runtime, ['https://www.shadcn.io/api/mcp.getComponents']);
+
+    expect(listTools).toHaveBeenCalledWith('shadcn', expect.anything());
+    expect(registerDefinition).not.toHaveBeenCalled();
+  });
+
+  it('reuses configured servers for scheme-less HTTP tool selectors', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition: ServerDefinition = {
+      name: 'shadcn',
+      description: 'shadcn/ui registry MCP',
+      command: { kind: 'http', url: new URL('https://shadcn.io/api/mcp') },
+      source: { kind: 'local', path: '/tmp/config.json' },
+    };
+    const listTools = vi.fn().mockResolvedValue([{ name: 'getComponents' }]);
+    const runtime = {
+      getDefinitions: () => [definition],
+      registerDefinition: vi.fn(),
+      getDefinition: () => definition,
+      listTools,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    await handleList(runtime, ['shadcn.io/api/mcp.getComponents']);
+
+    expect(listTools).toHaveBeenCalledWith('shadcn', expect.anything());
+  });
+
+  it('enables cached OAuth when listing all servers', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition: ServerDefinition = {
+      name: 'linear',
+      description: 'Linear MCP',
+      auth: 'oauth',
+      command: { kind: 'http', url: new URL('https://mcp.linear.app/sse') },
+      source: { kind: 'local', path: '/tmp/config.json' },
+    };
+    const listTools = vi.fn().mockResolvedValue([{ name: 'ok' }]);
+    const runtime = {
+      getDefinitions: () => [definition],
+      listTools,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    await handleList(runtime, []);
+
+    expect(listTools).toHaveBeenCalledWith('linear', {
+      autoAuthorize: false,
+      allowCachedAuth: true,
+    });
+  });
+
+  it('registers an ad-hoc HTTP server when URL is provided', async () => {
+    const { handleList } = await cliModulePromise;
+    const definitions = new Map<string, ServerDefinition>();
+    const registerDefinition = vi.fn((definition: ServerDefinition) => {
+      definitions.set(definition.name, definition);
+    });
+    const listTools = vi.fn(() => Promise.resolve([]));
+    const runtime = {
+      getDefinitions: () => Array.from(definitions.values()),
+      getDefinition: (name: string) => {
+        const definition = definitions.get(name);
+        if (!definition) {
+          throw new Error('missing');
+        }
+        return definition;
+      },
+      listTools,
+      registerDefinition,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['https://mcp.example.com/mcp']);
+
+    expect(registerDefinition).toHaveBeenCalled();
+    expect(definitions.get('mcp-example-com-mcp')).toBeDefined();
+    expect(listTools).toHaveBeenCalledWith('mcp-example-com-mcp', expect.objectContaining({ includeSchema: true }));
+
+    logSpy.mockRestore();
+  });
+
+  it('auto-corrects unknown server names when the edit distance is small', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition = linearDefinition;
+    const getDefinition = vi.fn().mockImplementation((name: string) => {
+      if (name === 'linear') {
+        return definition;
+      }
+      throw new Error(`Unknown MCP server '${name}'.`);
+    });
+    const listTools = vi.fn(() => Promise.resolve([]));
+    const runtime = {
+      getDefinition,
+      getDefinitions: () => [definition],
+      listTools,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['linera']);
+
+    expect(getDefinition).toHaveBeenCalledTimes(2);
+    expect(listTools).toHaveBeenCalledWith('linear', expect.objectContaining({ includeSchema: true }));
+    const messages = logSpy.mock.calls.map((call) => call.join(' '));
+    expect(messages.some((line) => line.includes('Auto-corrected server name to linear'))).toBe(true);
+
+    logSpy.mockRestore();
+  });
+
+  it('suggests a server name when the typo is large', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition = linearDefinition;
+    const listTools = vi.fn();
+    const runtime = {
+      getDefinition: () => {
+        throw new Error("Unknown MCP server 'zzz'");
+      },
+      getDefinitions: () => [definition],
+      listTools,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['zzz']);
+
+    const errorLines = errorSpy.mock.calls.map((call) => call.join(' '));
+    expect(errorLines.some((line) => line.includes('Did you mean linear?'))).toBe(true);
+    expect(listTools).not.toHaveBeenCalled();
+
+    errorSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+});