@nimrobo/mcporter-remote 0.1.0

package/src/daemon/host.ts

@@ -0,0 +1,455 @@
+import fs from 'node:fs/promises';
+import net from 'node:net';
+import path from 'node:path';
+import type { ServerDefinition } from '../config.js';
+import { isKeepAliveServer } from '../lifecycle.js';
+import { createRuntime, type Runtime } from '../runtime.js';
+import { collectConfigLayers, statConfigMtime } from './config-layers.js';
+import {
+  createLogContext,
+  disposeLogContext,
+  formatError,
+  type LogContext,
+  logEvent,
+  shouldLogServer,
+} from './log-context.js';
+import type {
+  CallToolParams,
+  CloseServerParams,
+  DaemonRequest,
+  DaemonResponse,
+  ListResourcesParams,
+  ListToolsParams,
+  StatusResult,
+} from './protocol.js';
+import {
+  buildErrorResponse,
+  ensureManaged,
+  evictIdleServers,
+  markActivity,
+  type ServerActivity,
+} from './request-utils.js';
+
+interface DaemonHostOptions {
+  readonly socketPath: string;
+  readonly metadataPath: string;
+  readonly configPath: string;
+  readonly configExplicit?: boolean;
+  readonly rootDir?: string;
+  readonly logPath?: string;
+  readonly logServers?: Set<string>;
+  readonly logAllServers?: boolean;
+}
+
+export async function runDaemonHost(options: DaemonHostOptions): Promise<void> {
+  const configLayers = await collectConfigLayers({
+    configPath: options.configExplicit ? options.configPath : undefined,
+    rootDir: options.rootDir,
+  });
+  const runtime = await createRuntime({
+    configPath: options.configExplicit ? options.configPath : undefined,
+    rootDir: options.rootDir,
+  });
+  const keepAliveDefinitions = runtime.getDefinitions().filter(isKeepAliveServer);
+  if (keepAliveDefinitions.length === 0) {
+    throw new Error('No MCP servers require keep-alive; daemon will not start.');
+  }
+  const managedServers = new Map<string, ServerDefinition>();
+  for (const definition of keepAliveDefinitions) {
+    managedServers.set(definition.name, definition);
+  }
+  const serverLoggingOverrides = new Set<string>();
+  for (const definition of keepAliveDefinitions) {
+    if (definition.logging?.daemon?.enabled) {
+      serverLoggingOverrides.add(definition.name);
+    }
+  }
+  const combinedServerLogs = new Set<string>([
+    ...serverLoggingOverrides,
+    ...(options.logServers ? Array.from(options.logServers) : []),
+  ]);
+  const logContext = createLogContext({
+    enabled: Boolean(options.logPath),
+    logAllServers: options.logAllServers ?? false,
+    servers: combinedServerLogs,
+    logPath: options.logPath,
+  });
+
+  await prepareSocket(options.socketPath);
+  await fs.mkdir(path.dirname(options.metadataPath), { recursive: true });
+  const configMtimeMs = await statConfigMtime(options.configPath);
+
+  const activity = new Map<string, ServerActivity>();
+  for (const definition of keepAliveDefinitions) {
+    activity.set(definition.name, { connected: false });
+  }
+
+  const idleWatcher = setInterval(() => {
+    void evictIdleServers(runtime, managedServers, activity);
+  }, 30_000);
+  idleWatcher.unref();
+
+  logEvent(logContext, 'Daemon host started.');
+
+  const startedAt = Date.now();
+  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
+    socket.setEncoding('utf8');
+    let buffer = '';
+    let handled = false;
+    const tryHandle = () => {
+      if (handled) {
+        return;
+      }
+      const trimmed = buffer.trim();
+      if (trimmed.length === 0) {
+        return;
+      }
+      // Attempt to parse immediately; if it parses, handle the request now.
+      let parsedRequest: DaemonRequest;
+      try {
+        parsedRequest = JSON.parse(trimmed) as DaemonRequest;
+      } catch {
+        // Not a complete JSON yet; wait for more data or 'end'
+        return;
+      }
+      handled = true;
+      void handleSocketRequest(
+        trimmed,
+        socket,
+        runtime,
+        managedServers,
+        activity,
+        {
+          configPath: options.configPath,
+          configLayers,
+          socketPath: options.socketPath,
+          startedAt,
+          logPath: options.logPath ?? null,
+          configMtimeMs,
+        },
+        logContext,
+        shutdown,
+        parsedRequest
+      );
+    };
+    socket.on('data', (chunk) => {
+      buffer += chunk;
+      tryHandle();
+    });
+    socket.on('end', () => {
+      // Fallback: if we haven't handled yet, try now (for compatibility)
+      if (!handled) {
+        tryHandle();
+      }
+    });
+    socket.on('error', () => {
+      socket.destroy();
+    });
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(options.socketPath, () => {
+      server.off('error', reject);
+      resolve();
+    });
+  });
+
+  await fs.writeFile(
+    options.metadataPath,
+    JSON.stringify(
+      {
+        pid: process.pid,
+        socketPath: options.socketPath,
+        configPath: options.configPath,
+        configLayers,
+        startedAt: Date.now(),
+        logPath: options.logPath ?? null,
+        configMtimeMs,
+      },
+      null,
+      2
+    ),
+    'utf8'
+  );
+
+  let shuttingDown = false;
+  const shutdown = async (): Promise<void> => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    logEvent(logContext, 'Shutting down daemon host.');
+    clearInterval(idleWatcher);
+    server.close();
+    await runtime.close().catch(() => {});
+    await disposeLogContext(logContext).catch(() => {});
+    await cleanupArtifacts(options);
+    process.exit(0);
+  };
+
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+  process.once('SIGQUIT', shutdown);
+}
+
+async function prepareSocket(socketPath: string): Promise<void> {
+  if (process.platform === 'win32') {
+    return;
+  }
+  try {
+    await fs.unlink(socketPath);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error;
+    }
+  }
+  await fs.mkdir(path.dirname(socketPath), { recursive: true });
+}
+
+async function cleanupArtifacts(options: DaemonHostOptions): Promise<void> {
+  if (process.platform !== 'win32') {
+    try {
+      await fs.unlink(options.socketPath);
+    } catch {
+      // ignore
+    }
+  }
+  try {
+    await fs.unlink(options.metadataPath);
+  } catch {
+    // ignore
+  }
+}
+
+async function handleSocketRequest(
+  rawPayload: string,
+  socket: net.Socket,
+  runtime: Runtime,
+  managedServers: Map<string, ServerDefinition>,
+  activity: Map<string, ServerActivity>,
+  metadata: {
+    configPath: string;
+    configLayers: Array<{ path: string; mtimeMs: number | null }>;
+    configMtimeMs: number | null;
+    socketPath: string;
+    startedAt: number;
+    logPath: string | null;
+  },
+  logContext: LogContext,
+  shutdown: () => Promise<void>,
+  preParsedRequest?: DaemonRequest
+): Promise<void> {
+  const { response, shouldShutdown } = await processRequest(
+    rawPayload,
+    runtime,
+    managedServers,
+    activity,
+    metadata,
+    logContext,
+    preParsedRequest
+  );
+  socket.write(JSON.stringify(response), () => {
+    socket.end(() => {
+      if (shouldShutdown) {
+        void shutdown();
+      }
+    });
+  });
+}
+
+async function processRequest(
+  rawPayload: string,
+  runtime: Runtime,
+  managedServers: Map<string, ServerDefinition>,
+  activity: Map<string, ServerActivity>,
+  metadata: {
+    configPath: string;
+    configLayers: Array<{ path: string; mtimeMs: number | null }>;
+    configMtimeMs: number | null;
+    socketPath: string;
+    startedAt: number;
+    logPath: string | null;
+  },
+  logContext: LogContext,
+  preParsedRequest?: DaemonRequest
+): Promise<{ response: DaemonResponse; shouldShutdown: boolean }> {
+  const trimmed = rawPayload.trim();
+  if (!trimmed && !preParsedRequest) {
+    return {
+      response: buildErrorResponse('unknown', 'empty_request'),
+      shouldShutdown: false,
+    };
+  }
+  let request: DaemonRequest;
+  if (preParsedRequest) {
+    request = preParsedRequest;
+  } else {
+    try {
+      request = JSON.parse(trimmed) as DaemonRequest;
+    } catch (error) {
+      return {
+        response: buildErrorResponse('unknown', 'invalid_json', error),
+        shouldShutdown: false,
+      };
+    }
+  }
+  const id = request.id ?? 'unknown';
+  try {
+    switch (request.method) {
+      case 'callTool': {
+        const params = request.params as CallToolParams;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `callTool start server=${params.server} tool=${params.tool}`);
+        }
+        try {
+          const result = await runtime.callTool(params.server, params.tool, {
+            args: params.args ?? {},
+            timeoutMs: params.timeoutMs,
+          });
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `callTool success server=${params.server} tool=${params.tool}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `callTool error server=${params.server} tool=${params.tool} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case 'listTools': {
+        const params = request.params as ListToolsParams;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `listTools start server=${params.server}`);
+        }
+        try {
+          const result = await runtime.listTools(params.server, {
+            includeSchema: params.includeSchema,
+            autoAuthorize: params.autoAuthorize,
+          });
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `listTools success server=${params.server}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `listTools error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case 'listResources': {
+        const params = request.params as ListResourcesParams;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `listResources start server=${params.server}`);
+        }
+        try {
+          const result = await runtime.listResources(params.server, params.params);
+          markActivity(params.server, activity);
+          if (loggable) {
+            logEvent(logContext, `listResources success server=${params.server}`);
+          }
+          return { response: { id, ok: true, result }, shouldShutdown: false };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `listResources error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case 'closeServer': {
+        const params = request.params as CloseServerParams;
+        ensureManaged(params.server, managedServers);
+        const loggable = shouldLogServer(logContext, params.server);
+        if (loggable) {
+          logEvent(logContext, `closeServer start server=${params.server}`);
+        }
+        try {
+          await runtime.close(params.server);
+          activity.set(params.server, { connected: false });
+          if (loggable) {
+            logEvent(logContext, `closeServer success server=${params.server}`);
+          }
+          return {
+            response: { id, ok: true, result: true },
+            shouldShutdown: false,
+          };
+        } catch (error) {
+          if (loggable) {
+            const detail = formatError(error);
+            logEvent(logContext, `closeServer error server=${params.server} err=${detail}`);
+          }
+          throw error;
+        }
+      }
+      case 'status': {
+        const result: StatusResult = {
+          pid: process.pid,
+          startedAt: metadata.startedAt,
+          configPath: metadata.configPath,
+          configLayers: metadata.configLayers,
+          configMtimeMs: metadata.configMtimeMs,
+          socketPath: metadata.socketPath,
+          logPath: metadata.logPath ?? undefined,
+          servers: Array.from(managedServers.values()).map((def) => {
+            const entry = activity.get(def.name);
+            return {
+              name: def.name,
+              connected: Boolean(entry?.connected),
+              lastUsedAt: entry?.lastUsedAt,
+            };
+          }),
+        };
+        return { response: { id, ok: true, result }, shouldShutdown: false };
+      }
+      case 'stop': {
+        logEvent(logContext, 'Received stop request.');
+        return {
+          response: { id, ok: true, result: true },
+          shouldShutdown: true,
+        };
+      }
+      default:
+        return {
+          response: buildErrorResponse(id, 'unknown_method'),
+          shouldShutdown: false,
+        };
+    }
+  } catch (error) {
+    return {
+      response: buildErrorResponse(id, 'runtime_error', error),
+      shouldShutdown: false,
+    };
+  }
+}
+
+export async function __testProcessRequest(
+  rawPayload: string,
+  runtime: Runtime,
+  managedServers: Map<string, ServerDefinition>,
+  activity: Map<string, ServerActivity>,
+  metadata: {
+    configPath: string;
+    configLayers: Array<{ path: string; mtimeMs: number | null }>;
+    configMtimeMs: number | null;
+    socketPath: string;
+    startedAt: number;
+    logPath: string | null;
+  },
+  logContext: LogContext,
+  preParsedRequest?: DaemonRequest
+): Promise<{ response: DaemonResponse; shouldShutdown: boolean }> {
+  return await processRequest(rawPayload, runtime, managedServers, activity, metadata, logContext, preParsedRequest);
+}

package/src/daemon/launch.ts

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+
+export interface DaemonLaunchOptions {
+  readonly configPath: string;
+  readonly configExplicit?: boolean;
+  readonly rootDir?: string;
+  readonly socketPath: string;
+  readonly metadataPath: string;
+  readonly extraArgs?: string[];
+}
+
+export function launchDaemonDetached(options: DaemonLaunchOptions): void {
+  const cliEntry = resolveCliEntry();
+  const configArgs = options.configExplicit ? ['--config', options.configPath] : [];
+  const args = [
+    ...process.execArgv,
+    cliEntry,
+    ...configArgs,
+    ...(options.rootDir ? ['--root', options.rootDir] : []),
+    'daemon',
+    'start',
+    '--foreground',
+    ...(options.extraArgs ?? []),
+  ];
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      MCPORTER_DAEMON_CHILD: '1',
+      MCPORTER_DAEMON_SOCKET: options.socketPath,
+      MCPORTER_DAEMON_METADATA: options.metadataPath,
+    },
+  });
+  child.unref();
+}
+
+function resolveCliEntry(): string {
+  const entry = process.argv[1];
+  if (!entry) {
+    throw new Error('Unable to resolve mcporter entry script.');
+  }
+  return path.resolve(entry);
+}

package/src/daemon/log-context.ts

@@ -0,0 +1,78 @@
+import fsSync from 'node:fs';
+import path from 'node:path';
+
+export interface LogContext {
+  enabled: boolean;
+  logAllServers: boolean;
+  servers: Set<string>;
+  writer?: fsSync.WriteStream;
+}
+
+export function createLogContext(options: {
+  enabled: boolean;
+  logAllServers: boolean;
+  servers: Set<string>;
+  logPath?: string;
+}): LogContext {
+  const derivedEnabled = options.enabled || options.logAllServers || options.servers.size > 0;
+  const context: LogContext = {
+    enabled: derivedEnabled,
+    logAllServers: options.logAllServers,
+    servers: options.servers,
+  };
+  if (derivedEnabled && options.logPath) {
+    try {
+      fsSync.mkdirSync(path.dirname(options.logPath), { recursive: true });
+      context.writer = fsSync.createWriteStream(options.logPath, {
+        flags: 'a',
+      });
+    } catch (error) {
+      console.warn(`[daemon] Failed to open log file ${options.logPath}: ${(error as Error).message}`);
+    }
+  }
+  return context;
+}
+
+export function logEvent(context: LogContext, message: string): void {
+  if (!context.enabled) {
+    return;
+  }
+  const line = `[daemon] ${new Date().toISOString()} ${message}`;
+  console.log(line);
+  try {
+    context.writer?.write(`${line}\n`);
+  } catch {
+    // ignore file write failures
+  }
+}
+
+export async function disposeLogContext(context: LogContext): Promise<void> {
+  const writer = context.writer;
+  if (!writer) {
+    return;
+  }
+  await new Promise<void>((resolve) => {
+    writer.end(() => resolve());
+    writer.on('error', () => resolve());
+  });
+}
+
+export function shouldLogServer(context: LogContext, server: string): boolean {
+  if (!context.enabled) {
+    return false;
+  }
+  if (context.logAllServers) {
+    return true;
+  }
+  return context.servers.has(server);
+}
+
+export function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === 'string') {
+    return error;
+  }
+  return 'unknown';
+}

package/src/daemon/paths.ts

@@ -0,0 +1,35 @@
+import os from 'node:os';
+import path from 'node:path';
+import { expandHome } from '../env.js';
+
+function resolveBaseDir(): string {
+  const override = process.env.MCPORTER_DAEMON_DIR;
+  if (override && override.trim().length > 0) {
+    return path.resolve(expandHome(override.trim()));
+  }
+  return path.join(os.homedir(), '.mcporter');
+}
+
+function ensureRunDir(): string {
+  return path.join(resolveBaseDir(), 'daemon');
+}
+
+export function getDaemonMetadataPath(configKey: string): string {
+  return path.join(ensureRunDir(), `daemon-${configKey}.json`);
+}
+
+export function getDaemonSocketPath(configKey: string): string {
+  const runDir = ensureRunDir();
+  if (process.platform === 'win32') {
+    return `\\\\.\\pipe\\mcporter-daemon-${configKey}`;
+  }
+  return path.join(runDir, `daemon-${configKey}.sock`);
+}
+
+export function getDaemonLogPath(configKey: string): string {
+  return path.join(ensureRunDir(), `daemon-${configKey}.log`);
+}
+
+export function getDaemonDir(): string {
+  return ensureRunDir();
+}

package/src/daemon/protocol.ts

@@ -0,0 +1,57 @@
+export type DaemonRequestMethod = 'callTool' | 'listTools' | 'listResources' | 'closeServer' | 'status' | 'stop';
+
+export interface DaemonRequest<T extends DaemonRequestMethod = DaemonRequestMethod, P = unknown> {
+  readonly id: string;
+  readonly method: T;
+  readonly params: P;
+}
+
+export interface DaemonResponse<T = unknown> {
+  readonly id: string;
+  readonly ok: boolean;
+  readonly result?: T;
+  readonly error?: {
+    readonly message: string;
+    readonly code?: string;
+  };
+}
+
+export interface CallToolParams {
+  readonly server: string;
+  readonly tool: string;
+  readonly args?: Record<string, unknown>;
+  readonly timeoutMs?: number;
+}
+
+export interface ListToolsParams {
+  readonly server: string;
+  readonly includeSchema?: boolean;
+  readonly autoAuthorize?: boolean;
+}
+
+export interface ListResourcesParams {
+  readonly server: string;
+  readonly params?: Record<string, unknown>;
+}
+
+export interface CloseServerParams {
+  readonly server: string;
+}
+
+export interface StatusResult {
+  readonly pid: number;
+  readonly startedAt: number;
+  readonly configPath: string;
+  readonly configMtimeMs?: number | null;
+  readonly configLayers?: Array<{
+    readonly path: string;
+    readonly mtimeMs: number | null;
+  }>;
+  readonly socketPath: string;
+  readonly logPath?: string;
+  readonly servers: Array<{
+    readonly name: string;
+    readonly connected: boolean;
+    readonly lastUsedAt?: number;
+  }>;
+}