@nimrobo/mcporter-remote 0.1.0

package/tests/daemon-client-config-stale.test.ts

@@ -0,0 +1,222 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { makeShortTempDir } from './fixtures/test-helpers.js';
+
+const sentMethods: string[] = [];
+let launchDaemonDetached: ReturnType<typeof vi.fn>;
+let createConnection: ReturnType<typeof vi.fn>;
+
+class MockSocket extends EventEmitter {
+  setTimeout(): this {
+    return this;
+  }
+
+  write(data: string, cb?: (err?: Error | null) => void): boolean {
+    const payload = JSON.parse(data.toString());
+    sentMethods.push(payload.method);
+    const response = buildResponse(payload.method, payload.id);
+    queueMicrotask(() => {
+      this.emit('data', JSON.stringify(response));
+      this.emit('end');
+    });
+    cb?.(null);
+    return true;
+  }
+
+  end(): this {
+    return this;
+  }
+
+  destroy(): this {
+    return this;
+  }
+}
+
+function buildResponse(method: string, id: string) {
+  if (method === 'status') {
+    return {
+      id,
+      ok: true,
+      result: {
+        pid: 123,
+        startedAt: Date.now(),
+        configPath: activeConfigPath,
+        configMtimeMs: activeConfigMtime,
+        configLayers: activeLayers,
+        socketPath: activeSocketPath,
+        servers: [],
+      },
+    };
+  }
+  return {
+    id,
+    ok: true,
+    result: method === 'listTools' ? { tools: [] } : true,
+  };
+}
+
+let activeConfigPath: string;
+let activeConfigMtime: number | null = null;
+let activeSocketPath: string;
+let previousDaemonDir: string | undefined;
+let activeLayers: Array<{ path: string; mtimeMs: number | null }> = [];
+
+vi.mock('node:net', () => {
+  createConnection = vi.fn(() => {
+    const socket = new MockSocket();
+    queueMicrotask(() => socket.emit('connect'));
+    return socket as unknown as import('node:net').Socket;
+  });
+  return { createConnection, default: { createConnection } };
+});
+
+vi.mock('../src/daemon/launch.js', () => {
+  launchDaemonDetached = vi.fn();
+  return { launchDaemonDetached };
+});
+
+const { DaemonClient, resolveDaemonPaths } = await import('../src/daemon/client.js');
+
+describe('DaemonClient config freshness', () => {
+  beforeEach(() => {
+    sentMethods.length = 0;
+    previousDaemonDir = process.env.MCPORTER_DAEMON_DIR;
+    activeLayers = [];
+    launchDaemonDetached.mockClear();
+  });
+
+  afterEach(async () => {
+    if (previousDaemonDir === undefined) {
+      delete process.env.MCPORTER_DAEMON_DIR;
+    } else {
+      process.env.MCPORTER_DAEMON_DIR = previousDaemonDir;
+    }
+  });
+
+  it('restarts the daemon when config mtime changes', async () => {
+    const tmpDir = await makeShortTempDir('daemon-stale');
+    process.env.MCPORTER_DAEMON_DIR = tmpDir;
+
+    const configPath = path.join(tmpDir, 'config.json');
+    await fs.writeFile(configPath, JSON.stringify({ mcpServers: {} }), 'utf8');
+    const stat = await fs.stat(configPath);
+    const oldMtime = stat.mtimeMs - 1000;
+    const { metadataPath, socketPath } = resolveDaemonPaths(configPath);
+    activeConfigPath = configPath;
+    activeSocketPath = socketPath;
+    activeConfigMtime = stat.mtimeMs;
+    activeLayers = [{ path: configPath, mtimeMs: stat.mtimeMs }];
+
+    await fs.mkdir(path.dirname(metadataPath), { recursive: true });
+    await fs.writeFile(
+      metadataPath,
+      JSON.stringify(
+        {
+          pid: 1111,
+          socketPath,
+          configPath,
+          startedAt: Date.now() - 10_000,
+          logPath: null,
+          configMtimeMs: oldMtime,
+          configLayers: [{ path: configPath, mtimeMs: oldMtime }],
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const client = new DaemonClient({ configPath, configExplicit: true, rootDir: tmpDir });
+    await client.listTools({ server: 'playwright' });
+
+    expect(sentMethods[0]).toBe('stop');
+    expect(sentMethods).toContain('status');
+    expect(sentMethods).toContain('listTools');
+    expect(launchDaemonDetached).toHaveBeenCalledTimes(1);
+  });
+
+  it('restarts when metadata layers differ from current layers', async () => {
+    const tmpDir = await makeShortTempDir('daemon-layers');
+    process.env.MCPORTER_DAEMON_DIR = tmpDir;
+
+    const configPath = path.join(tmpDir, 'config.json');
+    await fs.writeFile(configPath, JSON.stringify({ mcpServers: {} }), 'utf8');
+    const stat = await fs.stat(configPath);
+    const { metadataPath, socketPath } = resolveDaemonPaths(configPath);
+    activeConfigPath = configPath;
+    activeSocketPath = socketPath;
+    activeConfigMtime = stat.mtimeMs;
+    activeLayers = [{ path: configPath, mtimeMs: stat.mtimeMs }];
+
+    await fs.mkdir(path.dirname(metadataPath), { recursive: true });
+    await fs.writeFile(
+      metadataPath,
+      JSON.stringify(
+        {
+          pid: 1111,
+          socketPath,
+          configPath,
+          startedAt: Date.now() - 10_000,
+          logPath: null,
+          configMtimeMs: stat.mtimeMs,
+          configLayers: [
+            { path: configPath, mtimeMs: stat.mtimeMs },
+            { path: path.join(tmpDir, 'shadow.json'), mtimeMs: stat.mtimeMs },
+          ],
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const client = new DaemonClient({ configPath, configExplicit: true, rootDir: tmpDir });
+    await client.listResources({ server: 'playwright' });
+
+    expect(sentMethods[0]).toBe('stop');
+    expect(launchDaemonDetached).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not restart when metadata layers match', async () => {
+    const tmpDir = await makeShortTempDir('daemon-layers-stable');
+    process.env.MCPORTER_DAEMON_DIR = tmpDir;
+
+    const configPath = path.join(tmpDir, 'config.json');
+    await fs.writeFile(configPath, JSON.stringify({ mcpServers: {} }), 'utf8');
+    const stat = await fs.stat(configPath);
+    const { metadataPath, socketPath } = resolveDaemonPaths(configPath);
+    activeConfigPath = configPath;
+    activeSocketPath = socketPath;
+    activeConfigMtime = stat.mtimeMs;
+    activeLayers = [{ path: configPath, mtimeMs: stat.mtimeMs }];
+
+    await fs.mkdir(path.dirname(metadataPath), { recursive: true });
+    await fs.writeFile(
+      metadataPath,
+      JSON.stringify(
+        {
+          pid: 1111,
+          socketPath,
+          configPath,
+          startedAt: Date.now() - 10_000,
+          logPath: null,
+          configMtimeMs: stat.mtimeMs,
+          configLayers: activeLayers,
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const client = new DaemonClient({ configPath, configExplicit: true, rootDir: tmpDir });
+    await client.listTools({ server: 'playwright' });
+
+    expect(sentMethods[0]).toBe('status');
+    expect(sentMethods).toContain('listTools');
+    expect(sentMethods).not.toContain('stop');
+    expect(launchDaemonDetached).not.toHaveBeenCalled();
+  });
+});

package/tests/daemon-client-timeout.test.ts

@@ -0,0 +1,114 @@
+import { EventEmitter } from 'node:events';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const timeoutRecords: Array<{ method: string; timeout: number }> = [];
+
+class MockSocket extends EventEmitter {
+  currentTimeout = 0;
+
+  setTimeout(ms: number): this {
+    this.currentTimeout = ms;
+    return this;
+  }
+
+  write(data: string, cb?: (err?: Error | null) => void): boolean {
+    const payload = JSON.parse(data.toString());
+    timeoutRecords.push({ method: payload.method, timeout: this.currentTimeout });
+    const response = buildResponse(payload.method, payload.id);
+    setTimeout(() => {
+      this.emit('data', JSON.stringify(response));
+      this.emit('end');
+    }, responseDelayMs);
+    cb?.();
+    return true;
+  }
+
+  end(cb?: () => void): this {
+    cb?.();
+    return this;
+  }
+
+  destroy(): this {
+    return this;
+  }
+}
+
+let responseDelayMs = 5;
+const createConnection = vi.fn(() => {
+  const socket = new MockSocket();
+  setTimeout(() => socket.emit('connect'), 0);
+  return socket;
+});
+
+let previousDaemonTimeout: string | undefined;
+
+vi.mock('node:net', () => ({
+  createConnection,
+  default: { createConnection },
+}));
+
+vi.mock('../src/daemon/launch.js', () => ({
+  launchDaemonDetached: vi.fn(),
+}));
+
+const { DaemonClient } = await import('../src/daemon/client.js');
+
+function buildResponse(method: string, id: string) {
+  if (method === 'status') {
+    return {
+      id,
+      ok: true,
+      result: {
+        pid: 123,
+        startedAt: Date.now(),
+        configPath: 'test',
+        socketPath: '/tmp/socket',
+        servers: [],
+      },
+    };
+  }
+  return {
+    id,
+    ok: true,
+    result: { ok: true },
+  };
+}
+
+describe('DaemonClient timeouts', () => {
+  beforeEach(() => {
+    timeoutRecords.length = 0;
+    responseDelayMs = 5;
+    previousDaemonTimeout = process.env.MCPORTER_DAEMON_TIMEOUT_MS;
+    delete process.env.MCPORTER_DAEMON_TIMEOUT_MS;
+  });
+
+  afterEach(() => {
+    if (previousDaemonTimeout === undefined) {
+      delete process.env.MCPORTER_DAEMON_TIMEOUT_MS;
+    } else {
+      process.env.MCPORTER_DAEMON_TIMEOUT_MS = previousDaemonTimeout;
+    }
+  });
+
+  it('defaults to 30s per request', async () => {
+    const client = new DaemonClient({ configPath: 'mcporter.config.json' });
+    await client.callTool({ server: 'foo', tool: 'bar' });
+    const callRecord = timeoutRecords.find((entry) => entry.method === 'callTool');
+    expect(callRecord?.timeout).toBe(30_000);
+  });
+
+  it('honors MCPORTER_DAEMON_TIMEOUT_MS override', async () => {
+    process.env.MCPORTER_DAEMON_TIMEOUT_MS = '4500';
+    const client = new DaemonClient({ configPath: 'mcporter.config.json' });
+    await client.callTool({ server: 'foo', tool: 'bar' });
+    const callRecord = timeoutRecords.find((entry) => entry.method === 'callTool');
+    expect(callRecord?.timeout).toBe(4_500);
+  });
+
+  it('honors per-call timeout overrides', async () => {
+    const client = new DaemonClient({ configPath: 'mcporter.config.json' });
+    await client.callTool({ server: 'foo', tool: 'bar', timeoutMs: 12_345 });
+    const callRecord = timeoutRecords.find((entry) => entry.method === 'callTool');
+    expect(callRecord?.timeout).toBe(12_345);
+  });
+});

package/tests/daemon-client.test.ts

@@ -0,0 +1,61 @@
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { DaemonClient, resolveDaemonPaths } from '../src/daemon/client.js';
+import { makeShortTempDir } from './fixtures/test-helpers.js';
+
+describe('daemon client', () => {
+  it('keeps stdio sockets open until the daemon responds', async () => {
+    const tmpDir = await makeShortTempDir('mcpd');
+    const originalDir = process.env.MCPORTER_DAEMON_DIR;
+    process.env.MCPORTER_DAEMON_DIR = tmpDir;
+    const configPath = path.join(tmpDir, 'config.json');
+    const { socketPath } = resolveDaemonPaths(configPath);
+    await fs.mkdir(path.dirname(socketPath), { recursive: true });
+    try {
+      await fs.unlink(socketPath).catch(() => {});
+      let clientClosedBeforeResponse = false;
+      const server = net.createServer((socket) => {
+        let responded = false;
+        socket.on('data', () => {
+          setTimeout(() => {
+            responded = true;
+            socket.write(JSON.stringify({ id: 'status', ok: true, result: { pong: true } }), () => {
+              socket.end();
+            });
+          }, 20);
+        });
+        socket.on('end', () => {
+          if (!responded) {
+            clientClosedBeforeResponse = true;
+          }
+        });
+      });
+      await new Promise<void>((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(socketPath, () => {
+          server.off('error', reject);
+          resolve();
+        });
+      });
+      try {
+        const client = new DaemonClient({ configPath });
+        const result = await (
+          client as unknown as { sendRequest: (method: 'status', params: object) => Promise<unknown> }
+        ).sendRequest('status', {});
+        expect(result).toEqual({ pong: true });
+        expect(clientClosedBeforeResponse).toBe(false);
+      } finally {
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+        await fs.unlink(socketPath).catch(() => {});
+      }
+    } finally {
+      if (originalDir) {
+        process.env.MCPORTER_DAEMON_DIR = originalDir;
+      } else {
+        delete process.env.MCPORTER_DAEMON_DIR;
+      }
+    }
+  });
+});

package/tests/daemon-host.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import type { ServerDefinition } from '../src/config.js';
+import { __testProcessRequest } from '../src/daemon/host.js';
+import type { DaemonRequest } from '../src/daemon/protocol.js';
+import type { Runtime } from '../src/runtime.js';
+
+describe('daemon host request handling', () => {
+  it('reuses pre-parsed requests without reparsing payloads', async () => {
+    const metadata = {
+      configPath: '/tmp/config.json',
+      configLayers: [],
+      configMtimeMs: Date.now(),
+      socketPath: '/tmp/socket',
+      startedAt: Date.now(),
+      logPath: null,
+    };
+    const logContext = { enabled: false, logAllServers: false, servers: new Set<string>() };
+
+    const parsedRequest: DaemonRequest = { id: '1', method: 'status', params: {} };
+    const result = await __testProcessRequest(
+      '!!!invalid-json!!!',
+      {} as Runtime,
+      new Map<string, ServerDefinition>(),
+      new Map(),
+      metadata,
+      logContext,
+      parsedRequest
+    );
+
+    expect(result.response.ok).toBe(true);
+    expect(result.shouldShutdown).toBe(false);
+  });
+});

package/tests/daemon.integration.test.ts

@@ -0,0 +1,175 @@
+import { execFile } from 'node:child_process';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const CLI_ENTRY = fileURLToPath(new URL('../dist/cli.js', import.meta.url));
+const testRequire = createRequire(import.meta.url);
+const MCP_SERVER_MODULE = pathToFileURL(testRequire.resolve('@modelcontextprotocol/sdk/server/mcp.js')).href;
+const STDIO_SERVER_MODULE = pathToFileURL(testRequire.resolve('@modelcontextprotocol/sdk/server/stdio.js')).href;
+const ZOD_MODULE = pathToFileURL(testRequire.resolve('zod')).href;
+const describeDaemon = process.platform === 'win32' ? describe.skip : describe;
+const PNPM_COMMAND = process.platform === 'win32' ? 'cmd.exe' : 'pnpm';
+const PNPM_ARGS_PREFIX = process.platform === 'win32' ? ['/d', '/s', '/c', 'pnpm'] : [];
+
+function pnpmArgs(args: string[]): string[] {
+  return [...PNPM_ARGS_PREFIX, ...args];
+}
+
+async function readFileWithRetries(filePath: string, retries = 20, delayMs = 100): Promise<string> {
+  let lastError: unknown;
+  for (let attempt = 0; attempt < retries; attempt++) {
+    try {
+      return await fs.readFile(filePath, 'utf8');
+    } catch (error) {
+      lastError = error;
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw error;
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  throw lastError ?? new Error(`Failed to read ${filePath}`);
+}
+
+async function ensureDistBuilt(): Promise<void> {
+  try {
+    await fs.access(CLI_ENTRY);
+  } catch {
+    await new Promise<void>((resolve, reject) => {
+      execFile(PNPM_COMMAND, pnpmArgs(['build']), { cwd: process.cwd(), env: process.env }, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+}
+
+async function runCli(
+  args: string[],
+  configPath: string,
+  envOverrides: Record<string, string> = {}
+): Promise<{ stdout: string; stderr: string }> {
+  return await new Promise((resolve, reject) => {
+    execFile(
+      process.execPath,
+      [CLI_ENTRY, '--config', configPath, ...args],
+      {
+        env: { ...process.env, MCPORTER_NO_FORCE_EXIT: '1', ...envOverrides },
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          const wrapped = new Error(`${error.message}\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`);
+          reject(wrapped);
+          return;
+        }
+        resolve({ stdout, stderr });
+      }
+    );
+  });
+}
+
+function parseCliJson(output: string): { instanceId: string; count: number } {
+  const trimmed = output.trim();
+  const start = trimmed.indexOf('{');
+  const end = trimmed.lastIndexOf('}');
+  if (start === -1 || end === -1 || end < start) {
+    throw new Error(`Unable to locate JSON payload in CLI output:\n${output}`);
+  }
+  return JSON.parse(trimmed.slice(start, end + 1));
+}
+
+describeDaemon('daemon keep-alive integration', () => {
+  it('reuses stdio servers across mcporter invocations', async () => {
+    await ensureDistBuilt();
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mcporter-daemon-e2e-'));
+    const scriptPath = path.join(tempDir, 'daemon-server.mjs');
+    const configPath = path.join(tempDir, 'mcporter.daemon.json');
+
+    const stdioServerSource = `import { randomUUID } from 'node:crypto';
+import { McpServer } from '${MCP_SERVER_MODULE}';
+import { StdioServerTransport } from '${STDIO_SERVER_MODULE}';
+import { z } from '${ZOD_MODULE}';
+
+const instanceId = randomUUID();
+let counter = 0;
+
+const server = new McpServer({ name: 'daemon-e2e', version: '1.0.0' });
+server.registerTool('next_value', {
+  title: 'Next value',
+  description: 'Returns an incrementing counter along with the server instance id.',
+  inputSchema: {},
+  outputSchema: {
+    instanceId: z.string(),
+    count: z.number(),
+  },
+}, async () => {
+  counter += 1;
+  return {
+    content: [{ type: 'text', text: JSON.stringify({ instanceId, count: counter }) }],
+    structuredContent: { instanceId, count: counter },
+  };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+await new Promise((resolve) => {
+  transport.onclose = resolve;
+});
+`;
+
+    await fs.writeFile(scriptPath, stdioServerSource, 'utf8');
+    await fs.writeFile(
+      configPath,
+      JSON.stringify(
+        {
+          mcpServers: {
+            'daemon-e2e': {
+              description: 'E2E daemon test server',
+              command: 'node',
+              args: [scriptPath],
+              lifecycle: 'keep-alive',
+            },
+          },
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    const logPath = path.join(tempDir, 'daemon.log');
+    const cliEnv = {
+      MCPORTER_DAEMON_LOG: '1',
+      MCPORTER_DAEMON_LOG_PATH: logPath,
+      MCPORTER_DAEMON_LOG_SERVERS: 'daemon-e2e',
+    };
+    const cli = (args: string[]) => runCli(args, configPath, cliEnv);
+
+    try {
+      await cli(['daemon', 'stop']);
+
+      const first = await cli(['call', 'daemon-e2e.next_value', '--output', 'json']);
+      const firstResult = parseCliJson(first.stdout);
+      expect(firstResult.count).toBe(1);
+
+      const second = await cli(['call', 'daemon-e2e.next_value', '--output', 'json']);
+      const secondResult = parseCliJson(second.stdout);
+      expect(secondResult.count).toBe(2);
+      expect(secondResult.instanceId).toBe(firstResult.instanceId);
+
+      const logContents = await readFileWithRetries(logPath);
+      expect(logContents).toContain('callTool start server=daemon-e2e tool=next_value');
+      expect(logContents).toContain('callTool success server=daemon-e2e tool=next_value');
+    } finally {
+      await cli(['daemon', 'stop']).catch(() => {});
+      await fs.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  }, 40_000);
+});