@nimrobo/mcporter-remote 0.1.0

package/tests/runtime-header-utils.test.ts

@@ -0,0 +1,36 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { materializeHeaders } from '../src/runtime-header-utils.js';
+
+describe('materializeHeaders', () => {
+  const envKey = 'HEADER_TOKEN';
+  let previousValue: string | undefined;
+
+  afterEach(() => {
+    if (previousValue === undefined) {
+      delete process.env[envKey];
+    } else {
+      process.env[envKey] = previousValue;
+    }
+    previousValue = undefined;
+  });
+
+  it('resolves environment placeholders in headers', () => {
+    previousValue = process.env[envKey];
+    process.env[envKey] = 'test-secret';
+    const headers = materializeHeaders({ Authorization: `Bearer \${HEADER_TOKEN}` }, 'inline');
+    expect(headers).toEqual({ Authorization: 'Bearer test-secret' });
+  });
+
+  it('propagates a helpful error when placeholder resolution fails', () => {
+    previousValue = process.env[envKey];
+    delete process.env[envKey];
+    expect(() => materializeHeaders({ Authorization: `Bearer \${HEADER_TOKEN}` }, 'broken')).toThrow(
+      /Failed to resolve header 'Authorization'/
+    );
+  });
+
+  it('returns undefined when no headers are provided', () => {
+    const headers = materializeHeaders(undefined, 'noop');
+    expect(headers).toBeUndefined();
+  });
+});

package/tests/runtime-integration.test.ts

@@ -0,0 +1,113 @@
+import type { Server as HttpServer } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import express from 'express';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { z } from 'zod';
+import { createRuntime } from '../src/runtime.js';
+
+const app = express();
+app.use(express.json());
+app.get('/mcp', (_req, res) => {
+  res.sendStatus(405);
+});
+
+const server = new McpServer({
+  name: 'integration-demo',
+  version: '1.0.0',
+});
+
+server.registerTool(
+  'add',
+  {
+    title: 'Addition Tool',
+    description: 'Add two numbers',
+    inputSchema: { a: z.number(), b: z.number() },
+    outputSchema: { result: z.number() },
+  },
+  async ({ a, b }) => {
+    const result = { result: a + b };
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result) }],
+      structuredContent: result,
+    };
+  }
+);
+
+server.registerResource(
+  'greeting',
+  new ResourceTemplate('greeting://{name}', { list: undefined }),
+  {
+    title: 'Greeting',
+    description: 'Dynamic greeting resource',
+  },
+  async (uri, { name }) => {
+    const normalizedName = typeof name === 'string' ? name : Array.isArray(name) ? name.join(', ') : 'friend';
+
+    return {
+      contents: [
+        {
+          uri: uri.href,
+          text: `Hello, ${normalizedName}!`,
+        },
+      ],
+    };
+  }
+);
+
+app.post('/mcp', async (req, res) => {
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined,
+    enableJsonResponse: true,
+  });
+
+  res.on('close', () => {
+    transport.close().catch(() => {});
+  });
+
+  await server.connect(transport);
+  await transport.handleRequest(req, res, req.body);
+});
+
+let httpServer: HttpServer;
+let baseUrl: URL;
+
+describe('runtime integration', () => {
+  beforeAll(async () => {
+    httpServer = app.listen(0, '127.0.0.1');
+    await new Promise<void>((resolve, reject) => {
+      httpServer.once('listening', resolve);
+      httpServer.once('error', reject);
+    });
+    const address = httpServer.address() as AddressInfo;
+    baseUrl = new URL(`http://127.0.0.1:${address.port}/mcp`);
+  });
+
+  afterAll(async () => {
+    await new Promise<void>((resolve) => httpServer.close(() => resolve()));
+  });
+
+  it('lists tools and calls a tool over HTTP', async () => {
+    const runtime = await createRuntime({
+      servers: [
+        {
+          name: 'integration',
+          description: 'Integration test server',
+          command: { kind: 'http', url: baseUrl },
+        },
+      ],
+    });
+
+    const tools = await runtime.listTools('integration');
+    expect(tools.some((tool) => tool.name === 'add')).toBe(true);
+
+    const result = (await runtime.callTool('integration', 'add', {
+      args: { a: 3, b: 4 },
+    })) as { structuredContent?: { result: number } };
+
+    expect(result.structuredContent?.result).toBe(7);
+
+    await runtime.close('integration');
+  });
+});

package/tests/runtime-oauth-connect.test.ts

@@ -0,0 +1,72 @@
+import type { Client } from '@modelcontextprotocol/sdk/client';
+import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { describe, expect, it, vi } from 'vitest';
+import type { Logger } from '../src/logging.js';
+import type { OAuthSession } from '../src/oauth.js';
+import { connectWithAuth } from '../src/runtime/oauth.js';
+
+// Minimal mock transport that records finishAuth calls.
+class MockTransport implements Transport {
+  public readonly calls: string[] = [];
+  constructor(private readonly finishAuthImpl?: (code: string) => Promise<void>) {}
+  async start(): Promise<void> {}
+  async send(_message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void> {}
+  async close(): Promise<void> {}
+  async finishAuth(code: string): Promise<void> {
+    this.calls.push(code);
+    if (this.finishAuthImpl) {
+      await this.finishAuthImpl(code);
+    }
+  }
+}
+
+describe('connectWithAuth', () => {
+  it('waits for authorization code and retries connection', async () => {
+    // First connect throws Unauthorized, second succeeds after finishAuth.
+    const connect = vi
+      .fn()
+      .mockRejectedValueOnce(new UnauthorizedError('auth needed'))
+      .mockResolvedValueOnce(undefined);
+    const client = { connect } as unknown as Client;
+
+    let resolveCode: (code: string) => void = () => {};
+    const waitForAuthorizationCode = vi.fn(
+      () =>
+        new Promise<string>((resolve) => {
+          resolveCode = resolve;
+        })
+    );
+    const close = vi.fn(async () => {});
+    const session: OAuthSession = {
+      provider: { waitForAuthorizationCode } as unknown as OAuthSession['provider'],
+      waitForAuthorizationCode,
+      close,
+    };
+
+    const transport = new MockTransport();
+    const logger: Logger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+
+    const promise = connectWithAuth(client, transport, session, logger, {
+      serverName: 'test-server',
+      maxAttempts: 1,
+      oauthTimeoutMs: 5000,
+    });
+
+    await new Promise((resolve) => setImmediate(resolve));
+
+    // Simulate browser callback arrival.
+    resolveCode('oauth-code-123');
+
+    await promise;
+
+    expect(waitForAuthorizationCode).toHaveBeenCalledTimes(1);
+    expect(transport.calls).toEqual(['oauth-code-123']);
+    expect(connect).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/runtime-oauth-detection.test.ts

@@ -0,0 +1,72 @@
+import { UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js';
+import { describe, expect, it, vi } from 'vitest';
+
+import type { ServerDefinition } from '../src/config.js';
+import { isUnauthorizedError, maybeEnableOAuth } from '../src/runtime-oauth-support.js';
+
+const logger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+};
+
+describe('maybeEnableOAuth', () => {
+  const baseDefinition: ServerDefinition = {
+    name: 'adhoc-server',
+    command: { kind: 'http', url: new URL('https://example.com/mcp') },
+    source: { kind: 'local', path: '<adhoc>' },
+  };
+
+  it('returns an updated definition for ad-hoc HTTP servers', () => {
+    const updated = maybeEnableOAuth(baseDefinition, logger as never);
+    expect(updated).toBeDefined();
+    expect(updated?.auth).toBe('oauth');
+    expect(updated?.tokenCacheDir).toBeUndefined();
+    expect(logger.info).toHaveBeenCalled();
+  });
+
+  it('enables OAuth for non-ad-hoc HTTP servers (issue #38)', () => {
+    const def: ServerDefinition = {
+      name: 'local-server',
+      command: { kind: 'http', url: new URL('https://example.com') },
+      source: { kind: 'local', path: '/tmp/config.json' },
+    };
+    const updated = maybeEnableOAuth(def, logger as never);
+    expect(updated).toBeDefined();
+    expect(updated?.auth).toBe('oauth');
+  });
+
+  it('does not mutate stdio servers', () => {
+    const def: ServerDefinition = {
+      name: 'stdio-server',
+      command: { kind: 'stdio', command: 'echo', args: [], cwd: process.cwd() },
+    };
+    const updated = maybeEnableOAuth(def, logger as never);
+    expect(updated).toBeUndefined();
+  });
+
+  it('does not re-promote servers already configured for oauth', () => {
+    const def: ServerDefinition = {
+      name: 'oauth-server',
+      auth: 'oauth',
+      command: { kind: 'http', url: new URL('https://example.com') },
+    };
+    const updated = maybeEnableOAuth(def, logger as never);
+    expect(updated).toBeUndefined();
+  });
+});
+
+describe('isUnauthorizedError helper', () => {
+  it('matches UnauthorizedError instances', () => {
+    const err = new UnauthorizedError('Unauthorized');
+    expect(isUnauthorizedError(err)).toBe(true);
+  });
+
+  it('matches generic errors with 401 codes', () => {
+    expect(isUnauthorizedError(new Error('SSE error: Non-200 status code (401)'))).toBe(true);
+  });
+
+  it('ignores unrelated errors', () => {
+    expect(isUnauthorizedError(new Error('network timeout'))).toBe(false);
+  });
+});

package/tests/runtime-oauth-timeout.test.ts

@@ -0,0 +1,60 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { OAuthSession } from '../src/oauth.js';
+import { OAuthTimeoutError, waitForAuthorizationCodeWithTimeout } from '../src/runtime/oauth.js';
+
+describe('waitForAuthorizationCodeWithTimeout', () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('rejects when the authorization code is not received before the timeout', async () => {
+    vi.useFakeTimers();
+    const session: OAuthSession = {
+      provider: {
+        waitForAuthorizationCode: vi.fn(),
+      } as unknown as OAuthSession['provider'],
+      waitForAuthorizationCode: vi.fn(() => new Promise<string>(() => {})),
+      close: vi.fn(async () => {}),
+    };
+    const logger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+
+    const promise = waitForAuthorizationCodeWithTimeout(session, logger, 'fake', 1_000);
+    const expectation = expect(promise).rejects.toBeInstanceOf(OAuthTimeoutError);
+    await vi.advanceTimersByTimeAsync(1_000);
+    await expectation;
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('timed out after 1s'));
+  });
+
+  it('resolves when the authorization code arrives before the timeout', async () => {
+    vi.useFakeTimers();
+    let resolveCode: ((value: string) => void) | undefined;
+    const session: OAuthSession = {
+      provider: {
+        waitForAuthorizationCode: vi.fn(),
+      } as unknown as OAuthSession['provider'],
+      waitForAuthorizationCode: vi.fn(
+        () =>
+          new Promise<string>((resolve) => {
+            resolveCode = resolve;
+          })
+      ),
+      close: vi.fn(async () => {}),
+    };
+    const logger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+
+    const promise = waitForAuthorizationCodeWithTimeout(session, logger, 'fake', 1_000);
+    const expectation = expect(promise).resolves.toBe('abc123');
+    resolveCode?.('abc123');
+    await vi.advanceTimersByTimeAsync(0);
+    await expectation;
+    expect(logger.warn).not.toHaveBeenCalled();
+  });
+});

package/tests/runtime-oauth-utils.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { parseOAuthTimeout } from '../src/runtime/oauth.js';
+
+describe('parseOAuthTimeout', () => {
+  it('falls back to default on missing or invalid values', () => {
+    expect(parseOAuthTimeout(undefined)).toBe(60_000);
+    expect(parseOAuthTimeout('not-a-number')).toBe(60_000);
+    expect(parseOAuthTimeout('-500')).toBe(60_000);
+  });
+
+  it('parses valid integer inputs', () => {
+    expect(parseOAuthTimeout('45000')).toBe(45_000);
+  });
+});

package/tests/runtime-process-utils.test.ts

@@ -0,0 +1,53 @@
+import type { ChildProcess } from 'node:child_process';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const execFileMock = vi.fn();
+
+vi.mock('node:child_process', async () => {
+  const actual = await vi.importActual<typeof import('node:child_process')>('node:child_process');
+  return {
+    ...actual,
+    execFile: execFileMock,
+  };
+});
+
+describe('runtime-process-utils Windows process tree', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    execFileMock.mockReset();
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('win32');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('parses PowerShell output to enumerate descendants', async () => {
+    const { __testHooks } = await import('../src/runtime-process-utils.js');
+    const rootPid = process.pid;
+    const powershellOutput = JSON.stringify([
+      { ProcessId: rootPid + 1, ParentProcessId: rootPid },
+      { ProcessId: rootPid + 2, ParentProcessId: rootPid + 1 },
+      { ProcessId: rootPid + 3, ParentProcessId: 42 },
+    ]);
+
+    execFileMock.mockImplementation((command, _args, options, callback) => {
+      const cb = typeof options === 'function' ? options : callback;
+      if (command === 'powershell.exe') {
+        cb?.(null, powershellOutput, '');
+      } else {
+        cb?.(new Error('unexpected command'));
+      }
+      return { pid: 1 } as ChildProcess;
+    });
+
+    const descendants = await __testHooks.listDescendantPids(rootPid);
+    expect(descendants).toEqual([rootPid + 1, rootPid + 2]);
+    expect(execFileMock).toHaveBeenCalledWith(
+      'powershell.exe',
+      expect.arrayContaining(['-NoProfile', '-Command', expect.stringContaining('Get-CimInstance')]),
+      expect.any(Object),
+      expect.any(Function)
+    );
+  });
+});

package/tests/runtime-transport.test.ts

@@ -0,0 +1,69 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import type { ServerDefinition } from '../src/config.js';
+import { createClientContext } from '../src/runtime/transport.js';
+
+const logger = {
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+};
+
+const clientInfo = { name: 'mcporter', version: '0.0.0-test' };
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function stubHttpDefinition(url: string): ServerDefinition {
+  return {
+    name: 'http-server',
+    command: { kind: 'http', url: new URL(url) },
+    source: { kind: 'local', path: '<adhoc>' },
+  };
+}
+
+describe('createClientContext (HTTP)', () => {
+  it('falls back to SSE when primary connect fails', async () => {
+    const definition = stubHttpDefinition('https://example.com/mcp');
+    const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+    const { SSEClientTransport } = await import('@modelcontextprotocol/sdk/client/sse.js');
+    const { StreamableHTTPClientTransport } = await import('@modelcontextprotocol/sdk/client/streamableHttp.js');
+
+    const clientConnect = vi
+      .spyOn(Client.prototype, 'connect')
+      .mockImplementationOnce(async (transport) => {
+        expect(transport).toBeInstanceOf(StreamableHTTPClientTransport);
+        throw new Error('network down');
+      })
+      .mockImplementationOnce(async (transport) => {
+        expect(transport).toBeInstanceOf(SSEClientTransport);
+      });
+
+    const context = await createClientContext(definition, logger, clientInfo, { maxOAuthAttempts: 0 });
+
+    expect(context.transport).toBeInstanceOf(SSEClientTransport);
+    expect(clientConnect).toHaveBeenCalledTimes(2);
+  });
+
+  it.skip('promotes ad-hoc HTTP servers to OAuth after unauthorized, then retries', async () => {
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(async () => {
+      return new Response(null, { status: 401, statusText: 'Unauthorized' });
+    });
+    const definition = stubHttpDefinition('https://example.com/secure');
+    const { Client } = await import('@modelcontextprotocol/sdk/client/index.js');
+
+    const clientConnect = vi
+      .spyOn(Client.prototype, 'connect')
+      .mockImplementationOnce(async () => {
+        throw new Error('SSE error: Non-200 status code (401)');
+      })
+      .mockImplementationOnce(async () => {});
+
+    const context = await createClientContext(definition, logger, clientInfo, { maxOAuthAttempts: 1 });
+
+    expect(context.definition.auth).toBe('oauth');
+    expect(clientConnect).toHaveBeenCalledTimes(2);
+    fetchSpy.mockRestore();
+  });
+});

package/tests/runtime-utils.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it, vi } from 'vitest';
+import { normalizeTimeout, raceWithTimeout } from '../src/runtime/utils.js';
+
+describe('normalizeTimeout', () => {
+  it('returns undefined for invalid inputs', () => {
+    expect(normalizeTimeout(undefined)).toBeUndefined();
+    expect(normalizeTimeout(Number.NaN)).toBeUndefined();
+    expect(normalizeTimeout(-10)).toBeUndefined();
+    expect(normalizeTimeout(0)).toBeUndefined();
+  });
+
+  it('returns a truncated positive integer', () => {
+    expect(normalizeTimeout(1500.9)).toBe(1500);
+  });
+});
+
+describe('raceWithTimeout', () => {
+  it('resolves when the promise settles before the timeout', async () => {
+    const promise = raceWithTimeout(Promise.resolve('ok'), 1_000);
+    await expect(promise).resolves.toBe('ok');
+  });
+
+  it('rejects with a timeout error when exceeding the deadline', async () => {
+    vi.useFakeTimers();
+    const promise = raceWithTimeout(new Promise<void>(() => {}), 500);
+    const expectation = expect(promise).rejects.toThrowError('Timeout');
+    vi.advanceTimersByTime(500);
+    await expectation;
+    vi.useRealTimers();
+  });
+});

package/tests/runtime.test.ts

@@ -0,0 +1,94 @@
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { loadServerDefinitions } from '../src/config.js';
+import { resolveEnvPlaceholders, resolveEnvValue, withEnvOverrides } from '../src/env.js';
+import { resolveCommandArgument } from '../src/runtime/utils.js';
+
+const FIXTURE_PATH = path.resolve(__dirname, 'fixtures', 'mcporter.json');
+
+describe('loadServerDefinitions', () => {
+  it('parses all Sweetistics servers', async () => {
+    const servers = await loadServerDefinitions({
+      configPath: FIXTURE_PATH,
+      rootDir: '/repo',
+    });
+    expect(servers).toHaveLength(9);
+    const names = servers.map((server) => server.name);
+    expect(names).toContain('vercel');
+    const signoz = servers.find((server) => server.name === 'signoz');
+    expect(signoz).toBeDefined();
+    expect(signoz?.command.kind).toBe('stdio');
+    expect(signoz?.env?.SIGNOZ_URL).toBe(`\${SIGNOZ_URL:-http://localhost:3301}`);
+    const vercel = servers.find((server) => server.name === 'vercel');
+    const normalizedCacheDir = vercel?.tokenCacheDir ? path.normalize(vercel.tokenCacheDir) : undefined;
+    expect(normalizedCacheDir).toBe(path.join(os.homedir(), '.mcporter', 'vercel'));
+  });
+
+  it('resolves HTTP headers with environment placeholders', async () => {
+    process.env.LINEAR_API_KEY = 'linear-secret';
+    const servers = await loadServerDefinitions({ configPath: FIXTURE_PATH });
+    const linear = servers.find((server) => server.name === 'linear');
+    expect(linear?.command.kind).toBe('http');
+    expect(linear?.command.kind === 'http' ? linear.command.headers?.Authorization : undefined).toBe(
+      `Bearer \${LINEAR_API_KEY}`
+    );
+  });
+});
+
+describe('environment utilities', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it('resolveEnvValue respects default syntax', () => {
+    expect(resolveEnvValue(`\${MISSING_VAR:-fallback}`)).toBe('fallback');
+    process.env.MISSING_VAR = 'present';
+    expect(resolveEnvValue(`\${MISSING_VAR:-fallback}`)).toBe('present');
+  });
+
+  it('resolveEnvPlaceholders enforces presence', () => {
+    process.env.TEST_TOKEN = 'abc';
+    expect(resolveEnvPlaceholders(`Bearer \${TEST_TOKEN}`)).toBe('Bearer abc');
+    expect(() => resolveEnvPlaceholders(`Bearer \${NOT_SET}`)).toThrow();
+  });
+
+  it('withEnvOverrides applies temporary overrides', async () => {
+    delete process.env.SIGNOZ_URL;
+    await withEnvOverrides({ SIGNOZ_URL: `\${SIGNOZ_URL:-http://localhost:3301}` }, async () => {
+      expect(process.env.SIGNOZ_URL).toBe('http://localhost:3301');
+    });
+    expect(process.env.SIGNOZ_URL).toBeUndefined();
+  });
+});
+
+describe('command argument interpolation', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  it('resolves placeholder tokens', () => {
+    process.env.CHROME_DEVTOOLS_URL = 'http://127.0.0.1:5555';
+    const placeholder = String.raw`\${CHROME_DEVTOOLS_URL}`;
+    const result = resolveCommandArgument(`--browserUrl ${placeholder}`);
+    expect(result).toBe('--browserUrl http://127.0.0.1:5555');
+  });
+
+  it('passes through tokens without placeholders', () => {
+    const value = '--browserUrl';
+    const result = resolveCommandArgument(value);
+    expect(result).toBe(value);
+  });
+});

package/tests/sdk-patches.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { evaluateStdioLogPolicy, type StdioLogMode } from '../src/sdk-patches.js';
+
+function evaluate(mode: StdioLogMode, hasStderr: boolean, exitCode: number | null) {
+  return evaluateStdioLogPolicy(mode, hasStderr, exitCode);
+}
+
+describe('sdk-patches STDIO log policy', () => {
+  it('prints logs in auto mode only when stderr exists and exit code is non-zero', () => {
+    expect(evaluate('auto', true, 1)).toBe(true);
+    expect(evaluate('auto', true, 0)).toBe(false);
+    expect(evaluate('auto', false, 1)).toBe(false);
+  });
+
+  it('always prints when mode is forced to always', () => {
+    expect(evaluate('always', true, 0)).toBe(true);
+    expect(evaluate('always', true, null)).toBe(true);
+  });
+
+  it('never prints when mode is silent', () => {
+    expect(evaluate('silent', true, 2)).toBe(false);
+    expect(evaluate('silent', true, null)).toBe(false);
+  });
+});