@nimrobo/mcporter-remote 0.1.0

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

@@ -0,0 +1,371 @@
+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 { handleConfigCli } from '../src/cli/config-command.js';
+import type { LoadConfigOptions } from '../src/config.js';
+import { MCPORTER_VERSION } from '../src/runtime.js';
+
+describe('mcporter config CLI', () => {
+  let tempDir: string;
+  let configPath: string;
+  let originalXdg: string | undefined;
+
+  beforeEach(async () => {
+    originalXdg = process.env.XDG_CONFIG_HOME;
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-'));
+    configPath = path.join(tempDir, 'config', 'mcporter.json');
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+    process.env.XDG_CONFIG_HOME = originalXdg;
+    vi.restoreAllMocks();
+  });
+
+  it('adds an HTTP server via positional target', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    const buffer = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    const linear = parsed.mcpServers.linear;
+    expect(linear).toBeDefined();
+    expect(linear?.baseUrl).toBe('https://linear.app/mcp');
+  });
+
+  it('lists servers in JSON format', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['list', '--json']);
+    spy.mockRestore();
+    const jsonLine = logs.find((entry) => entry.trimStart().startsWith('{')) ?? '{}';
+    const payload = JSON.parse(jsonLine.trim()) as { servers: Array<{ name: string }> };
+    expect(payload.servers).toHaveLength(1);
+    expect(payload.servers[0]?.name).toBe('linear');
+  });
+
+  it('prints config summary for text list output', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['list']);
+    spy.mockRestore();
+    expect(logs.some((entry) => entry.includes('Project config:'))).toBe(true);
+    expect(logs.some((entry) => entry.includes('System config:'))).toBe(true);
+  });
+
+  it('removes an existing server', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    await handleConfigCli(buildOptions({ configPath }), ['remove', 'linear']);
+    const buffer = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, unknown> };
+    expect(parsed.mcpServers.linear).toBeUndefined();
+  });
+
+  it('copies imported entries when requested', async () => {
+    const cursorDir = path.join(tempDir, '.cursor');
+    await fs.mkdir(cursorDir, { recursive: true });
+    const importPath = path.join(cursorDir, 'mcp.json');
+    await fs.writeFile(
+      importPath,
+      JSON.stringify({
+        mcpServers: {
+          'cursor-only': {
+            description: 'from cursor',
+            baseUrl: 'https://cursor.example/mcp',
+          },
+        },
+      }),
+      'utf8'
+    );
+
+    await handleConfigCli(buildOptions({ configPath, rootDir: tempDir }), [
+      'import',
+      'cursor',
+      '--copy',
+      '--filter',
+      'cursor-only',
+    ]);
+    const buffer = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    const cursorOnly = parsed.mcpServers['cursor-only'];
+    expect(cursorOnly).toBeDefined();
+    expect(cursorOnly?.baseUrl).toBe('https://cursor.example/mcp');
+  });
+  it('rejects stdio args without a command target', async () => {
+    await expect(handleConfigCli(buildOptions({ configPath }), ['add', 'broken', '--arg', 'foo'])).rejects.toThrow(
+      '--arg requires a stdio command'
+    );
+  });
+
+  it('keeps project-scoped imports ahead of user-scoped ones when copying', async () => {
+    const cursorProjectDir = path.join(tempDir, '.cursor');
+    await fs.mkdir(cursorProjectDir, { recursive: true });
+    const projectConfigPath = path.join(cursorProjectDir, 'mcp.json');
+    await fs.writeFile(
+      projectConfigPath,
+      JSON.stringify({
+        mcpServers: {
+          shared: { baseUrl: 'https://project.example/mcp' },
+        },
+      }),
+      'utf8'
+    );
+
+    const xdgRoot = path.join(tempDir, 'xdg');
+    process.env.XDG_CONFIG_HOME = xdgRoot;
+    const cursorUserPath = path.join(xdgRoot, 'Cursor');
+    await fs.mkdir(cursorUserPath, { recursive: true });
+    const userConfigPath = path.join(cursorUserPath, 'mcp.json');
+    await fs.writeFile(
+      userConfigPath,
+      JSON.stringify({
+        mcpServers: {
+          shared: { baseUrl: 'https://user.example/mcp' },
+        },
+      }),
+      'utf8'
+    );
+
+    await handleConfigCli(buildOptions({ configPath, rootDir: tempDir }), [
+      'import',
+      'cursor',
+      '--copy',
+      '--filter',
+      'shared',
+    ]);
+
+    const buffer = await fs.readFile(configPath, 'utf8');
+    const parsed = JSON.parse(buffer) as { mcpServers: Record<string, { baseUrl: string }> };
+    const shared = parsed.mcpServers.shared;
+    expect(shared).toBeDefined();
+    expect(shared?.baseUrl).toBe('https://project.example/mcp');
+  });
+
+  it('delegates login to the auth handler', async () => {
+    const invokeAuth = vi.fn().mockResolvedValue(undefined);
+    await handleConfigCli(buildOptions({ configPath }, { invokeAuth }), ['login', 'linear']);
+    expect(invokeAuth).toHaveBeenCalledWith(['linear']);
+  });
+
+  it('clears cached credentials on logout', async () => {
+    const tokenDir = path.join(tempDir, 'token-cache');
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(
+      configPath,
+      JSON.stringify({
+        mcpServers: {
+          linear: {
+            baseUrl: 'https://linear.app/mcp',
+            auth: 'oauth',
+            tokenCacheDir: tokenDir,
+          },
+        },
+      }),
+      'utf8'
+    );
+    await fs.mkdir(tokenDir, { recursive: true });
+    await fs.writeFile(path.join(tokenDir, 'token.json'), '{}', 'utf8');
+    await handleConfigCli(buildOptions({ configPath }), ['logout', 'linear']);
+    await expect(fs.access(tokenDir)).rejects.toThrow();
+  });
+
+  it('reports a clean config via doctor', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['doctor']);
+    spy.mockRestore();
+    expect(logs[0]).toBe(`MCPorter ${MCPORTER_VERSION}`);
+    expect(logs[1]).toMatch(/^Project config:/);
+    expect(logs[2]).toMatch(/^System config:/);
+    expect(logs[3]).toBe('');
+    expect(logs[4]).toBe('Config looks good.');
+  });
+
+  it('prints config locations before doctor issues', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'stdio-server', '--command', 'node --version']);
+    const absoluteSpy = vi.spyOn(path, 'isAbsolute').mockReturnValue(false);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['doctor']);
+    absoluteSpy.mockRestore();
+    spy.mockRestore();
+    expect(logs[0]).toBe(`MCPorter ${MCPORTER_VERSION}`);
+    expect(logs[1]).toMatch(/^Project config:/);
+    expect(logs[2]).toMatch(/^System config:/);
+    expect(logs[4]).toBe('Config issues detected:');
+    expect(logs[5]).toMatch(/non-absolute working directory/);
+  });
+
+  it('prints inline help for subcommands via --help', async () => {
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['add', '--help']);
+    spy.mockRestore();
+    const output = logs.join('\n');
+    expect(output).toContain('mcporter config add');
+    expect(output).toContain('Usage');
+    expect(output).toContain('--url <https://host>');
+  });
+
+  it('prints help for named subcommands via config help', async () => {
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['help', 'list']);
+    spy.mockRestore();
+    const output = logs.join('\n');
+    expect(output).toContain('mcporter config list');
+    expect(output).toContain('--source <local|import>');
+  });
+
+  it('warns when requesting help for unknown subcommands', async () => {
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['help', 'bogus']);
+    spy.mockRestore();
+    expect(logs.join('\n')).toContain("Unknown config subcommand 'bogus'");
+  });
+
+  it('lists only local entries by default and summarizes imports', async () => {
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, 'xdg-home');
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify({ mcpServers: {}, imports: ['cursor'] }), 'utf8');
+    const cursorDir = path.join(tempDir, '.cursor');
+    await fs.mkdir(cursorDir, { recursive: true });
+    const importPath = path.join(cursorDir, 'mcp.json');
+    await fs.writeFile(
+      importPath,
+      JSON.stringify({
+        mcpServers: {
+          'cursor-only': { baseUrl: 'https://cursor.example/mcp' },
+        },
+      }),
+      'utf8'
+    );
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath, rootDir: tempDir }), ['list']);
+    spy.mockRestore();
+    const output = logs.join('\n');
+    expect(output).toContain('No local servers match');
+    expect(output).toContain('Other sources available via --source import');
+    const cursorPathPattern = /\.cursor[\\/]mcp\.json/;
+    expect(output).toMatch(cursorPathPattern);
+    expect(output).toContain('cursor-only');
+  });
+
+  it('lists import entries when --source import is provided', async () => {
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, 'xdg-home');
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify({ mcpServers: {}, imports: ['cursor'] }), 'utf8');
+    const cursorDir = path.join(tempDir, '.cursor');
+    await fs.mkdir(cursorDir, { recursive: true });
+    const importPath = path.join(cursorDir, 'mcp.json');
+    await fs.writeFile(
+      importPath,
+      JSON.stringify({
+        mcpServers: {
+          'cursor-only': { baseUrl: 'https://cursor.example/mcp' },
+        },
+      }),
+      'utf8'
+    );
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath, rootDir: tempDir }), ['list', '--json', '--source', 'import']);
+    spy.mockRestore();
+    const jsonLine = logs.find((entry) => entry.trimStart().startsWith('{')) ?? '{}';
+    const payload = JSON.parse(jsonLine.trim()) as { servers: Array<{ name: string }> };
+    expect(payload.servers.some((server) => server.name === 'cursor-only')).toBe(true);
+  });
+
+  it('filters list output by source', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['list', '--json', '--source', 'local']);
+    spy.mockRestore();
+    const jsonLine = logs.find((entry) => entry.trimStart().startsWith('{')) ?? '{}';
+    const payload = JSON.parse(jsonLine.trim()) as { servers: Array<{ name: string }> };
+    expect(payload.servers).toHaveLength(1);
+    expect(payload.servers[0]?.name).toBe('linear');
+  });
+
+  it('prints server details via get --json', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'linear', 'https://linear.app/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['get', 'linear', '--json']);
+    spy.mockRestore();
+    const payload = JSON.parse(logs.join('\n')) as { name: string; baseUrl: string };
+    expect(payload.name).toBe('linear');
+    expect(payload.baseUrl).toBe('https://linear.app/mcp');
+  });
+
+  it('auto-corrects server names when using get', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'shadcn', 'https://shadcn.io/api/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await handleConfigCli(buildOptions({ configPath }), ['get', 'sshadcn', '--json']);
+    spy.mockRestore();
+    const output = logs.join('\n');
+    expect(output).toContain('Auto-corrected server name to shadcn');
+  });
+
+  it('suggests close matches when get cannot auto-correct', async () => {
+    await handleConfigCli(buildOptions({ configPath }), ['add', 'shadcn', 'https://shadcn.io/api/mcp']);
+    const logs: string[] = [];
+    const spy = vi.spyOn(console, 'log').mockImplementation(captureLog(logs));
+    await expect(handleConfigCli(buildOptions({ configPath }), ['get', 'shadowverse'])).rejects.toThrow(
+      "[mcporter] Unknown server 'shadowverse'."
+    );
+    spy.mockRestore();
+    expect(logs.join('\n')).toContain('Did you mean shadcn');
+  });
+});
+
+function captureLog(target: string[]): (message?: unknown) => void {
+  return (message?: unknown) => {
+    if (typeof message === 'string') {
+      target.push(message);
+      return;
+    }
+    if (message == null) {
+      target.push('');
+      return;
+    }
+    if (typeof message === 'object') {
+      try {
+        target.push(JSON.stringify(message));
+        return;
+      } catch {
+        target.push('[object]');
+        return;
+      }
+    }
+    if (typeof message === 'number' || typeof message === 'boolean' || typeof message === 'bigint') {
+      target.push(String(message));
+      return;
+    }
+    if (typeof message === 'symbol') {
+      target.push(String(message));
+      return;
+    }
+    if (typeof message === 'function') {
+      target.push('[function]');
+      return;
+    }
+    target.push('');
+  };
+}
+
+function buildOptions(
+  loadOptions: LoadConfigOptions,
+  overrides?: Partial<{ invokeAuth: (args: string[]) => Promise<void> }>
+): { loadOptions: LoadConfigOptions; invokeAuth: (args: string[]) => Promise<void> } {
+  return {
+    loadOptions,
+    invokeAuth: overrides?.invokeAuth ?? (async () => {}),
+  };
+}

package/tests/cli-config-fallback.test.ts

@@ -0,0 +1,259 @@
+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 { MCPORTER_VERSION } from '../src/runtime.js';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+const cliModulePromise = import('../src/cli.js');
+
+describe('mcporter CLI config fallback', () => {
+  let tempDir: string;
+  let originalCwd: string;
+  let previousNoForceExit: string | undefined;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-cli-config-'));
+    process.chdir(tempDir);
+    previousNoForceExit = process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+  });
+
+  afterEach(async () => {
+    process.chdir(originalCwd);
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    process.exitCode = undefined;
+    if (previousNoForceExit === undefined) {
+      delete process.env.MCPORTER_NO_FORCE_EXIT;
+    } else {
+      process.env.MCPORTER_NO_FORCE_EXIT = previousNoForceExit;
+    }
+  });
+
+  it('lists servers even when the config directory is missing', async () => {
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(runCli(['config', 'list'])).resolves.not.toThrow();
+    expect(warnSpy).not.toHaveBeenCalled();
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('warns once and continues when the default config is corrupt', async () => {
+    const { runCli } = await cliModulePromise;
+    await fs.mkdir(path.join(tempDir, 'config'), { recursive: true });
+    const configPath = path.join(tempDir, 'config', 'mcporter.json');
+    await fs.writeFile(configPath, '{ invalid : json', 'utf8');
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(runCli(['config', 'list'])).resolves.not.toThrow();
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    const message = warnSpy.mock.calls[0]?.[0]?.toString() ?? '';
+    expect(message).toContain('Ignoring config');
+    expect(message).toContain(configPath);
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('prints the doctor banner even when config is missing', async () => {
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(runCli(['config', 'doctor'])).resolves.not.toThrow();
+    expect(logs[0]).toBe(`MCPorter ${MCPORTER_VERSION}`);
+    expect(warnSpy).not.toHaveBeenCalled();
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('doctor warns once and keeps running when the config is corrupt', async () => {
+    const { runCli } = await cliModulePromise;
+    await fs.mkdir(path.join(tempDir, 'config'), { recursive: true });
+    const configPath = path.join(tempDir, 'config', 'mcporter.json');
+    await fs.writeFile(configPath, '{ not valid }', 'utf8');
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    await expect(runCli(['config', 'doctor'])).resolves.not.toThrow();
+    expect(logs[0]).toBe(`MCPorter ${MCPORTER_VERSION}`);
+    expect(warnSpy).toHaveBeenCalledTimes(1);
+    expect(warnSpy.mock.calls[0]?.[0]).toContain(configPath);
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+});
+
+describe('mcporter CLI with completely empty environment (ENOENT regression)', () => {
+  let tempDir: string;
+  let originalCwd: string;
+  let previousNoForceExit: string | undefined;
+  let homedirSpy: { mockRestore(): void } | undefined;
+  let previousEnv: Record<string, string | undefined> = {};
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    // Create a completely empty temp directory - no config files anywhere
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-cli-empty-env-'));
+    process.chdir(tempDir);
+    previousNoForceExit = process.env.MCPORTER_NO_FORCE_EXIT;
+    process.env.MCPORTER_NO_FORCE_EXIT = '1';
+    // Mock homedir to an empty directory to ensure no home config exists
+    homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(tempDir);
+    // Save and override env vars that could point to config files
+    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 = tempDir;
+    process.env.USERPROFILE = tempDir;
+    process.env.APPDATA = path.join(tempDir, 'AppData', 'Roaming');
+    process.env.XDG_CONFIG_HOME = path.join(tempDir, '.config');
+    delete process.env.MCPORTER_CONFIG;
+  });
+
+  afterEach(async () => {
+    homedirSpy?.mockRestore();
+    process.chdir(originalCwd);
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    process.exitCode = undefined;
+    if (previousNoForceExit === undefined) {
+      delete process.env.MCPORTER_NO_FORCE_EXIT;
+    } else {
+      process.env.MCPORTER_NO_FORCE_EXIT = previousNoForceExit;
+    }
+    // Restore env vars
+    for (const [key, value] of Object.entries(previousEnv)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  it('list command succeeds with no config files anywhere (regression test)', async () => {
+    // This is the key regression test: before the fix, this would crash with:
+    // ENOENT: no such file or directory, open '.../config/mcporter.json'
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    // This should NOT throw - it should gracefully handle missing config
+    await expect(runCli(['list'])).resolves.not.toThrow();
+
+    // Should not have any warnings about missing config (since it's optional)
+    expect(warnSpy).not.toHaveBeenCalled();
+    // Should show "No MCP servers configured" or similar empty state
+    const output = logs.join('\n');
+    expect(output).toContain('No MCP servers configured');
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  it('list --json succeeds with no config files anywhere', async () => {
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await expect(runCli(['list', '--json'])).resolves.not.toThrow();
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    // Should output valid JSON with empty servers array
+    const jsonOutput = JSON.parse(logs[logs.length - 1] ?? '{}');
+    expect(jsonOutput).toHaveProperty('servers');
+    expect(jsonOutput.servers).toEqual([]);
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('config list succeeds with no config files anywhere', async () => {
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await expect(runCli(['config', 'list'])).resolves.not.toThrow();
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('config doctor succeeds with no config files anywhere', async () => {
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await expect(runCli(['config', 'doctor'])).resolves.not.toThrow();
+    expect(logs[0]).toBe(`MCPorter ${MCPORTER_VERSION}`);
+    expect(warnSpy).not.toHaveBeenCalled();
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+
+  it('daemon start no-ops gracefully with no config files anywhere', async () => {
+    const { runCli } = await cliModulePromise;
+    const logs: string[] = [];
+    const logSpy = vi.spyOn(console, 'log').mockImplementation((value?: unknown) => {
+      if (typeof value === 'string') {
+        logs.push(value);
+      }
+    });
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await expect(runCli(['daemon', 'start'])).resolves.not.toThrow();
+    expect(warnSpy).not.toHaveBeenCalled();
+    expect(logs.join('\n')).toContain('No MCP servers are configured for keep-alive; daemon not started.');
+
+    logSpy.mockRestore();
+    warnSpy.mockRestore();
+  });
+});

package/tests/cli-config-routing.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it, vi } from 'vitest';
+
+process.env.MCPORTER_DISABLE_AUTORUN = '1';
+
+vi.mock('../src/cli/config-command.js', async () => {
+  const actual = await vi.importActual<typeof import('../src/cli/config-command.js')>('../src/cli/config-command.js');
+  return {
+    ...actual,
+    handleConfigCli: vi.fn().mockResolvedValue(undefined),
+  };
+});
+
+describe('mcporter config entrypoint', () => {
+  it('routes to the config handler before runtime inference', async () => {
+    const { runCli } = await import('../src/cli.js');
+    const { handleConfigCli } = await import('../src/cli/config-command.js');
+    await runCli(['config']);
+    expect(handleConfigCli).toHaveBeenCalledTimes(1);
+  });
+});