@nimrobo/mcporter-remote 0.1.0

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

@@ -0,0 +1,83 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { ServerDefinition } from '../src/config.js';
+import { cliModulePromise } from './fixtures/cli-list-fixtures.js';
+
+describe('CLI list flag parsing', () => {
+  it('parses --timeout flag into list flags', async () => {
+    const { extractListFlags } = await cliModulePromise;
+    const args = ['--timeout', '7500', '--schema', 'server'];
+    const flags = extractListFlags(args);
+    expect(flags).toEqual({
+      schema: true,
+      timeoutMs: 7500,
+      requiredOnly: true,
+      includeSources: false,
+      verbose: false,
+      ephemeral: undefined,
+      format: 'text',
+    });
+    expect(args).toEqual(['server']);
+  });
+
+  it('parses --all-parameters flag and removes it from args', async () => {
+    const { extractListFlags } = await cliModulePromise;
+    const args = ['--all-parameters', 'server'];
+    const flags = extractListFlags(args);
+    expect(flags).toEqual({
+      schema: false,
+      timeoutMs: undefined,
+      requiredOnly: false,
+      includeSources: false,
+      verbose: false,
+      ephemeral: undefined,
+      format: 'text',
+    });
+    expect(args).toEqual(['server']);
+  });
+
+  it('parses --json flag and removes it from args', async () => {
+    const { extractListFlags } = await cliModulePromise;
+    const args = ['--json', 'server'];
+    const flags = extractListFlags(args);
+    expect(flags.format).toBe('json');
+    expect(args).toEqual(['server']);
+  });
+
+  it('treats --sse as a hidden alias for --http-url in ad-hoc mode', async () => {
+    const { extractListFlags } = await cliModulePromise;
+    const args = ['--sse', 'https://mcp.example.com/sse', 'list'];
+    const flags = extractListFlags(args);
+    expect(flags.ephemeral).toEqual({ httpUrl: 'https://mcp.example.com/sse' });
+    expect(args).toEqual(['list']);
+  });
+
+  it('honors --timeout when listing a single server', async () => {
+    const { handleList } = await cliModulePromise;
+    const definition: ServerDefinition = {
+      name: 'slow-server',
+      command: { kind: 'stdio', command: 'noop', args: [], cwd: process.cwd() },
+      source: { kind: 'local', path: '/tmp/config.json' },
+    };
+
+    const runtime = {
+      getDefinitions: () => [definition],
+      getDefinition: () => definition,
+      listTools: () =>
+        new Promise((resolve) => {
+          setTimeout(() => resolve([{ name: 'ok' }]), 50);
+        }),
+    } 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, ['--timeout', '10', 'slow-server']);
+
+    const warningLines = warnSpy.mock.calls.map((call) => call[0]);
+    expect(warningLines).toContain('  Tools: <timed out after 10ms>');
+    expect(warningLines).toContain('  Reason: Timeout');
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,358 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { ServerDefinition } from '../src/config.js';
+import { stripAnsi } from './fixtures/ansi.js';
+import { buildLinearDocumentsTool, cliModulePromise, linearDefinition } from './fixtures/cli-list-fixtures.js';
+
+describe('CLI list formatting', () => {
+  it('prints detailed usage for single server listings', async () => {
+    const { handleList } = await cliModulePromise;
+    const listToolsSpy = vi.fn((_name: string, options?: { includeSchema?: boolean }) =>
+      Promise.resolve([
+        {
+          name: 'add',
+          description: 'Add two numbers',
+          inputSchema: options?.includeSchema
+            ? {
+                type: 'object',
+                properties: {
+                  a: { type: 'number', description: 'First operand' },
+                  format: { type: 'string', enum: ['json', 'markdown'], description: 'Output serialization format' },
+                  dueBefore: { type: 'string', format: 'date-time', description: 'ISO 8601 timestamp' },
+                },
+                required: ['a'],
+              }
+            : undefined,
+          outputSchema: options?.includeSchema
+            ? {
+                type: 'object',
+                properties: {
+                  result: { type: 'array', description: 'List of calculation results' },
+                  total: { type: 'number', description: 'Total results returned' },
+                },
+              }
+            : undefined,
+        },
+      ])
+    );
+    const runtime = {
+      getDefinition: (name: string) => ({
+        name,
+        description: 'Test integration server',
+        command: { kind: 'http', url: new URL('https://example.com/mcp') },
+      }),
+      listTools: listToolsSpy,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['calculator']);
+
+    const rawLines = logSpy.mock.calls.map((call) => call.join(' '));
+    const lines = rawLines.map(stripAnsi);
+
+    const headerLine = lines.find((line) => line.trim().startsWith('calculator -'));
+    expect(headerLine).toBeDefined();
+    const summaryLine = lines.find((line) => line.includes('HTTP https://example.com/mcp'));
+    expect(summaryLine).toBeDefined();
+    expect(summaryLine).toMatch(/1 tool/);
+    expect(summaryLine).toMatch(/ms/);
+    expect(summaryLine).toContain('HTTP https://example.com/mcp');
+    expect(lines.some((line) => line.includes('/**'))).toBe(true);
+    const paramLineIndex = lines.findIndex((line) => line.includes('@param a'));
+    expect(paramLineIndex).toBeGreaterThan(1);
+    expect(lines[paramLineIndex - 1]?.trim()).toBe('*');
+    expect(lines.some((line) => line.includes('@param a') && line.includes('First operand'))).toBe(true);
+    expect(lines.some((line) => line.includes('function add('))).toBe(true);
+    expect(lines.some((line) => line.includes('format?: "json" | "markdown"'))).toBe(true);
+    expect(lines.some((line) => line.includes('dueBefore?: string'))).toBe(true);
+    expect(lines.some((line) => line.includes('Examples:'))).toBe(true);
+    expect(lines.some((line) => line.includes('mcporter call calculator.add(a: 1'))).toBe(true);
+    expect(
+      lines.some((line) => line.includes('Optional parameters hidden; run with --all-parameters to view all fields'))
+    ).toBe(false);
+    expect(listToolsSpy).toHaveBeenCalledWith('calculator', expect.objectContaining({ includeSchema: true }));
+
+    logSpy.mockRestore();
+  });
+
+  it('emits JSON summaries for multi-server listings when --json is provided', async () => {
+    const { handleList } = await cliModulePromise;
+    const originalCI = process.env.CI;
+    process.env.CI = '1';
+    const definitions: ServerDefinition[] = [
+      linearDefinition,
+      {
+        name: 'github',
+        command: { kind: 'http', url: new URL('https://example.com/mcp') },
+      },
+    ];
+    const runtime = {
+      getDefinitions: () => definitions,
+      listTools: (name: string) => {
+        if (name === 'linear') {
+          return Promise.resolve([{ name: 'list_documents' }]);
+        }
+        return Promise.reject(new Error('HTTP error 500: upstream unavailable'));
+      },
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await handleList(runtime, ['--json']);
+    const payload = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}');
+    expect(payload.mode).toBe('list');
+    expect(payload.servers).toHaveLength(2);
+    const github = payload.servers.find((entry: { name: string }) => entry.name === 'github');
+    expect(github.status).toBe('http');
+    const linear = payload.servers.find((entry: { name: string }) => entry.name === 'linear');
+    expect(linear.tools[0].name).toBe('list_documents');
+    logSpy.mockRestore();
+    process.env.CI = originalCI;
+  });
+
+  it('emits JSON payloads for single server listings when --json is provided', async () => {
+    const { handleList } = await cliModulePromise;
+    const toolCache = await import('../src/cli/tool-cache.js');
+    const metadata = [
+      {
+        tool: {
+          name: 'add',
+          description: 'Add numbers',
+          inputSchema: { type: 'object', properties: { a: { type: 'number' } }, required: ['a'] },
+          outputSchema: { type: 'number' },
+        },
+        methodName: 'add',
+        options: [],
+      },
+    ];
+    const metadataSpy = vi.spyOn(toolCache, 'loadToolMetadata').mockResolvedValue(metadata as never);
+    const definition: ServerDefinition = {
+      name: 'linear',
+      description: 'Hosted Linear MCP',
+      command: { kind: 'http', url: new URL('https://example.com/mcp') },
+    };
+    const runtime = {
+      getDefinitions: () => [definition],
+      getDefinition: () => definition,
+      registerDefinition: vi.fn(),
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['--json', 'linear']);
+
+    const payload = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}');
+    expect(payload.mode).toBe('server');
+    expect(payload.status).toBe('ok');
+    expect(payload.tools[0].name).toBe('add');
+
+    logSpy.mockRestore();
+    metadataSpy.mockRestore();
+  });
+
+  it('summarizes hidden optional parameters and hints include flag', async () => {
+    const { handleList } = await cliModulePromise;
+    const listToolsSpy = vi.fn((_name: string, options?: { includeSchema?: boolean }) =>
+      Promise.resolve([buildLinearDocumentsTool(options?.includeSchema)])
+    );
+    const runtime = {
+      getDefinition: () => linearDefinition,
+      listTools: listToolsSpy,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['linear']);
+
+    const lines = logSpy.mock.calls.map((call) => stripAnsi(call.join(' ')));
+    expect(lines.some((line) => line.includes('function list_documents('))).toBe(true);
+    expect(
+      lines.some((line) => line.includes('// optional (4): projectId, initiativeId, creatorId, includeArchived'))
+    ).toBe(true);
+    expect(
+      lines.some((line) => line.includes('Optional parameters hidden; run with --all-parameters to view all fields'))
+    ).toBe(true);
+    expect(listToolsSpy).toHaveBeenCalledWith('linear', expect.objectContaining({ includeSchema: true }));
+
+    logSpy.mockRestore();
+  });
+
+  it('truncates long examples for readability', async () => {
+    const { handleList } = await cliModulePromise;
+    const listToolsSpy = vi.fn((_name: string, options?: { includeSchema?: boolean }) =>
+      Promise.resolve([buildLinearDocumentsTool(options?.includeSchema)])
+    );
+    const runtime = {
+      getDefinition: () => linearDefinition,
+      listTools: listToolsSpy,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['linear']);
+
+    const lines = logSpy.mock.calls.map((call) => stripAnsi(call.join(' ')));
+    const exampleLines = lines.filter((line) => line.includes('mcporter call linear.'));
+    expect(exampleLines).toHaveLength(1);
+    const exampleLine = exampleLines[0] as string;
+    expect(exampleLine.length).toBeLessThanOrEqual(90);
+    expect(exampleLine).toMatch(/, ...\)$/);
+
+    logSpy.mockRestore();
+  });
+
+  it('indents multi-line parameter docs beneath the @param label', async () => {
+    const { handleList } = await cliModulePromise;
+    const listToolsSpy = vi.fn((_name: string, options?: { includeSchema?: boolean }) =>
+      Promise.resolve([
+        {
+          name: 'list_projects',
+          description: 'List Vercel projects',
+          inputSchema: options?.includeSchema
+            ? {
+                type: 'object',
+                properties: {
+                  teamId: {
+                    type: 'string',
+                    description: `The team ID to target.\nTeam IDs start with "team_".\n- Read the file .vercel/project.json\n- Use the list_teams tool`,
+                  },
+                },
+                required: ['teamId'],
+              }
+            : undefined,
+        },
+      ])
+    );
+    const runtime = {
+      getDefinition: () => linearDefinition,
+      listTools: listToolsSpy,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['linear']);
+
+    const lines = logSpy.mock.calls.map((call) => stripAnsi(call.join(' ')));
+    expect(lines.some((line) => line.includes('@param teamId'))).toBe(true);
+    const continuationLine = lines.find((line) => line.includes('Team IDs start with "team_"'));
+    expect(continuationLine).toBeDefined();
+    expect(continuationLine?.includes('*               Team IDs start with "team_"')).toBe(true);
+
+    logSpy.mockRestore();
+  });
+
+  it('includes optional parameters when --all-parameters is set', async () => {
+    const { handleList } = await cliModulePromise;
+    const listToolsSpy = vi.fn((_name: string, options?: { includeSchema?: boolean }) =>
+      Promise.resolve([buildLinearDocumentsTool(options?.includeSchema)])
+    );
+    const runtime = {
+      getDefinition: () => linearDefinition,
+      listTools: listToolsSpy,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleList(runtime, ['--all-parameters', 'linear']);
+
+    const lines = logSpy.mock.calls.map((call) => stripAnsi(call.join(' ')));
+
+    const headerLine = lines.find((line) => line.trim().startsWith('linear -'));
+    expect(headerLine).toBeDefined();
+    const summaryLine = lines.find((line) => line.includes('HTTP https://example.com/mcp'));
+    expect(summaryLine).toBeDefined();
+    expect(summaryLine).toMatch(/1 tool/);
+    expect(summaryLine).toMatch(/ms/);
+    expect(summaryLine).toContain('HTTP https://example.com/mcp');
+    expect(lines.some((line) => line.includes('/**'))).toBe(true);
+    expect(lines.some((line) => line.includes('@param limit?') && line.includes('Maximum number of documents'))).toBe(
+      true
+    );
+    expect(lines.some((line) => line.includes('function list_documents('))).toBe(true);
+    expect(lines.some((line) => line.includes('limit?: number'))).toBe(true);
+    expect(lines.some((line) => line.includes('orderBy?: "createdAt" | "updatedAt"'))).toBe(true);
+    expect(lines.some((line) => line.includes('includeArchived?: boolean'))).toBe(true);
+    expect(listToolsSpy).toHaveBeenCalledWith('linear', expect.objectContaining({ includeSchema: true }));
+
+    logSpy.mockRestore();
+  });
+
+  it('matches the expected formatted snapshot for a complex server', async () => {
+    const { handleList } = await cliModulePromise;
+    const listToolsSpy = vi.fn((_name: string, options?: { includeSchema?: boolean }) =>
+      Promise.resolve([
+        buildLinearDocumentsTool(options?.includeSchema),
+        {
+          name: 'create_comment',
+          description: 'Create a comment on a specific Linear issue',
+          inputSchema: options?.includeSchema
+            ? {
+                type: 'object',
+                properties: {
+                  issueId: { type: 'string', description: 'The issue ID' },
+                  parentId: { type: 'string', description: 'Optional parent comment ID' },
+                  body: { type: 'string', description: 'Comment body as Markdown' },
+                },
+                required: ['issueId', 'body'],
+              }
+            : undefined,
+          outputSchema: options?.includeSchema
+            ? {
+                title: 'Comment',
+                type: 'object',
+              }
+            : undefined,
+        },
+      ])
+    );
+    const runtime = {
+      getDefinition: () => linearDefinition,
+      listTools: listToolsSpy,
+    } as unknown as Awaited<ReturnType<typeof import('../src/runtime.js')['createRuntime']>>;
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const nowSpy = vi.spyOn(Date, 'now').mockReturnValue(1_700_000_000_000);
+
+    await handleList(runtime, ['linear']);
+
+    nowSpy.mockRestore();
+
+    const lines = logSpy.mock.calls.map((call) => stripAnsi(call.join(' ')));
+    expect(lines.join('\n')).toMatchInlineSnapshot(`
+      "linear - Hosted Linear MCP
+
+        /**
+         * List documents in the user's Linear workspace
+         *
+         * @param query The search query
+         * @param limit? Maximum number of documents to return
+         * @param before? Cursor to page backwards
+         * @param after? Cursor to page forwards
+         * @param orderBy? Sort order for the documents
+         * @param projectId? Filter by project
+         * @param initiativeId? Filter by initiative
+         * @param creatorId? Filter by creator
+         * @param includeArchived? Whether to include archived documents
+         */
+        function list_documents(query: string, limit?: number, before?: string, after?: string, orderBy?: "createdAt" | "updatedAt"): DocumentConnection;
+        // optional (4): projectId, initiativeId, creatorId, includeArchived
+
+        /**
+         * Create a comment on a specific Linear issue
+         *
+         * @param issueId The issue ID
+         * @param parentId? Optional parent comment ID
+         * @param body Comment body as Markdown
+         */
+        function create_comment(issueId: string, parentId?: string, body: string): Comment;
+
+        Examples:
+          mcporter call linear.list_documents(query: "value", limit: 1, orderBy: "cr, ...)
+
+        Optional parameters hidden; run with --all-parameters to view all fields.
+
+        2 tools · 0ms · HTTP https://example.com/mcp
+      "
+    `);
+
+    logSpy.mockRestore();
+  });
+});

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

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('mcporter list help shortcut', () => {
+  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;
+    }
+  });
+
+  it('prints list-specific help when --help is used', async () => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(['list', '--help']);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage: mcporter list'));
+    expect(process.exitCode).toBe(0);
+  });
+
+  it('prints list-specific help when the bare help token follows the command', async () => {
+    const { runCli } = await cliModulePromise;
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await runCli(['list', 'help']);
+
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Usage: mcporter list'));
+    expect(process.exitCode).toBe(0);
+  });
+});

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

@@ -0,0 +1,55 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleList as runHandleList } from '../src/cli/list-command.js';
+import type { ServerDefinition } from '../src/config.js';
+import type { Runtime } from '../src/runtime.js';
+
+const healthyDefinition: ServerDefinition = {
+  name: 'healthy',
+  command: { kind: 'http', url: new URL('https://healthy.example.com/mcp') },
+};
+
+const authDefinition: ServerDefinition = {
+  name: 'auth-server',
+  command: { kind: 'http', url: new URL('https://auth.example.com/mcp') },
+};
+
+function createRuntime(): Runtime {
+  const definitions = [healthyDefinition, authDefinition];
+  return {
+    getDefinitions: () => definitions,
+    getDefinition: (name: string) => {
+      const definition = definitions.find((entry) => entry.name === name);
+      if (!definition) {
+        throw new Error(`Unknown server '${name}'`);
+      }
+      return definition;
+    },
+    registerDefinition: vi.fn(),
+    listTools: vi.fn((name: string) => {
+      if (name === 'healthy') {
+        return Promise.resolve([{ name: 'list_documents' }]);
+      }
+      return Promise.reject(new Error('HTTP error 401: auth required'));
+    }),
+  } as unknown as Runtime;
+}
+
+describe('handleList JSON output', () => {
+  it('emits aggregated status counts', async () => {
+    const runtime = createRuntime();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await runHandleList(runtime, ['--json']);
+
+    const payload = JSON.parse(logSpy.mock.calls.at(-1)?.[0] ?? '{}');
+    expect(payload.mode).toBe('list');
+    expect(payload.counts.auth).toBe(1);
+    const healthyEntry = payload.servers.find((entry: { name: string }) => entry.name === 'healthy');
+    expect(healthyEntry.status).toBe('ok');
+    const authEntry = payload.servers.find((entry: { name: string }) => entry.name === 'auth-server');
+    expect(authEntry.status).toBe('auth');
+    expect(authEntry.issue.kind).toBe('auth');
+
+    logSpy.mockRestore();
+  });
+});

package/tests/cli-list-stdio-logs.test.ts

@@ -0,0 +1,108 @@
+import { afterEach, beforeEach, 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';
+import * as sdkPatches from '../src/sdk-patches.js';
+
+function buildServerDefinition(name: string): ServerDefinition {
+  return {
+    name,
+    description: `${name} server`,
+    command: { kind: 'stdio', command: name, args: [], cwd: '/tmp' },
+    source: { kind: 'local', path: '/tmp/mcporter.json' },
+  };
+}
+
+function createRuntime(definitions: ServerDefinition[]) {
+  const listTools = vi.fn(
+    async (_name: string, _options?: unknown): Promise<ServerToolInfo[]> => [
+      {
+        name: 'doctor',
+        description: 'Runs diagnostics',
+        inputSchema: undefined,
+        outputSchema: undefined,
+      },
+    ]
+  );
+  const runtime: Runtime = {
+    listServers: () => definitions.map((entry) => entry.name),
+    getDefinitions: () => definitions,
+    getDefinition: (name: string): ServerDefinition => {
+      const found = definitions.find((entry) => entry.name === name);
+      if (!found) {
+        throw new Error(`Unknown MCP server '${name}'.`);
+      }
+      return found;
+    },
+    registerDefinition: vi.fn(),
+    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 };
+}
+
+const originalCI = process.env.CI;
+
+describe('handleList STDIO log policy', () => {
+  beforeEach(() => {
+    process.env.CI = '1';
+    sdkPatches.setStdioLogMode('auto');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    process.env.CI = originalCI;
+    sdkPatches.setStdioLogMode('auto');
+  });
+
+  it('silences STDIO stderr when listing all servers', async () => {
+    const definitions = [buildServerDefinition('alpha'), buildServerDefinition('beta')];
+    const { runtime, listTools } = createRuntime(definitions);
+    const setModeSpy = vi.spyOn(sdkPatches, 'setStdioLogMode');
+    const observedModes: sdkPatches.StdioLogMode[] = [];
+    listTools.mockImplementation(async (_name: string, _options?: unknown) => {
+      observedModes.push(sdkPatches.getStdioLogMode());
+      return [
+        {
+          name: 'doctor',
+          description: 'Runs diagnostics',
+          inputSchema: undefined,
+          outputSchema: undefined,
+        },
+      ];
+    });
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      await handleList(runtime, []);
+    } finally {
+      logSpy.mockRestore();
+      warnSpy.mockRestore();
+    }
+    expect(setModeSpy).toHaveBeenCalledWith('silent');
+    const lastCall = setModeSpy.mock.calls.at(-1);
+    expect(lastCall?.[0]).toBe('auto');
+    expect(observedModes.length).toBeGreaterThan(0);
+    expect(observedModes.every((mode) => mode === 'silent')).toBe(true);
+  });
+
+  it('leaves STDIO stderr in auto mode for targeted listings', async () => {
+    const definitions = [buildServerDefinition('alpha')];
+    const { runtime } = createRuntime(definitions);
+    const setModeSpy = vi.spyOn(sdkPatches, 'setStdioLogMode');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      await handleList(runtime, ['alpha']);
+    } finally {
+      logSpy.mockRestore();
+      warnSpy.mockRestore();
+    }
+    expect(setModeSpy).not.toHaveBeenCalled();
+  });
+});