@nimrobo/mcporter-remote 0.1.0

package/tests/config-missing.test.ts

@@ -0,0 +1,140 @@
+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 { loadServerDefinitions } from '../src/config.js';
+
+describe('loadServerDefinitions when config is optional', () => {
+  let tempHomeDir: string | undefined;
+  let homedirSpy: { mockRestore(): void } | undefined;
+  let previousEnv: Record<string, string | undefined> = {};
+
+  beforeEach(async () => {
+    tempHomeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-missing-home-'));
+    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,
+    };
+    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');
+  });
+
+  afterEach(async () => {
+    homedirSpy?.mockRestore();
+    homedirSpy = undefined;
+    process.env.HOME = previousEnv.HOME;
+    process.env.USERPROFILE = previousEnv.USERPROFILE;
+    process.env.APPDATA = previousEnv.APPDATA;
+    process.env.XDG_CONFIG_HOME = previousEnv.XDG_CONFIG_HOME;
+    if (tempHomeDir) {
+      await fs.rm(tempHomeDir, { recursive: true, force: true }).catch(() => {});
+      tempHomeDir = undefined;
+    }
+  });
+
+  it('returns an empty list when the default config is missing', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-missing-'));
+    try {
+      const servers = await loadServerDefinitions({ rootDir: tempDir });
+      expect(servers).toEqual([]);
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  });
+
+  it('returns an empty list when the config directory exists but the file is missing', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-folder-'));
+    try {
+      await fs.mkdir(path.join(tempDir, 'config'), { recursive: true });
+      const servers = await loadServerDefinitions({ rootDir: tempDir });
+      expect(servers).toEqual([]);
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  });
+
+  it('returns an empty list and logs when the config file is invalid JSON', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-invalid-'));
+    const configDir = path.join(tempDir, 'config');
+    await fs.mkdir(configDir, { recursive: true });
+    const configPath = path.join(configDir, 'mcporter.json');
+    await fs.writeFile(configPath, '{ this is not valid JSON', 'utf8');
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    try {
+      const servers = await loadServerDefinitions({ rootDir: tempDir });
+      expect(servers).toEqual([]);
+      expect(warnSpy).toHaveBeenCalledTimes(1);
+      expect(warnSpy.mock.calls[0]?.[0]).toContain('Ignoring config');
+      expect(warnSpy.mock.calls[0]?.[0]).toContain(configPath);
+    } finally {
+      warnSpy.mockRestore();
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  });
+
+  it('still throws when an explicit config path is missing', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-explicit-'));
+    const explicitPath = path.join(tempDir, 'does-not-exist.json');
+    await expect(loadServerDefinitions({ configPath: explicitPath })).rejects.toThrow();
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('loads project config files that contain JSONC comments and trailing commas', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-jsonc-project-'));
+    const configDir = path.join(tempDir, 'config');
+    await fs.mkdir(configDir, { recursive: true });
+    await fs.writeFile(
+      path.join(configDir, 'mcporter.json'),
+      `{
+        // local MCP servers
+        "mcpServers": {
+          "demo": {
+            "command": "node",
+            "args": ["./demo-server.mjs",], // trailing comma
+          },
+        },
+      }`,
+      'utf8'
+    );
+
+    try {
+      const servers = await loadServerDefinitions({ rootDir: tempDir });
+      expect(servers).toHaveLength(1);
+      expect(servers[0]?.name).toBe('demo');
+      expect(servers[0]?.command.kind).toBe('stdio');
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  });
+
+  it('loads explicit .jsonc config files with comments/trailing commas', async () => {
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-jsonc-explicit-'));
+    const explicitPath = path.join(tempDir, 'mcporter.jsonc');
+    await fs.writeFile(
+      explicitPath,
+      `{
+        /* explicit JSONC file */
+        "mcpServers": {
+          "demo-http": {
+            "url": "https://example.com/mcp", // allowed comment
+          },
+        },
+      }`,
+      'utf8'
+    );
+
+    try {
+      const servers = await loadServerDefinitions({ configPath: explicitPath });
+      expect(servers).toHaveLength(1);
+      expect(servers[0]?.name).toBe('demo-http');
+      expect(servers[0]?.command.kind).toBe('http');
+    } finally {
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  });
+});

package/tests/config-normalize.test.ts

@@ -0,0 +1,71 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { loadServerDefinitions } from '../src/config.js';
+
+const TEMP_DIR = path.join(os.tmpdir(), 'mcporter-config-test');
+
+describe('config normalization', () => {
+  it('injects Accept header for HTTP servers', async () => {
+    await fs.mkdir(TEMP_DIR, { recursive: true });
+    const configPath = path.join(TEMP_DIR, 'mcporter.json');
+    await fs.writeFile(
+      configPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            test: {
+              baseUrl: 'https://example.com/mcp',
+            },
+          },
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const servers = await loadServerDefinitions({ configPath });
+    const server = servers.find((entry) => entry.name === 'test');
+    expect(server).toBeDefined();
+    expect(server?.command.kind).toBe('http');
+    const headers = server?.command.kind === 'http' ? server.command.headers : undefined;
+    expect(headers).toBeDefined();
+    expect(headers?.accept?.toLowerCase()).toContain('application/json');
+    expect(headers?.accept?.toLowerCase()).toContain('text/event-stream');
+  });
+
+  it('normalizes oauthScope from camelCase and snake_case keys', async () => {
+    await fs.mkdir(TEMP_DIR, { recursive: true });
+    const configPath = path.join(TEMP_DIR, 'mcporter-oauth-scope.json');
+    await fs.writeFile(
+      configPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            camel: {
+              baseUrl: 'https://example.com/mcp',
+              auth: 'oauth',
+              oauthScope: 'openid profile',
+            },
+            snake: {
+              baseUrl: 'https://example.com/mcp',
+              auth: 'oauth',
+              oauth_scope: 'email',
+            },
+          },
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const servers = await loadServerDefinitions({ configPath });
+    const camel = servers.find((entry) => entry.name === 'camel');
+    const snake = servers.find((entry) => entry.name === 'snake');
+    expect(camel?.oauthScope).toBe('openid profile');
+    expect(snake?.oauthScope).toBe('email');
+  });
+});

package/tests/config-remove.test.ts

@@ -0,0 +1,44 @@
+import fs from 'node:fs/promises';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { handleRemoveCommand } from '../src/cli/config/remove.js';
+import type { LoadConfigOptions, RawConfig } from '../src/config.js';
+import { createTempConfig } from './fixtures/config-fixture.js';
+
+describe('config remove', () => {
+  let loadOptions: LoadConfigOptions;
+  let cleanup: (() => Promise<void>) | undefined;
+
+  beforeEach(async () => {
+    const initial: RawConfig = {
+      mcpServers: {
+        linear: { baseUrl: 'https://linear.app/mcp' },
+        alpha: { baseUrl: 'https://alpha.example/mcp' },
+      },
+      imports: [],
+    };
+    const ctx = await createTempConfig(initial);
+    loadOptions = ctx.loadOptions;
+    cleanup = () => ctx.cleanup();
+  });
+
+  afterEach(async () => {
+    if (cleanup) {
+      await cleanup();
+      cleanup = undefined;
+    }
+    vi.restoreAllMocks();
+  });
+
+  it('fuzzy-matches server names when removing entries', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await handleRemoveCommand({ loadOptions } as never, ['linr']);
+
+    const buffer = await fs.readFile(loadOptions.configPath ?? '', 'utf8');
+    const parsed = JSON.parse(buffer) as RawConfig;
+    logSpy.mockRestore();
+
+    expect(parsed.mcpServers?.linear).toBeUndefined();
+    expect(parsed.mcpServers?.alpha).toBeDefined();
+  });
+});

package/tests/config-render.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { serializeDefinition } from '../src/cli/config/render.js';
+import type { ServerDefinition } from '../src/config-schema.js';
+
+describe('config render helpers', () => {
+  it('serializes HTTP definitions with headers and oauth fields', () => {
+    const definition: ServerDefinition = {
+      name: 'http-server',
+      description: 'A test server',
+      command: {
+        kind: 'http',
+        url: new URL('https://example.com/mcp'),
+        headers: { Authorization: 'Bearer token' },
+      },
+      source: { kind: 'import', path: '/tmp/source.json' },
+      auth: 'oauth',
+      tokenCacheDir: '/tmp/cache',
+      clientName: 'mcporter',
+      oauthRedirectUrl: 'https://example.com/callback',
+      oauthScope: 'openid profile',
+      env: { FOO: 'bar' },
+    };
+
+    const payload = serializeDefinition(definition);
+
+    expect(payload).toMatchObject({
+      transport: 'http',
+      baseUrl: 'https://example.com/mcp',
+      headers: { Authorization: 'Bearer token' },
+      auth: 'oauth',
+      tokenCacheDir: '/tmp/cache',
+      clientName: 'mcporter',
+      oauthRedirectUrl: 'https://example.com/callback',
+      oauthScope: 'openid profile',
+      env: { FOO: 'bar' },
+      source: { kind: 'import', path: '/tmp/source.json' },
+    });
+  });
+
+  it('serializes stdio definitions with command metadata', () => {
+    const definition: ServerDefinition = {
+      name: 'stdio-server',
+      command: {
+        kind: 'stdio',
+        command: 'node',
+        args: ['--version'],
+        cwd: '/tmp',
+      },
+    };
+
+    const payload = serializeDefinition(definition);
+
+    expect(payload).toMatchObject({
+      transport: 'stdio',
+      command: 'node',
+      args: ['--version'],
+      cwd: '/tmp',
+      name: 'stdio-server',
+    });
+  });
+});

package/tests/config-resolution.test.ts

@@ -0,0 +1,94 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { resolveConfigPath } from '../src/config.js';
+
+function makeTempDir(prefix: string): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+describe('resolveConfigPath', () => {
+  const originalEnvValue = process.env.MCPORTER_CONFIG;
+  let tempDirs: string[] = [];
+  let homedirSpy: { mockRestore(): void } | undefined;
+
+  afterEach(() => {
+    if (originalEnvValue === undefined) {
+      delete process.env.MCPORTER_CONFIG;
+    } else {
+      process.env.MCPORTER_CONFIG = originalEnvValue;
+    }
+    homedirSpy?.mockRestore();
+    for (const dir of tempDirs) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+    tempDirs = [];
+  });
+
+  it('prefers an explicit config path argument', () => {
+    const tempRoot = makeTempDir('mcporter-config-');
+    tempDirs.push(tempRoot);
+    const explicitPath = path.join(tempRoot, 'custom.json');
+    fs.writeFileSync(explicitPath, '{"mcpServers":{}}');
+
+    const resolved = resolveConfigPath(explicitPath, tempRoot);
+    expect(resolved.path).toBe(explicitPath);
+    expect(resolved.explicit).toBe(true);
+  });
+
+  it('uses MCPORTER_CONFIG when set', () => {
+    const tempRoot = makeTempDir('mcporter-config-env-');
+    tempDirs.push(tempRoot);
+    const envPath = path.join(tempRoot, 'env-config.json');
+    fs.writeFileSync(envPath, '{"mcpServers":{}}');
+    process.env.MCPORTER_CONFIG = envPath;
+
+    const resolved = resolveConfigPath(undefined, tempRoot);
+    expect(resolved.path).toBe(envPath);
+    expect(resolved.explicit).toBe(true);
+  });
+
+  it('falls back to the project config when it exists', () => {
+    const tempRoot = makeTempDir('mcporter-project-');
+    tempDirs.push(tempRoot);
+    const projectConfig = path.join(tempRoot, 'config', 'mcporter.json');
+    fs.mkdirSync(path.dirname(projectConfig), { recursive: true });
+    fs.writeFileSync(projectConfig, '{"mcpServers":{}}');
+
+    const resolved = resolveConfigPath(undefined, tempRoot);
+    expect(resolved.path).toBe(projectConfig);
+    expect(resolved.explicit).toBe(false);
+  });
+
+  it('falls back to the home config when project config is missing', () => {
+    const tempRoot = makeTempDir('mcporter-project-missing-');
+    const fakeHome = makeTempDir('mcporter-home-');
+    tempDirs.push(tempRoot, fakeHome);
+    const homeConfigDir = path.join(fakeHome, '.mcporter');
+    const homeConfigPath = path.join(homeConfigDir, 'mcporter.json');
+    fs.mkdirSync(homeConfigDir, { recursive: true });
+    fs.writeFileSync(homeConfigPath, '{"mcpServers":{}}');
+    homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(fakeHome);
+
+    const resolved = resolveConfigPath(undefined, tempRoot);
+    expect(resolved.path).toBe(homeConfigPath);
+    expect(resolved.explicit).toBe(false);
+  });
+
+  it('returns explicit=false when no config exists anywhere (regression for ENOENT bug)', () => {
+    // This test verifies the fix for the bug where mcporter crashed with ENOENT
+    // when run in an environment with no config file at all. The CLI was passing
+    // the resolved (but non-existent) path as if it were explicit.
+    const tempRoot = makeTempDir('mcporter-no-config-anywhere-');
+    const fakeHome = makeTempDir('mcporter-empty-home-');
+    tempDirs.push(tempRoot, fakeHome);
+    // No config files created - completely empty environment
+    homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(fakeHome);
+
+    const resolved = resolveConfigPath(undefined, tempRoot);
+    // Should return the default project path but marked as NOT explicit
+    expect(resolved.path).toBe(path.join(tempRoot, 'config', 'mcporter.json'));
+    expect(resolved.explicit).toBe(false);
+  });
+});

package/tests/config-schema-file.test.ts

@@ -0,0 +1,29 @@
+import fs from 'node:fs/promises';
+import { describe, expect, it } from 'vitest';
+import { buildConfigJsonSchema, CONFIG_SCHEMA_DRAFT } from '../scripts/generate-json-schema.js';
+
+describe('generated config schema', () => {
+  it('stays in sync with the checked-in schema file', async () => {
+    const schemaPath = new URL('../mcporter.schema.json', import.meta.url);
+    const checkedIn = JSON.parse(await fs.readFile(schemaPath, 'utf8')) as Record<string, unknown>;
+    const generated = buildConfigJsonSchema();
+    expect(checkedIn).toEqual(generated);
+  });
+
+  it('includes top-level $schema and oauthScope properties', async () => {
+    const schemaPath = new URL('../mcporter.schema.json', import.meta.url);
+    const schema = JSON.parse(await fs.readFile(schemaPath, 'utf8')) as {
+      $schema?: string;
+      properties?: Record<string, unknown>;
+    };
+    expect(schema.$schema).toBe(CONFIG_SCHEMA_DRAFT);
+    expect(schema.properties?.$schema).toBeDefined();
+
+    const mcpServers = schema.properties?.mcpServers as
+      | { additionalProperties?: { properties?: Record<string, unknown> } }
+      | undefined;
+    const entryProperties = mcpServers?.additionalProperties?.properties;
+    expect(entryProperties?.oauthScope).toBeDefined();
+    expect(entryProperties?.oauth_scope).toBeDefined();
+  });
+});

package/tests/config-shared.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from 'vitest';
+import { findServerNameWithFuzzyMatch, resolveServerDefinition } from '../src/cli/config/shared.js';
+import type { ServerDefinition } from '../src/config-schema.js';
+
+function buildServers(): ServerDefinition[] {
+  return [
+    {
+      name: 'linear',
+      command: { kind: 'http', url: new URL('https://linear.app/mcp'), headers: {} },
+    },
+    {
+      name: 'slack',
+      command: { kind: 'stdio', command: 'slack-mcp', args: [], cwd: '/tmp' },
+    },
+  ];
+}
+
+describe('config shared helpers', () => {
+  it('auto-corrects close names when resolving server definitions', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const server = resolveServerDefinition('linea', buildServers(), logSpy);
+    logSpy.mockRestore();
+    expect(server.name).toBe('linear');
+  });
+
+  it('throws when no close match exists', () => {
+    expect(() => resolveServerDefinition('unknown', buildServers(), null)).toThrow(/Unknown server/);
+  });
+
+  it('returns matched name when helper finds direct match', () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const match = findServerNameWithFuzzyMatch('linear', ['linear', 'other'], logSpy);
+    logSpy.mockRestore();
+    expect(match).toBe('linear');
+  });
+
+  it('returns null when fuzzy helper has no candidate', () => {
+    const match = findServerNameWithFuzzyMatch('nothing', ['alpha', 'beta'], null);
+    expect(match).toBeNull();
+  });
+});

package/tests/config-sources.test.ts

@@ -0,0 +1,58 @@
+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 { loadServerDefinitions } from '../src/config.js';
+
+describe('config sources tracking', () => {
+  let tempDir: string;
+  let originalCwd: string;
+  let restoreHomedir: (() => void) | undefined;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-config-sources-'));
+    process.chdir(tempDir);
+    const spy = vi.spyOn(os, 'homedir');
+    spy.mockReturnValue(tempDir);
+    restoreHomedir = () => spy.mockRestore();
+  });
+
+  afterEach(async () => {
+    restoreHomedir?.();
+    process.chdir(originalCwd);
+    await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('keeps primary definition first and includes alternate sources when duplicates exist', async () => {
+    const projectConfigPath = path.join(tempDir, 'config', 'mcporter.json');
+    await fs.mkdir(path.dirname(projectConfigPath), { recursive: true });
+    await fs.writeFile(
+      projectConfigPath,
+      JSON.stringify(
+        { imports: ['cursor'], mcpServers: { alpha: { baseUrl: 'https://primary.example.com/mcp' } } },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const cursorConfigPath = path.join(tempDir, '.cursor', 'mcp.json');
+    await fs.mkdir(path.dirname(cursorConfigPath), { recursive: true });
+    await fs.writeFile(
+      cursorConfigPath,
+      JSON.stringify({ mcpServers: { alpha: { baseUrl: 'https://shadow.example.com/mcp' } } }, null, 2),
+      'utf8'
+    );
+
+    const definitions = await loadServerDefinitions({ configPath: projectConfigPath, rootDir: tempDir });
+
+    expect(definitions).toHaveLength(1);
+    const definition = definitions[0];
+    if (!definition) {
+      throw new Error('definition should be present');
+    }
+    expect(definition.source?.path).toBe(projectConfigPath);
+    expect(definition.sources?.map((entry) => entry.path)).toEqual([projectConfigPath, cursorConfigPath]);
+  });
+});

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

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const stopMock = vi.fn();
+const statusMock = vi.fn();
+const mkdirMock = vi.fn();
+const launchDaemonDetachedMock = vi.fn();
+const runDaemonHostMock = vi.fn();
+const createRuntimeMock = vi.fn();
+const isKeepAliveServerMock = vi.fn(() => true);
+const DaemonClientMock = vi.fn();
+
+vi.mock('node:fs/promises', () => ({
+  default: { mkdir: mkdirMock },
+  mkdir: mkdirMock,
+}));
+
+vi.mock('../src/daemon/client.js', () => ({
+  DaemonClient: DaemonClientMock,
+  resolveDaemonPaths: vi.fn(() => ({
+    key: 'abc123',
+    socketPath: '/tmp/socket',
+    metadataPath: '/tmp/meta',
+  })),
+}));
+
+vi.mock('../src/daemon/launch.js', () => ({
+  launchDaemonDetached: launchDaemonDetachedMock,
+}));
+
+vi.mock('../src/daemon/host.js', () => ({
+  runDaemonHost: runDaemonHostMock,
+}));
+
+vi.mock('../src/daemon/paths.js', () => ({
+  getDaemonLogPath: vi.fn(() => '/tmp/mock-daemon.log'),
+}));
+
+vi.mock('../src/env.js', () => ({
+  expandHome: (value: string) => value,
+}));
+
+vi.mock('../src/runtime.js', () => ({
+  createRuntime: (...args: Parameters<typeof createRuntimeMock>) => createRuntimeMock(...args),
+}));
+
+vi.mock('../src/lifecycle.js', () => ({
+  isKeepAliveServer: (...args: Parameters<typeof isKeepAliveServerMock>) => isKeepAliveServerMock(...args),
+}));
+
+const { handleDaemonCli } = await import('../src/cli/daemon-command.js');
+
+describe('daemon CLI restart', () => {
+  beforeEach(() => {
+    stopMock.mockReset();
+    statusMock.mockReset();
+    mkdirMock.mockReset();
+    launchDaemonDetachedMock.mockReset();
+    runDaemonHostMock.mockReset();
+    createRuntimeMock.mockReset();
+    isKeepAliveServerMock.mockReset();
+    DaemonClientMock.mockReset();
+    DaemonClientMock.mockImplementation(function MockDaemonClient() {
+      return {
+        stop: stopMock,
+        status: statusMock,
+      };
+    });
+    stopMock.mockResolvedValue(undefined);
+
+    const closeMock = vi.fn().mockResolvedValue(undefined);
+    createRuntimeMock.mockResolvedValue({
+      getDefinitions: () => [{ name: 'daemon-e2e', lifecycle: 'keep-alive' }],
+      close: closeMock,
+    });
+    isKeepAliveServerMock.mockReturnValue(true);
+    mkdirMock.mockResolvedValue(undefined);
+  });
+
+  it('stops the daemon and launches a fresh instance while honoring log flags', async () => {
+    statusMock
+      .mockResolvedValueOnce(null) // restart wait sees daemon already stopped
+      .mockResolvedValueOnce(null) // handleDaemonStart: no existing daemon
+      .mockResolvedValueOnce(null) // waitFor: daemon not ready yet
+      .mockResolvedValueOnce({ pid: 420, socketPath: '/tmp/socket', servers: [], logPath: '/tmp/mock-daemon.log' });
+
+    await handleDaemonCli(['restart', '--log'], { configPath: '/tmp/config.json', configExplicit: true });
+
+    expect(stopMock).toHaveBeenCalledTimes(1);
+    expect(launchDaemonDetachedMock).toHaveBeenCalledWith({
+      configPath: '/tmp/config.json',
+      configExplicit: true,
+      rootDir: undefined,
+      metadataPath: '/tmp/meta',
+      socketPath: '/tmp/socket',
+      extraArgs: ['--log-file', '/tmp/mock-daemon.log'],
+    });
+  });
+
+  it('uses implicit config when no explicit path is provided, avoiding ENOENT', async () => {
+    statusMock
+      .mockResolvedValueOnce(null) // restart wait sees daemon already stopped
+      .mockResolvedValueOnce(null) // handleDaemonStart: no existing daemon
+      .mockResolvedValueOnce({ pid: 321, socketPath: '/tmp/socket', servers: [], logPath: undefined }); // waitFor ready
+
+    await handleDaemonCli(['restart'], { configPath: '/tmp/config.json', configExplicit: false });
+
+    expect(createRuntimeMock).toHaveBeenCalledWith({
+      configPath: undefined,
+      rootDir: undefined,
+    });
+  });
+});