fix(stdio): quiet existing WDIO loggers

Author: Mochxd

package.json

@@ -70,6 +70,7 @@
   "dependencies": {
     "@appium/support": "^7.0.2",
     "@modelcontextprotocol/sdk": "^1.22.0",
+    "@wdio/logger": "^9.29.1",
     "@xmldom/xmldom": "^0.9.8",
     "appium-adb": "^16.0.0",
     "appium-ios-device": "^3.1.0",

src/logger.ts

@@ -1,6 +1,7 @@
 import {logger} from '@appium/support';
 
 import {isStdioTransportLoggingConfigured, markStdioTransportLoggingConfigured} from './stdio-logging-state.js';
+import {quietExistingWdioLoggers} from './utils/wdio-logging.js';
 
 const log = logger.getLogger('appium-mcp');
 
@@ -20,9 +21,7 @@ export function configureStdioTransportLogging(): void {
   markStdioTransportLoggingConfigured();
   ensureLoggerWritesToStderr();
   log.level = 'warn';
-  if (!process.env.WDIO_LOG_LEVEL) {
-    process.env.WDIO_LOG_LEVEL = 'warn';
-  }
+  quietExistingWdioLoggers();
 }
 
 export default log;

src/tests/fixtures/programmatic-stdio-wdio-child.ts

@@ -0,0 +1,43 @@
+import http from 'node:http';
+
+import {createAppiumMcpServer} from '../../core.js';
+import {attachToRemoteSession} from '../../utils/url.js';
+
+const mockServer = http.createServer((_req, res) => {
+  res.writeHead(200, {'Content-Type': 'application/json; charset=utf-8'});
+  res.end(
+    JSON.stringify({
+      value: {
+        sessionId: 'test-session',
+        capabilities: {platformName: 'Android'},
+      },
+    }),
+  );
+});
+
+await new Promise<void>((resolve) => {
+  mockServer.listen(0, '127.0.0.1', () => resolve());
+});
+
+const {port} = mockServer.address() as {port: number};
+const remoteServerUrl = `http://127.0.0.1:${port}/`;
+
+try {
+  const server = await createAppiumMcpServer();
+  void server.start({transportType: 'stdio'});
+
+  const client = await attachToRemoteSession({
+    remoteServerUrl,
+    sessionId: 'test-session',
+    capabilities: {platformName: 'Android'},
+  });
+
+  await client.deleteSession();
+  process.stderr.write('child-done\n');
+  process.exit(0);
+} catch (err) {
+  process.stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+  process.exit(1);
+} finally {
+  mockServer.close();
+}

src/tests/logger.test.ts

@@ -1,4 +1,5 @@
 import {afterEach, describe, expect, test} from '@jest/globals';
+import wdioLogger from '@wdio/logger';
 
 import {configureStdioTransportLogging, ensureLoggerWritesToStderr, log} from '../logger.js';
 import {isStdioTransportLoggingConfigured, markStdioTransportLoggingConfigured} from '../stdio-logging-state.js';
@@ -48,13 +49,20 @@ describe('stdio transport logging', () => {
   test('configureStdioTransportLogging quiets info logs and WDIO when unset', () => {
     delete process.env.WDIO_LOG_LEVEL;
     log.unwrap().stream = process.stdout;
+    const utilsLogger = wdioLogger('@wdio/utils');
+    const webdriverLogger = wdioLogger('webdriver');
+    utilsLogger.setLevel('info');
+    webdriverLogger.setLevel('info');
+    const infoLevel = utilsLogger.getLevel();
 
     configureStdioTransportLogging();
 
     expect(isStdioTransportLoggingConfigured()).toBe(true);
     expect(log.unwrap().stream).toBe(process.stderr);
     expect(log.level).toBe('warn');
     expect(process.env.WDIO_LOG_LEVEL).toBe('warn');
+    expect(utilsLogger.getLevel()).toBeGreaterThan(infoLevel);
+    expect(webdriverLogger.getLevel()).toBeGreaterThan(infoLevel);
   });
 
   test('withQuietWebDriverLogging sets warn after stdio logging is configured', () => {

src/tests/stdio-wdio-logging.test.ts

@@ -0,0 +1,69 @@
+import {spawn} from 'node:child_process';
+import {existsSync} from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+
+import {describe, expect, test} from '@jest/globals';
+
+const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const fixturePath = path.join(rootDir, 'dist/tests/fixtures/programmatic-stdio-wdio-child.js');
+
+function isJsonRpcLine(line: string): boolean {
+  if (!line.trim()) {
+    return true;
+  }
+  try {
+    const message = JSON.parse(line);
+    return typeof message === 'object' && message !== null && 'jsonrpc' in message;
+  } catch {
+    return false;
+  }
+}
+
+describe('programmatic stdio WDIO logging', () => {
+  test('keeps non-JSON-RPC output off stdout after core stdio start', async () => {
+    if (!existsSync(fixturePath)) {
+      throw new Error(`Compiled fixture missing at ${fixturePath}. Run npm run build first.`);
+    }
+
+    const {WDIO_LOG_LEVEL: _wdioLogLevel, ...env} = process.env;
+    const child = spawn(process.execPath, [fixturePath], {
+      cwd: rootDir,
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString();
+    });
+
+    const exitCode = await new Promise<number>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        child.kill('SIGTERM');
+        reject(new Error(`child process timed out\nstdout: ${stdout}\nstderr: ${stderr}`));
+      }, 15_000);
+
+      child.on('error', reject);
+      child.on('close', (code) => {
+        clearTimeout(timeout);
+        resolve(code ?? 1);
+      });
+    });
+
+    expect(exitCode).toBe(0);
+    expect(stderr).toContain('child-done');
+
+    const nonEmptyStdoutLines = stdout.split('\n').filter((line) => line.trim().length > 0);
+    for (const line of nonEmptyStdoutLines) {
+      expect(isJsonRpcLine(line)).toBe(true);
+    }
+
+    expect(stdout).not.toMatch(/INFO\s+@wdio\/utils:/);
+    expect(stdout).not.toMatch(/INFO\s+webdriver:/);
+  }, 20_000);
+});

src/utils/wdio-logging.ts

@@ -0,0 +1,12 @@
+import wdioLogger from '@wdio/logger';
+
+import {QUIET_WEBDRIVER_LOG_LEVEL} from './webdriver-client-options.js';
+
+type WdioLogLevel = NonNullable<Parameters<typeof wdioLogger.setLogLevelsConfig>[1]>;
+
+/** Quiet every WDIO logger that was created before stdio config ran. */
+export function quietExistingWdioLoggers(
+  level: WdioLogLevel = (process.env.WDIO_LOG_LEVEL as WdioLogLevel | undefined) ?? QUIET_WEBDRIVER_LOG_LEVEL,
+): void {
+  wdioLogger.setLogLevelsConfig({}, level);
+}