@nimrobo/mcporter-remote 0.1.0

package/tests/config-add-flags.test.ts

@@ -0,0 +1,61 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleAddCommand } from '../src/cli/config/add.js';
+import type { LoadConfigOptions } from '../src/config.js';
+import { createTempConfig } from './fixtures/config-fixture.js';
+
+describe('config add flag parsing', () => {
+  let loadOptions: LoadConfigOptions;
+  let cleanup: (() => Promise<void>) | undefined;
+
+  beforeEach(async () => {
+    const ctx = await createTempConfig();
+    loadOptions = ctx.loadOptions;
+    cleanup = () => ctx.cleanup();
+  });
+
+  afterEach(async () => {
+    if (cleanup) {
+      await cleanup();
+      cleanup = undefined;
+    }
+    vi.restoreAllMocks();
+  });
+
+  it('merges env, headers, description and auth metadata, and respects dry-run', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleAddCommand({ loadOptions } as never, [
+      'example',
+      'https://api.example.com/mcp',
+      '--env',
+      'FOO=bar',
+      '--header',
+      'X-Test=1',
+      '--description',
+      'desc',
+      '--auth',
+      'oauth',
+      '--client-name',
+      'mcporter',
+      '--oauth-redirect-url',
+      'https://example.com/callback',
+      '--dry-run',
+    ]);
+
+    const payloadLine = logSpy.mock.calls
+      .map((call) => call[0])
+      .find((msg) => typeof msg === 'string' && msg.trim().startsWith('{'));
+    logSpy.mockRestore();
+
+    expect(payloadLine).toBeDefined();
+    const payload = JSON.parse(String(payloadLine)) as Record<string, unknown>;
+    const entry = payload.example as Record<string, unknown>;
+    expect(entry.baseUrl).toBe('https://api.example.com/mcp');
+    expect(entry.env).toEqual({ FOO: 'bar' });
+    expect(entry.headers).toEqual({ 'X-Test': '1' });
+    expect(entry.description).toBe('desc');
+    expect(entry.auth).toBe('oauth');
+    expect(entry.clientName).toBe('mcporter');
+    expect(entry.oauthRedirectUrl).toBe('https://example.com/callback');
+  });
+});

package/tests/config-add-imports.test.ts

@@ -0,0 +1,28 @@
+import fs from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+import { handleAddCommand } from '../src/cli/config/add.js';
+import { createTempConfig } from './fixtures/config-fixture.js';
+
+describe('config add imports preservation', () => {
+  it('keeps imports undefined when config omits the key', async () => {
+    const ctx = await createTempConfig({ mcpServers: {} });
+
+    await handleAddCommand({ loadOptions: ctx.loadOptions } as never, ['local', 'https://local.example/mcp']);
+
+    const buffer = await fs.readFile(ctx.configPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { imports?: string[] };
+    expect(Object.hasOwn(parsed, 'imports')).toBe(false);
+    await ctx.cleanup();
+  });
+
+  it('keeps imports undefined when creating a new config file', async () => {
+    const ctx = await createTempConfig();
+
+    await handleAddCommand({ loadOptions: ctx.loadOptions } as never, ['fresh', 'https://fresh.example/mcp']);
+
+    const buffer = await fs.readFile(ctx.configPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { imports?: string[] };
+    expect(Object.hasOwn(parsed, 'imports')).toBe(false);
+    await ctx.cleanup();
+  });
+});

package/tests/config-add-persist.test.ts

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { handleAddCommand } from '../src/cli/config/add.js';
+import { createTempConfig } from './fixtures/config-fixture.js';
+
+describe('config add persist and scope', () => {
+  it('writes to custom persist path when provided', async () => {
+    const ctx = await createTempConfig();
+    const persistPath = path.join(ctx.tempDir, 'custom', 'mcporter.json');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleAddCommand({ loadOptions: ctx.loadOptions } as never, [
+      'persisted',
+      'https://persist.example/mcp',
+      '--persist',
+      persistPath,
+    ]);
+
+    logSpy.mockRestore();
+    const buffer = await fs.readFile(persistPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    expect(parsed.mcpServers.persisted).toBeDefined();
+    expect(parsed.mcpServers.persisted?.baseUrl).toBe('https://persist.example/mcp');
+    await ctx.cleanup();
+  });
+});

package/tests/config-add-scope-behavior.test.ts

@@ -0,0 +1,46 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleAddCommand } from '../src/cli/config/add.js';
+import type { LoadConfigOptions } from '../src/config.js';
+
+describe('config add scope behavior', () => {
+  let projectDir: string;
+  let homeDir: string;
+  let loadOptions: LoadConfigOptions;
+  let restoreHomedir: (() => void) | undefined;
+
+  beforeEach(async () => {
+    projectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-add-scope-project-'));
+    homeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-add-scope-home-'));
+    loadOptions = { rootDir: projectDir };
+    const spy = vi.spyOn(os, 'homedir').mockReturnValue(homeDir);
+    restoreHomedir = () => spy.mockRestore();
+  });
+
+  afterEach(async () => {
+    restoreHomedir?.();
+    restoreHomedir = undefined;
+    await fs.rm(projectDir, { recursive: true, force: true });
+    await fs.rm(homeDir, { recursive: true, force: true });
+  });
+
+  it('writes to home config when scope=home', async () => {
+    await handleAddCommand({ loadOptions } as never, ['homescope', 'https://home.example/mcp', '--scope', 'home']);
+    const homeConfigPath = path.join(homeDir, '.mcporter', 'mcporter.json');
+    const buffer = await fs.readFile(homeConfigPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    expect(parsed.mcpServers.homescope).toBeDefined();
+    expect(parsed.mcpServers.homescope?.baseUrl).toBe('https://home.example/mcp');
+  });
+
+  it('writes to project config when scope=project', async () => {
+    await handleAddCommand({ loadOptions } as never, ['projects', 'https://project.example/mcp', '--scope', 'project']);
+    const projectConfigPath = path.join(projectDir, 'config', 'mcporter.json');
+    const buffer = await fs.readFile(projectConfigPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    expect(parsed.mcpServers.projects).toBeDefined();
+    expect(parsed.mcpServers.projects?.baseUrl).toBe('https://project.example/mcp');
+  });
+});

package/tests/config-add-scope.test.ts

@@ -0,0 +1,101 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { __configCommandInternals } from '../src/cli/config-command.js';
+import type { LoadConfigOptions } from '../src/config.js';
+
+describe('config add --scope targeting', () => {
+  let tempHomeDir: string | undefined;
+  let tempProjectDir: string | undefined;
+  let homedirSpy: { mockRestore(): void } | undefined;
+  let previousEnv: Record<string, string | undefined> = {};
+
+  beforeEach(async () => {
+    tempHomeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-scope-home-'));
+    tempProjectDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-scope-project-'));
+    homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(tempHomeDir);
+    previousEnv = {
+      HOME: process.env.HOME,
+      USERPROFILE: process.env.USERPROFILE,
+      APPDATA: process.env.APPDATA,
+      XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
+      MCPORTER_CONFIG: process.env.MCPORTER_CONFIG,
+    };
+    process.env.HOME = tempHomeDir;
+    process.env.USERPROFILE = tempHomeDir;
+    process.env.APPDATA = path.join(tempHomeDir, 'AppData', 'Roaming');
+    process.env.XDG_CONFIG_HOME = path.join(tempHomeDir, '.config');
+    delete process.env.MCPORTER_CONFIG;
+  });
+
+  afterEach(async () => {
+    homedirSpy?.mockRestore();
+    homedirSpy = undefined;
+    for (const key of Object.keys(previousEnv)) {
+      const typedKey = key as keyof typeof previousEnv;
+      const value = previousEnv[typedKey];
+      if (value === undefined) {
+        delete process.env[typedKey];
+      } else {
+        process.env[typedKey] = value;
+      }
+    }
+    if (tempHomeDir) {
+      await fs.rm(tempHomeDir, { recursive: true, force: true }).catch(() => {});
+      tempHomeDir = undefined;
+    }
+    if (tempProjectDir) {
+      await fs.rm(tempProjectDir, { recursive: true, force: true }).catch(() => {});
+      tempProjectDir = undefined;
+    }
+  });
+
+  it('writes to home when scope=home', () => {
+    const projectDir =
+      tempProjectDir ??
+      (() => {
+        throw new Error('tempProjectDir missing');
+      })();
+    const homeDir =
+      tempHomeDir ??
+      (() => {
+        throw new Error('tempHomeDir missing');
+      })();
+    const target = __configCommandInternals.resolveWriteTarget(
+      { args: [], env: {}, headers: {}, scope: 'home' },
+      {},
+      projectDir
+    );
+    expect(target).toBe(path.join(homeDir, '.mcporter', 'mcporter.json'));
+  });
+
+  it('writes to project when scope=project', () => {
+    const projectDir =
+      tempProjectDir ??
+      (() => {
+        throw new Error('tempProjectDir missing');
+      })();
+    const target = __configCommandInternals.resolveWriteTarget(
+      { args: [], env: {}, headers: {}, scope: 'project' },
+      {},
+      projectDir
+    );
+    expect(target).toBe(path.join(projectDir, 'config', 'mcporter.json'));
+  });
+
+  it('defaults to resolved path when no scope provided', () => {
+    const projectDir =
+      tempProjectDir ??
+      (() => {
+        throw new Error('tempProjectDir missing');
+      })();
+    const loadOptions: LoadConfigOptions = { rootDir: projectDir }; // no config yet
+    const target = __configCommandInternals.resolveWriteTarget(
+      { args: [], env: {}, headers: {} },
+      loadOptions,
+      projectDir
+    );
+    expect(target).toBe(path.join(projectDir, 'config', 'mcporter.json'));
+  });
+});

package/tests/config-add-sse.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleAddCommand } from '../src/cli/config/add.js';
+import { createTempConfig } from './fixtures/config-fixture.js';
+
+describe('config add with sse transport', () => {
+  it('accepts sse transport when url is provided', async () => {
+    const ctx = await createTempConfig();
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleAddCommand({ loadOptions: ctx.loadOptions } as never, [
+      'sse-server',
+      'https://sse.example/mcp',
+      '--transport',
+      'sse',
+      '--dry-run',
+    ]);
+
+    logSpy.mockRestore();
+    await ctx.cleanup();
+    // If no error thrown, transport validation succeeded. Ensure dry-run printed payload.
+    expect(true).toBe(true);
+  });
+});

package/tests/config-command-string.test.ts

@@ -0,0 +1,96 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { loadServerDefinitions } from '../src/config.js';
+
+const TMP_PREFIX = path.join(os.tmpdir(), 'mcporter-command-');
+
+let tmpDir: string | undefined;
+
+afterEach(async () => {
+  if (tmpDir) {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+    tmpDir = undefined;
+  }
+});
+
+describe('command string parsing', () => {
+  it('splits whitespace-delimited command strings into executable + args', async () => {
+    tmpDir = await fs.mkdtemp(TMP_PREFIX);
+    const configDir = path.join(tmpDir, 'config');
+    await fs.mkdir(configDir, { recursive: true });
+    const configPath = path.join(configDir, 'mcporter.json');
+    await fs.writeFile(
+      configPath,
+      JSON.stringify({
+        mcpServers: {
+          xcodebuild: {
+            description: 'test server',
+            command: 'npx -y xcodebuildmcp@latest',
+          },
+        },
+        imports: [],
+      })
+    );
+
+    const servers = await loadServerDefinitions({
+      configPath,
+      rootDir: tmpDir,
+    });
+
+    expect(servers).toHaveLength(1);
+    const server = servers[0];
+    if (!server) {
+      throw new Error('expected server definition');
+    }
+    expect(server.command.kind).toBe('stdio');
+    if (server.command.kind !== 'stdio') {
+      throw new Error('expected stdio command');
+    }
+    expect(server.command.command).toBe('npx');
+    expect(server.command.args).toEqual(['-y', 'xcodebuildmcp@latest']);
+    expect(server.source).toEqual({
+      kind: 'local',
+      path: configPath,
+    });
+  });
+
+  it('respects quoted segments inside command strings', async () => {
+    tmpDir = await fs.mkdtemp(TMP_PREFIX);
+    const configDir = path.join(tmpDir, 'config');
+    await fs.mkdir(configDir, { recursive: true });
+    const configPath = path.join(configDir, 'mcporter.json');
+    await fs.writeFile(
+      configPath,
+      JSON.stringify({
+        mcpServers: {
+          bash: {
+            command: 'bash -lc "echo \'hello world\'"',
+          },
+        },
+        imports: [],
+      })
+    );
+
+    const servers = await loadServerDefinitions({
+      configPath,
+      rootDir: tmpDir,
+    });
+
+    const server = servers[0];
+    if (!server) {
+      throw new Error('expected server definition');
+    }
+    expect(server.command.kind).toBe('stdio');
+    if (server.command.kind !== 'stdio') {
+      throw new Error('expected stdio command');
+    }
+    expect(server.command.command).toBe('bash');
+    expect(server.command.args).toEqual(['-lc', "echo 'hello world'"]);
+    expect(server.source).toEqual({
+      kind: 'local',
+      path: configPath,
+    });
+  });
+});

package/tests/config-doctor.test.ts

@@ -0,0 +1,45 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleDoctorCommand } from '../src/cli/config/doctor.js';
+import type { LoadConfigOptions } from '../src/config.js';
+import * as configModule from '../src/config.js';
+
+let tempDir: string;
+let loadOptions: LoadConfigOptions;
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-doctor-'));
+  loadOptions = { rootDir: tempDir };
+});
+
+afterEach(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+describe('config doctor', () => {
+  it('reports issues for stdio cwd and missing oauth token cache', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(configModule, 'loadServerDefinitions').mockResolvedValue([
+      {
+        name: 'bad-stdio',
+        command: { kind: 'stdio', command: 'node', args: [], cwd: 'relative/path' },
+      },
+      {
+        name: 'oauth-missing-cache',
+        command: { kind: 'http', url: new URL('https://example.com/mcp'), headers: {} },
+        auth: 'oauth',
+        tokenCacheDir: undefined,
+      },
+    ]);
+
+    await handleDoctorCommand({ loadOptions } as never, []);
+
+    const output = logSpy.mock.calls.flat().join('\n');
+    logSpy.mockRestore();
+
+    expect(output).toContain('has a non-absolute working directory');
+  });
+});

package/tests/config-get-json.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it, vi } from 'vitest';
+import { handleGetCommand } from '../src/cli/config/get.js';
+import * as configModule from '../src/config.js';
+import type { ServerDefinition } from '../src/config-schema.js';
+
+describe('config get --json', () => {
+  it('includes headers and env in JSON output', async () => {
+    const server: ServerDefinition = {
+      name: 'http-one',
+      command: { kind: 'http', url: new URL('https://api.example/mcp'), headers: { Authorization: 'Bearer token' } },
+      env: { FOO: 'bar' },
+    };
+    vi.spyOn(configModule, 'loadServerDefinitions').mockResolvedValue([server]);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleGetCommand({ loadOptions: {} } as never, ['http-one', '--json']);
+
+    const output = logSpy.mock.calls.map((call) => call[0]).join('\n');
+    logSpy.mockRestore();
+    const payload = JSON.parse(output) as { headers?: Record<string, string>; env?: Record<string, string> };
+    expect(payload.headers?.Authorization).toBe('Bearer token');
+    expect(payload.env?.FOO).toBe('bar');
+  });
+});

package/tests/config-import-dedupe.test.ts

@@ -0,0 +1,27 @@
+import fs from 'node:fs/promises';
+import { describe, expect, it, vi } from 'vitest';
+import { handleImportCommand } from '../src/cli/config/import.js';
+import * as importModule from '../src/config-imports.js';
+import { createTempConfig } from './fixtures/config-fixture.js';
+
+describe('config import deduplication', () => {
+  it('keeps first matching entry when multiple imports share names', async () => {
+    const ctx = await createTempConfig();
+    const firstPath = '/first.json';
+    const secondPath = '/second.json';
+    vi.spyOn(importModule, 'pathsForImport').mockReturnValue([firstPath, secondPath]);
+    vi.spyOn(importModule, 'readExternalEntries')
+      .mockResolvedValueOnce(new Map([['dup', { baseUrl: 'https://first.example/mcp' }]]) as never)
+      .mockResolvedValueOnce(new Map([['dup', { baseUrl: 'https://second.example/mcp' }]]) as never);
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await handleImportCommand({ loadOptions: ctx.loadOptions } as never, ['cursor', '--copy']);
+    logSpy.mockRestore();
+
+    const buffer = await fs.readFile(ctx.loadOptions.configPath ?? '', 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    expect(parsed.mcpServers.dup).toBeDefined();
+    expect(parsed.mcpServers.dup?.baseUrl).toBe('https://first.example/mcp');
+    await ctx.cleanup();
+  });
+});

package/tests/config-import-paths.test.ts

@@ -0,0 +1,49 @@
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { pathsForImport } from '../src/config-imports.js';
+
+describe('pathsForImport on Windows', () => {
+  const homeDir = path.join(os.tmpdir(), 'mcporter-win-home');
+  const appData = path.join(homeDir, 'AppData', 'Roaming');
+
+  beforeEach(() => {
+    vi.spyOn(process, 'platform', 'get').mockReturnValue('win32');
+    vi.spyOn(os, 'homedir').mockReturnValue(homeDir);
+    process.env.HOME = homeDir;
+    process.env.USERPROFILE = homeDir;
+    process.env.APPDATA = appData;
+    process.env.XDG_CONFIG_HOME = '';
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    delete process.env.HOME;
+    delete process.env.USERPROFILE;
+    delete process.env.APPDATA;
+    delete process.env.XDG_CONFIG_HOME;
+  });
+
+  it('includes Windows Cursor directories and workspace override', () => {
+    const rootDir = 'C:/repo';
+    const paths = pathsForImport('cursor', rootDir);
+    expect(paths).toContain(path.resolve(rootDir, '.cursor', 'mcp.json'));
+    expect(paths).toContain(path.join(homeDir, '.cursor', 'mcp.json'));
+    expect(paths).toContain(path.join(appData, 'Cursor', 'User', 'mcp.json'));
+  });
+
+  it('includes Windows windsuf configs across Codeium directories', () => {
+    const rootDir = 'C:/repo';
+    const paths = pathsForImport('windsurf', rootDir);
+    expect(paths).toContain(path.join(appData, 'Codeium', 'windsurf', 'mcp_config.json'));
+    expect(paths).toContain(path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'));
+  });
+
+  it('prefers workspace .vscode/mcp.json before user-level VS Code configs', () => {
+    const rootDir = 'C:/repo';
+    const paths = pathsForImport('vscode', rootDir);
+    expect(paths[0]).toBe(path.resolve(rootDir, '.vscode', 'mcp.json'));
+    expect(paths).toContain(path.join(appData, 'Code', 'User', 'mcp.json'));
+    expect(paths).toContain(path.join(appData, 'Code - Insiders', 'User', 'mcp.json'));
+  });
+});

package/tests/config-import.test.ts

@@ -0,0 +1,64 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleImportCommand } from '../src/cli/config/import.js';
+import type { LoadConfigOptions, RawConfig } from '../src/config.js';
+import * as configModule from '../src/config.js';
+import * as importModule from '../src/config-imports.js';
+
+let tempDir: string;
+let loadOptions: LoadConfigOptions;
+
+beforeEach(async () => {
+  tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-import-'));
+  loadOptions = { rootDir: tempDir };
+});
+
+afterEach(async () => {
+  await fs.rm(tempDir, { recursive: true, force: true });
+  vi.restoreAllMocks();
+});
+
+describe('config import', () => {
+  it('copies filtered entries into project config', async () => {
+    vi.spyOn(importModule, 'pathsForImport').mockReturnValue([path.join(tempDir, 'imports', 'cursor.json')]);
+    vi.spyOn(importModule, 'readExternalEntries').mockResolvedValue(
+      new Map([
+        ['keep', { baseUrl: 'https://example.com/mcp' }],
+        ['skip', { baseUrl: 'https://skip.example/mcp' }],
+      ]) as never
+    );
+
+    let writtenConfig: RawConfig | undefined;
+    vi.spyOn(configModule, 'writeRawConfig').mockImplementation(async (_path, config) => {
+      writtenConfig = config as RawConfig;
+    });
+
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    await handleImportCommand({ loadOptions } as never, ['cursor', '--copy', '--filter', 'keep']);
+    logSpy.mockRestore();
+
+    expect(writtenConfig?.mcpServers?.keep).toBeDefined();
+    expect(writtenConfig?.mcpServers?.skip).toBeUndefined();
+  });
+
+  it('emits JSON when --json is provided', async () => {
+    vi.spyOn(importModule, 'pathsForImport').mockReturnValue([path.join(tempDir, 'imports', 'cursor.json')]);
+    vi.spyOn(importModule, 'readExternalEntries').mockResolvedValue(
+      new Map([['keep', { baseUrl: 'https://example.com/mcp' }]]) as never
+    );
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleImportCommand({ loadOptions } as never, ['cursor', '--json']);
+
+    const json = logSpy.mock.calls
+      .map((call) => call[0])
+      .find((msg) => typeof msg === 'string' && msg.trim().startsWith('{'));
+    logSpy.mockRestore();
+    expect(json).toBeDefined();
+    const payload = JSON.parse(String(json)) as { entries: Array<{ name: string }> };
+    expect(payload.entries).toHaveLength(1);
+    expect(payload.entries[0]?.name).toBe('keep');
+  });
+});