mcp-config-manager 1.0.2 → 1.0.4

package/README.md

@@ -101,11 +101,32 @@ npm run web
 
 ### Web UI
 
-Start the web server:
+#### Development (when cloning repository)
 ```bash
 npm run web
-# or
-mcp-manager web --port 3456
+```
+
+#### Global Installation
+After installing globally with `npm install -g mcp-config-manager`:
+
+**Start web server in foreground:**
+```bash
+mcp-config-manager web --port 3456
+```
+
+**Start web server as background daemon:**
+```bash
+mcp-config-manager start --port 3456
+```
+
+**Check daemon status:**
+```bash
+mcp-config-manager status
+```
+
+**Stop daemon:**
+```bash
+mcp-config-manager stop
 ```
 
 Then open http://localhost:3456 in your browser.

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "mcp-config-manager",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Simple CLI and web UI to manage MCP configs across multiple AI clients",
   "main": "src/cli.js",
   "bin": {
+    "mcp-config-manager": "src/cli.js",
     "mcp-manager": "src/cli.js"
   },
   "scripts": {

package/src/cli.js

@@ -6,7 +6,7 @@ import { MCPConfigManager } from './config-manager.js';
 const manager = new MCPConfigManager();
 
 program
-  .name('mcp-manager')
+  .name('mcp-config-manager')
   .description('CLI to manage MCP configurations across different AI clients')
   .version('1.0.0');
 
@@ -383,12 +383,108 @@ program
   .command('web')
   .description('Start the web UI server')
   .option('-p, --port <port>', 'Port to run the server on', '3456')
+  .option('-d, --daemon', 'Run in background as daemon')
   .action(async (options) => {
-    console.log(`Starting web UI server on port ${options.port}...`);
-    console.log(`Open http://localhost:${options.port} in your browser`);
+    if (options.daemon) {
+      const { spawn } = await import('child_process');
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const os = await import('os');
+
+      const pidFile = path.join(os.tmpdir(), 'mcp-config-manager.pid');
+
+      try {
+        // Check if daemon is already running
+        const existingPid = await fs.readFile(pidFile, 'utf8');
+        const { execSync } = await import('child_process');
+        try {
+          execSync(`kill -0 ${existingPid}`, { stdio: 'ignore' });
+          console.log(`Web UI server already running on port ${options.port} (PID: ${existingPid})`);
+          console.log(`Open http://localhost:${options.port} in your browser`);
+          return;
+        } catch {
+          // Process not running, remove stale pid file
+          await fs.unlink(pidFile);
+        }
+      } catch {
+        // PID file doesn't exist
+      }
+
+      // Start daemon
+      const daemon = spawn(process.execPath, [process.argv[1], 'web', '--port', options.port], {
+        detached: true,
+        stdio: 'ignore'
+      });
+
+      daemon.unref();
+      await fs.writeFile(pidFile, daemon.pid.toString());
+
+      console.log(`Web UI server started as daemon on port ${options.port} (PID: ${daemon.pid})`);
+      console.log(`Open http://localhost:${options.port} in your browser`);
+      console.log(`Use 'mcp-config-manager stop' to stop the server`);
+    } else {
+      console.log(`Starting web UI server on port ${options.port}...`);
+      console.log(`Open http://localhost:${options.port} in your browser`);
+
+      const { startServer } = await import('./server.js');
+      startServer(parseInt(options.port));
+    }
+  });
 
-    const { startServer } = await import('./server.js');
-    startServer(parseInt(options.port));
+program
+  .command('start')
+  .description('Start the web UI server in background')
+  .option('-p, --port <port>', 'Port to run the server on', '3456')
+  .action(async (options) => {
+    // Call web command with daemon option
+    program.parse([process.argv[0], process.argv[1], 'web', '--daemon', '--port', options.port]);
+  });
+
+program
+  .command('stop')
+  .description('Stop the background web UI server')
+  .action(async () => {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const os = await import('os');
+    const { execSync } = await import('child_process');
+
+    const pidFile = path.join(os.tmpdir(), 'mcp-config-manager.pid');
+
+    try {
+      const pid = await fs.readFile(pidFile, 'utf8');
+      execSync(`kill ${pid}`);
+      await fs.unlink(pidFile);
+      console.log(`Web UI server stopped (PID: ${pid})`);
+    } catch (error) {
+      console.log('No running web UI server found');
+    }
+  });
+
+program
+  .command('status')
+  .description('Check status of background web UI server')
+  .action(async () => {
+    const fs = await import('fs/promises');
+    const path = await import('path');
+    const os = await import('os');
+    const { execSync } = await import('child_process');
+
+    const pidFile = path.join(os.tmpdir(), 'mcp-config-manager.pid');
+
+    try {
+      const pid = await fs.readFile(pidFile, 'utf8');
+      try {
+        execSync(`kill -0 ${pid}`, { stdio: 'ignore' });
+        console.log(`Web UI server is running (PID: ${pid})`);
+        console.log(`Open http://localhost:3456 in your browser`);
+      } catch {
+        console.log('Web UI server is not running (stale PID file found)');
+        await fs.unlink(pidFile);
+      }
+    } catch {
+      console.log('Web UI server is not running');
+    }
   });
 
 program.parse();

package/src/config-manager.js

@@ -3,21 +3,46 @@ import path from 'path';
 import os from 'os';
 
 import { CLIENTS as PROD_CLIENTS } from './clients.js';
-import { MOCK_CLIENTS, MOCK_GLOBAL_SERVERS_PATH } from '../test/mock-clients.js';
 
 const USE_MOCK_CLIENTS = process.env.MCP_USE_MOCK_CLIENTS === 'true';
-const CLIENTS = USE_MOCK_CLIENTS ? MOCK_CLIENTS : PROD_CLIENTS;
-const GLOBAL_SERVERS_PATH = USE_MOCK_CLIENTS ? MOCK_GLOBAL_SERVERS_PATH : path.join(os.homedir(), '.mcp-global-servers.json');
 
 export class MCPConfigManager {
   constructor() {
     this.platform = os.platform();
     this.availableClients = {};
+    this.clients = PROD_CLIENTS;
+    this.globalServersPath = path.join(os.homedir(), '.mcp-global-servers.json');
+    this.mockClientsInitialized = false;
+  }
+
+  async initializeMockClients() {
+    if (USE_MOCK_CLIENTS && !this.mockClientsInitialized) {
+      try {
+        const mockModule = await import('../test/mock-clients.js');
+        this.clients = mockModule.MOCK_CLIENTS;
+        this.globalServersPath = mockModule.MOCK_GLOBAL_SERVERS_PATH;
+        this.mockClientsInitialized = true;
+      } catch (error) {
+        console.warn('Mock clients not available, using production clients instead');
+        // Fall back to production clients if mock clients are not available
+      }
+    }
+  }
+
+  async getClients() {
+    await this.initializeMockClients();
+    return this.clients;
+  }
+
+  async getGlobalServersPath() {
+    await this.initializeMockClients();
+    return this.globalServersPath;
   }
 
   async readGlobalServers() {
     try {
-      const content = await fs.readFile(GLOBAL_SERVERS_PATH, 'utf-8');
+      const globalPath = await this.getGlobalServersPath();
+      const content = await fs.readFile(globalPath, 'utf-8');
       return JSON.parse(content);
     } catch (error) {
       if (error.code !== 'ENOENT') {
@@ -29,7 +54,8 @@ export class MCPConfigManager {
   }
 
   async writeGlobalServers(globalServers) {
-    await fs.writeFile(GLOBAL_SERVERS_PATH, JSON.stringify(globalServers, null, 2));
+    const globalPath = await this.getGlobalServersPath();
+    await fs.writeFile(globalPath, JSON.stringify(globalServers, null, 2));
   }
 
   async addGlobalServer(serverName, serverConfig) {
@@ -103,10 +129,11 @@ export class MCPConfigManager {
               configHash: this.getServerConfigHash(serverConfig || {})
             };
           }
+          const configPath = await this.getConfigPath(clientId);
           allServers[serverName].clients.push({
             id: clientId,
             name: clientInfo.name,
-            configPath: this.getConfigPath(clientId)
+            configPath
           });
           // If a server exists globally and in a client, mark it as global
           if (globalServers[serverName]) {
@@ -124,7 +151,8 @@ export class MCPConfigManager {
 
   async detectClients() {
     const detectedClients = {};
-    for (const [id, client] of Object.entries(CLIENTS)) {
+    const clients = await this.getClients();
+    for (const [id, client] of Object.entries(clients)) {
       const configPath = client.configPaths[os.platform()];
       const absoluteConfigPath = path.isAbsolute(configPath) ? configPath : path.join(process.cwd(), configPath);
       try {
@@ -153,19 +181,21 @@ export class MCPConfigManager {
       try {
         const config = await this.readConfig(key);
         const serverCount = Object.keys(config.servers).length;
+        const configPath = await this.getConfigPath(key);
         clientsWithConfigs.push({
           id: key,
           name: client.name,
-          configPath: this.getConfigPath(key),
+          configPath,
           serverCount,
           exists: true
         });
       } catch (error) {
         console.error(`Error processing client ${key}:`, error.message);
+        const configPath = await this.getConfigPath(key);
         clientsWithConfigs.push({
           id: key,
           name: client.name,
-          configPath: this.getConfigPath(key),
+          configPath,
           serverCount: 0,
           exists: false
         });
@@ -175,8 +205,9 @@ export class MCPConfigManager {
     return clientsWithConfigs;
   }
 
-  getConfigPath(client) {
-    const clientConfig = CLIENTS[client];
+  async getConfigPath(client) {
+    const clients = await this.getClients();
+    const clientConfig = clients[client];
     if (!clientConfig) {
       throw new Error(`Unknown client: ${client}`);
     }
@@ -189,13 +220,14 @@ export class MCPConfigManager {
   }
 
   async readConfig(client) {
-    const configPath = this.getConfigPath(client);
+    const configPath = await this.getConfigPath(client);
     let clientConfig = { servers: {} };
 
     try {
       const content = await fs.readFile(configPath, 'utf-8');
       const parsedContent = JSON.parse(content);
-      clientConfig = this.normalizeConfig(parsedContent, CLIENTS[client].format);
+      const clients = await this.getClients();
+      clientConfig = this.normalizeConfig(parsedContent, clients[client].format);
     } catch (error) {
       if (error.code !== 'ENOENT') {
         throw error;
@@ -239,8 +271,9 @@ export class MCPConfigManager {
   }
 
   async writeConfig(client, config) {
-    const configPath = this.getConfigPath(client);
-    const clientConfig = CLIENTS[client];
+    const configPath = await this.getConfigPath(client);
+    const clients = await this.getClients();
+    const clientConfig = clients[client];
 
     let originalConfig = {};
     try {
@@ -396,8 +429,9 @@ export class MCPConfigManager {
 
   async getAllEnvironmentVariables() {
     const envVarMap = new Map();
+    const clients = await this.getClients();
 
-    for (const [clientId, clientInfo] of Object.entries(CLIENTS)) {
+    for (const [clientId, clientInfo] of Object.entries(clients)) {
       try {
         const config = await this.readConfig(clientId);
 
@@ -430,8 +464,9 @@ export class MCPConfigManager {
 
   async updateEnvironmentVariableAcrossConfigs(envKey, newValue, targetServers = null) {
     const results = [];
+    const clients = await this.getClients();
 
-    for (const [clientId, clientInfo] of Object.entries(CLIENTS)) {
+    for (const [clientId, clientInfo] of Object.entries(clients)) {
       try {
         const config = await this.readConfig(clientId);
         let configModified = false;