fa-mcp-sdk 0.2.87 → 0.2.92

package/bin/fa-mcp.js

@@ -13,6 +13,7 @@ const PRINT_FILLED = true;
 
 const hl = (v) => chalk.bgGreen.black(v);
 const hly = (v) => chalk.bgYellow.black(v);
+const hp = (paramName) => ` [${chalk.magenta(paramName)}]`;
 const formatDefaultValue = (v) => (v ? ` (default: ${hl(v)})` : '');
 const OPTIONAL = chalk.gray(' (optional)');
 const FROM_CONFIG = chalk.gray(' (from config)');
@@ -20,7 +21,7 @@ const trim = (s) => String(s || '').trim();
 
 const printFilled = (paramName, paramValue) => {
   if (PRINT_FILLED) {
-    console.log(`   ${paramName}: ${hl(paramValue)}`);
+    console.log(`  ${hp(paramName)}: ${hl(paramValue)}`);
   }
 };
 
@@ -46,7 +47,7 @@ const getAsk = () => {
     optional: (title, paramName, defaultValue, example = undefined) => new Promise(resolve => {
       const defaultText = formatDefaultValue(defaultValue);
       example = example ? ` (example: ${example})` : '';
-      const prompt = `${title} [${paramName}]${defaultText}${example}${OPTIONAL}: `;
+      const prompt = `${title}${hp(paramName)}${defaultText}${example}${OPTIONAL}: `;
       rl.question(prompt, (v) => {
         resolve(trim(v) || trim(defaultValue));
       });
@@ -57,8 +58,8 @@ const getAsk = () => {
       const y = isTrue ? `${hl('y')}` : 'y';
       const n = isTrue ? 'n' : `${hl('n')}`;
 
-      paramName = paramName ? ` [${paramName}]` : '';
-      const prompt = `${title}${paramName} (${y}/${n}): `;
+      const hpn = paramName ? hp(paramName) : '';
+      const prompt = `${title}${hpn} (${y}/${n}): `;
       while (true) {
         const answer = await yn_(prompt, defaultValue === 'true' ? 'y' : 'n');
         if (answer === 'y' || answer === 'n') {
@@ -171,6 +172,13 @@ class MCPGenerator {
         defaultValue: '',
         title: 'Domain name for nginx configuration',
       },
+      {
+        name: 'ssl-wildcard.conf.rel.path',
+        defaultValue: 'snippets/ssl-wildcard.conf',
+        title: `The relative path to the nginx configuration file 
+in the /etc/nginx folder that specifies the SSL 
+certificate's public and private keys`,
+      },
 
       {
         name: 'webServer.auth.enabled',
@@ -201,8 +209,9 @@ class MCPGenerator {
         name: 'NODE_ENV',
       },
       {
-        skip: true,
         name: 'SERVICE_INSTANCE',
+        defaultValue: '',
+        title: 'Suffix of the service name in Consul and process manager',
       },
       {
         skip: true,
@@ -213,6 +222,17 @@ class MCPGenerator {
         defaultValue: '',
         title: 'Maintainer url',
       },
+      {
+        name: 'logger.useFileLogger',
+        defaultValue: '',
+        title: 'Whether to check MCP name in the token',
+      },
+      {
+        skip: true,
+        name: 'logger.dir',
+        defaultValue: '',
+        title: 'Папка, куда будут записываться логи',
+      },
     ];
   }
 
@@ -430,14 +450,28 @@ class MCPGenerator {
           value = await ask.optional(title, name, defaultValue);
           if (value) {
             // Auto-generate upstream from mcp.domain by replacing dots with dashes
-            config['upstream'] = value.replace(/\./g, '-');
+            config.upstream = value.replace(/\./g, '-');
           }
           continue;
 
         case 'maintainerUrl':
           value = await ask.optional(title, name, defaultValue);
           if (value) {
-            config['maintainerHtml'] = `<a href="${value}" target="_blank" rel="noopener" class="clickable">Support</a>`;
+            config.maintainerHtml = `<a href="${value}" target="_blank" rel="noopener" class="clickable">Support</a>`;
+          }
+          continue;
+        case 'logger.useFileLogger':
+          const enabled = await ask.yn(title, name, defaultValue);
+          config[name] = String(enabled);
+          if (enabled) {
+            const nm = 'logger.dir';
+            const p = this.optionalParams.find(({ name: n }) => n === nm);
+            value = await ask.optional(p.title, nm, config[nm] || p.defaultValue);
+            if (value) {
+              config[nm] = value;
+            }
+          } else {
+            config[nm] = '';
           }
           continue;
         default:
@@ -518,6 +552,11 @@ class MCPGenerator {
     // Loop until configuration is confirmed
     while (!confirmed) {
       await this.collectConfigData(configProxy, isRetry);
+
+      // Set NODE_ENV and PM2_NAMESPACE based on isProduction
+      config.NODE_ENV = config.isProduction === 'true' ? 'production' : 'development';
+      config.PM2_NAMESPACE = config.isProduction === 'true' ? 'prod' : 'dev';
+
       confirmed = await this.confirmConfiguration(config);
 
       if (!confirmed) {

package/cli-template/.env.example

@@ -1,6 +1,4 @@
 SERVICE_NAME={{project.name}}
-# Used as an alternate service name when using systemd
-SERVICE_NAME_ALT={{project.name}}
 NODE_ENV={{NODE_ENV}}
 # Used for PM2
 SERVICE_INSTANCE={{SERVICE_INSTANCE}}

package/cli-template/config/_local.yaml

@@ -15,7 +15,7 @@ consul:
       token: '{{consul.agent.reg.token}}'
   service:
     enable: {{consul.service.enable}} # true - Allows registration of the service with the consul
-    instance: 'instance-0' # This value will be specified as a suffix in the id of the service
+    instance: '{{SERVICE_INSTANCE}}' # This value will be specified as a suffix in the id of the service
   envCode: # Used to generate the service ID
     prod: '{{consul.envCode.prod}}' # Production environment code
     dev: '{{consul.envCode.dev}}' # Development environment code
@@ -35,7 +35,8 @@ db:
 
 logger:
   level: info
-  useFileLogger: true # To use or not to use logging to a file
+  useFileLogger: {{logger.useFileLogger}} # To use or not to use logging to a file
+  dir: '{{logger.dir}}'
 
 mcp:
   transportType: http # 'stdio' or 'http'

package/cli-template/config/default.yaml

@@ -15,6 +15,7 @@ consul:
     timeout: '5s'
     deregistercriticalserviceafter: '3m'
   agent:
+    # Credentials for getting information about services in the DEV DC
     dev:
       dc: '{{consul.agent.dev.dc}}'
       host: '{{consul.agent.dev.host}}'
@@ -22,6 +23,7 @@ consul:
       secure: true
       # Token for getting information about DEV services
       token: '***'
+    # Credentials for getting information about services in the PROD DC
     prd:
       dc: '{{consul.agent.prd.dc}}'
       host: '{{consul.agent.prd.host}}'
@@ -29,8 +31,10 @@ consul:
       secure: true
       # Token for obtaining information about PROD services
       token: '***'
+    # Credentials for registering the service with Consul
     reg:
-      host: null # The host of the consul agent where the service will be registered. If not specified, the server on which the service is running is used
+      # The host of the consul agent where the service will be registered. If not specified, the server on which the service is running is used
+      host: null
       port: 8500
       secure: false
       # Token for registering the service in the consul agent
@@ -38,7 +42,7 @@ consul:
   service:
     enable: {{consul.service.enable}} # true - Allows registration of the service with the consul
     name: <name> # <name> will be replaced by <package.json>.name at initialization
-    instance: 'instance-0' # This value will be specified as a suffix in the id of the service
+    instance: '{{SERVICE_INSTANCE}}' # This value will be specified as a suffix in the id of the service
     version: <version> # <version> will be replaced by <package.json>.version at initialization
     description: <description> # <description> will be replaced by <package.json>.description at initialization
     tags: [] # If null or empty array - Will be pulled up from package.keywords at initialization
@@ -63,7 +67,8 @@ db:
 
 logger:
   level: info
-  useFileLogger: true # To use or not to use logging to a file
+  useFileLogger: {{logger.useFileLogger}} # To use or not to use logging to a file
+  dir: '{{logger.dir}}'
 
 mcp:
   transportType: http # stdio | http
@@ -77,12 +82,17 @@ mcp:
 
 swagger:
   servers:  # An array of servers that will be added to swagger docs
-    - url: http://localhost:{{port}}
-      description: "Development server (localhost)"
-    - url: http://0.0.0.0:{{port}}
-      description: "Development server (all interfaces)"
+    # - url: http://localhost:9020
+    #   description: "Development server (localhost)"
+    # - url: http://0.0.0.0:9020
+    #   description: "Development server (all interfaces)"
+    # - url: http://<prod_server_host_or_ip>:{{port}}
+    #   description: "PROD server"
+    - url: https://{{mcp.domain}}
+      description: "PROD server"
 
-uiColor:  # Font color of the header and a number of interface elements on the ABOUT page
+uiColor:
+  # Font color of the header and a number of interface elements on the ABOUT page
   primary: '#0f65dc'
 
 webServer:

package/cli-template/deploy/{mcp-template.com.conf → NGINX/sites-enabled/mcp-template.com.conf}

@@ -40,7 +40,7 @@ server {
     }
 
     listen 443 ssl http2;
-    include snippets/ssl-wildcard-finam-ru.conf;
+    include {{ssl-wildcard.conf.rel.path}};
     include snippets/ssl-params.conf;
     ssl_protocols  TLSv1.3;
 }

package/cli-template/deploy/NGINX/snippets/ssl-params.conf

@@ -0,0 +1,18 @@
+ssl_protocols TLSv1.2;
+ssl_prefer_server_ciphers on;
+ssl_dhparam /etc/nginx/dhparam.pem;
+ssl_ciphers ECDHE-RSA-AES256-GCM-SHA512:DHE-RSA-AES256-GCM-SHA512:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA384;
+ssl_ecdh_curve secp384r1; # Requires nginx >= 1.1.0
+ssl_session_timeout  10m;
+ssl_session_cache shared:SSL:10m;
+ssl_session_tickets off; # Requires nginx >= 1.5.9
+ssl_stapling off; # Requires nginx >= 1.3.7
+ssl_stapling_verify on; # Requires nginx => 1.3.7
+resolver 8.8.8.8 8.8.4.4 valid=300s;
+resolver_timeout 5s;
+# Disable strict transport security for now. You can uncomment the following
+# line if you understand the implications.
+# add_header Strict-Transport-Security "max-age=63072000; includeSubDomains; preload";
+add_header X-Frame-Options DENY;
+add_header X-Content-Type-Options nosniff;
+add_header X-XSS-Protection "1; mode=block";

package/cli-template/deploy/NGINX/snippets/ssl-wildcard.conf

@@ -0,0 +1,3 @@
+# Provide the correct paths to the certificate and private key
+ssl_certificate /etc/nginx/cert/wildcard.crt;
+ssl_certificate_key /etc/nginx/cert/wildcard.key;

package/cli-template/deploy/srv.cjs

@@ -0,0 +1,449 @@
+#!/usr/bin/env node
+
+/**
+ * srv.cjs - Unified systemd service management script (Node.js version)
+ * Analog of deploy/srv.sh
+ * Can be run from project root or from deploy/ directory
+ */
+
+/* Colors for output */
+const c = '\x1b[1;36m', lc = '\x1b[0;36m';
+const g = '\x1b[1;32m', lg = '\x1b[0;32m';
+const m = '\x1b[1;35m', lm = '\x1b[0;35m';
+const r = '\x1b[1;31m', lr = '\x1b[0;31m';
+const y = '\x1b[1;33m', ly = '\x1b[0;33m';
+const c0 = '\x1b[0m';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync, spawn, spawnSync } = require('child_process');
+
+/* Script configuration */
+const SCRIPT_DIR = __dirname; // deploy/
+const PROJECT_ROOT = path.resolve(SCRIPT_DIR, '..'); // Project root
+process.chdir(PROJECT_ROOT);
+
+let SERVICE_NAME = '';
+let NODE_VERSION = '';
+let PORT = '';
+let COMMAND = '';
+
+const trim = (v) => String(v || '').trim();
+
+/* Helpers */
+function log (...args) { console.log(...args); }
+
+function err (...args) { console.error(...args); }
+
+function sh (cmd, opts = {}) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], ...opts }).trim();
+  } catch (e) {
+    // Attach stderr to error message for easier diagnosis
+    const stderr = e.stderr ? e.stderr.toString() : '';
+    const stdout = e.stdout ? e.stdout.toString() : '';
+    const msg = stderr || stdout || e.message;
+    const errObj = new Error(msg);
+    errObj.code = e.status;
+    throw errObj;
+  }
+}
+
+function showUsage () {
+  const usage = `
+Usage:
+  ${process.argv[1]} i|install [-n <service_name>] [-v <node_version>]
+  ${process.argv[1]} d|delete  [-n <service_name>] [-p <port>]
+  ${process.argv[1]} r|reinstall [-n <service_name>] [-p <port>] [-v <node_version>]
+
+Commands:
+  i, install    - Install and start systemd service
+  d, delete     - Stop and remove systemd service
+  r, reinstall  - Reinstall service (delete + install)
+
+Options:
+  -n <name>     - Alternative service name (default: from package.json)
+  -v <version>  - Node.js version (default: auto-detected)
+  -p <port>     - Port number for service cleanup (default: auto-detected)
+
+Working directories:
+  Script location: ${SCRIPT_DIR}
+  Project root: ${PROJECT_ROOT}
+`.trim();
+  log(usage);
+}
+
+function serviceExists (name) {
+  try {
+    const cmd = `systemctl list-units --all -t service --full --no-legend ${name}.service`;
+    const out = sh(cmd, { shell: '/bin/bash' });
+    const re = new RegExp(`\\b${name}\\.service\\b`);
+    return re.test(out);
+  } catch {
+    return false;
+  }
+}
+
+function readFileSafe (p) {
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+function detectNodeVersion () {
+  let version = '';
+  if (NODE_VERSION) {
+    version = NODE_VERSION;
+    err(`${c}**** Using provided Node.js version: ${g}${version}${c} ****${c0}`);
+  } else {
+    const envrc = path.join(PROJECT_ROOT, '.envrc');
+    if (fs.existsSync(envrc)) {
+      const content = readFileSafe(envrc);
+      const m = content.match(/^\s*nvm\s+use\s+([0-9]+\.[0-9]+\.[0-9]+)/m);
+      if (m) {
+        version = m[1];
+        err(`${c}**** Found Node.js version in .envrc: ${g}${version}${c} ****${c0}`);
+      }
+    }
+  }
+  if (!version) {
+    try {
+      const v = sh('node -v 2>/dev/null', { shell: '/bin/bash' });
+      version = v.replace(/^v/, '');
+      if (version) {
+        err(`${c}**** Using current Node.js version: ${g}${version}${c} ****${c0}`);
+      }
+    } catch {
+      // ignore
+    }
+  }
+  if (!version) {
+    err(`${r}**** Error: Could not detect Node.js version ****${c0}`);
+    process.exit(1);
+  }
+  return version;
+}
+
+function findNodePath (version) {
+  // Try NVM path first
+  const nvmPath = path.join(os.homedir(), '.nvm', 'versions', 'node', `v${version}`, 'bin', 'node');
+  if (fs.existsSync(nvmPath)) {
+    err(`${c}**** Found Node.js at NVM path: ${g}${nvmPath}${c} ****${c0}`);
+    return nvmPath;
+  }
+  // Try system node
+  try {
+    const whichNode = sh('which node 2>/dev/null', { shell: '/bin/bash' });
+    if (whichNode) {
+      let currentVersion = '';
+      try { currentVersion = sh('node -v 2>/dev/null', { shell: '/bin/bash' }).replace(/^v/, ''); } catch {}
+      if (currentVersion === version) {
+        err(`${c}**** Found Node.js at system path: ${g}${whichNode}${c} ****${c0}`);
+      } else {
+        const warn = `
+${y}**** Warning: System Node.js version (${currentVersion}) differs from target (${version}) ****${c0}
+${c}**** Using system path anyway: ${g}${whichNode}${c} ****${c0}
+`.trim();
+        err(warn);
+      }
+      return whichNode;
+    }
+  } catch {
+    // ignore
+  }
+  err(`${r}**** Error: Could not find Node.js binary ****${c0}`);
+  process.exit(1);
+}
+
+function parsePackageJson (field) {
+  const packageFile = path.join(PROJECT_ROOT, 'package.json');
+  if (!fs.existsSync(packageFile)) {
+    err(`${r}**** Error: package.json not found at ${packageFile} ****${c0}`);
+    process.exit(1);
+  }
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageFile, 'utf8'));
+    const value = pkg[field] || '';
+    if (!value) throw new Error('empty');
+    return value;
+  } catch {
+    err(`${r}**** Error: Could not parse ${field} from package.json ****${c0}`);
+    process.exit(1);
+  }
+}
+
+// Parse .env in project root to extract variables
+function parseDotEnvVars () {
+  const envPath = path.join(PROJECT_ROOT, '.env');
+  const result = {};
+  if (!fs.existsSync(envPath)) return result;
+  try {
+    const content = fs.readFileSync(envPath, 'utf8');
+    // Simple line parser, ignores comments and empty lines
+    for (const line of content.split(/\r?\n/)) {
+      if (!line || /^\s*#/.test(line)) continue;
+      const m = line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$/);
+      if (!m) continue;
+      const key = m[1];
+      // remove surrounding quotes if present
+      let val = m[2];
+      const q = val[0];
+      if ((q === '"' || q === '\'') && val[val.length - 1] === q) {
+        val = val.slice(1, -1);
+      }
+      result[key] = val;
+    }
+  } catch {}
+  return result;
+}
+
+// Return full service name aligned with update.cjs logic: base name plus optional "--<instance>"
+function getServiceName () {
+  // Highest priority: CLI parameter (-n)
+  let baseName = trim(SERVICE_NAME);
+  if (baseName) {
+    return baseName;
+  }
+  let instance = '';
+
+  const envVars = parseDotEnvVars();
+
+  // If base name not provided via CLI, try from .env, then from package.json
+  if (!baseName) {
+    baseName = trim(envVars.SERVICE_NAME);
+  }
+  if (!baseName) {
+    baseName = parsePackageJson('name');
+  }
+
+  // Instance suffix from .env if present
+  const rawInstance = trim(envVars.SERVICE_INSTANCE);
+  if (rawInstance) {
+    instance = `--${rawInstance}`;
+  }
+
+  return `${baseName}${instance}`;
+}
+
+async function detectPort () {
+  if (PORT) return PORT;
+  // Try to load config from project root
+  try {
+    // Ensure module resolution relative to project root
+    const createRequire = require('module').createRequire;
+    const projectRequire = createRequire(path.join(PROJECT_ROOT, 'package.json'));
+    let cfg;
+    try {
+      cfg = projectRequire('config');
+    } catch (e) {
+      // Try dynamic import
+      cfg = await new Function('p', 'return import(p)')('config');
+      cfg = cfg.default || cfg;
+    }
+    const port = cfg?.webServer?.port;
+    if (port && String(port).match(/^[0-9]{2,5}$/)) return String(port);
+  } catch (e) {
+    // ignore, will fail below
+  }
+  err(`${r}**** Error: Could not detect port from config ****${c0}`);
+  process.exit(1);
+}
+
+function generateUnitFile (serviceName, nodePath, mainFile) {
+  const workingDir = PROJECT_ROOT;
+  const serviceFile = `/etc/systemd/system/${serviceName}.service`;
+  const content = `
+[Unit]
+Description=${serviceName}
+After=network.target
+# https://www.freedesktop.org/software/systemd/man/latest/systemd.unit.html#StartLimitIntervalSec=interval
+StartLimitIntervalSec=0
+
+[Service]
+User=root
+WorkingDirectory=${workingDir}
+EnvironmentFile=${workingDir}/.env
+ExecStart=${nodePath} ${mainFile}
+Restart=always
+RestartSec=3
+
+[Install]
+WantedBy=multi-user.target
+`.trimStart();
+  fs.writeFileSync(serviceFile, content, 'utf8');
+  const info = `
+${c}**** Generated unit file for ${g}${serviceName}${c} ****${c0}
+${lc}   WorkingDirectory: ${g}${workingDir}${c0}
+${lc}   ExecStart: ${g}${nodePath} ${mainFile}${c0}
+${lc}   View Service file: ${g}cat ${serviceFile}${c0}
+`.trim();
+  err(info);
+}
+
+function systemctl (args, inherit = false) {
+  if (inherit) {
+    const p = spawn('systemctl', args.split(/\s+/).filter(Boolean), { stdio: 'inherit' });
+    return new Promise((resolve, reject) => {
+      p.on('exit', code => code === 0 ? resolve() : reject(new Error(`systemctl ${args} exited with ${code}`)));
+    });
+  } else {
+    sh(`systemctl ${args}`);
+  }
+}
+
+async function installService () {
+  log(`${c}**** Installing service ****${c0}`);
+  const nodeVersion = detectNodeVersion();
+  const nodePath = findNodePath(nodeVersion);
+  const mainFile = parsePackageJson('main');
+  const serviceName = getServiceName();
+
+  const cfgInfo = `
+${c}**** Service configuration ****${c0}
+${lc}   Service name: ${g}${serviceName}${c0}
+${lc}   Node.js version: ${g}${nodeVersion}${c0}
+${lc}   Node.js path: ${g}${nodePath}${c0}
+${lc}   Main file: ${g}${mainFile}${c0}
+${lc}   Project root: ${g}${PROJECT_ROOT}${c0}
+`.trim();
+  err(cfgInfo);
+
+  if (serviceExists(serviceName)) {
+    err(`${c}**** Service ${g}${serviceName}${c} already installed ****${c0}`);
+    return;
+  }
+
+  generateUnitFile(serviceName, nodePath, mainFile);
+
+  // Reload systemd and enable service
+  sh('systemctl daemon-reload');
+  try {
+    sh(`systemctl enable --now ${serviceName}`);
+  } catch (e) {
+    const msg = `
+${r}**** Error: Failed to install service ${serviceName} ****${c0}
+${e.message || String(e)}
+`.trim();
+    err(msg);
+    process.exit(1);
+  }
+
+  const post = `
+${c}**** Service ${g}${serviceName}${c} installed and started ****${c0}
+
+${m}View status: ${y}systemctl -l status ${serviceName}${c0}
+${m}View logs: ${y}journalctl -o cat -xefu ${serviceName}${c0}
+`.trim();
+  log(post);
+}
+
+async function deleteService () {
+  const serviceName = getServiceName();
+  const port = await detectPort();
+  log(`${c}**** Removing service ${g}${serviceName}${c} listening on port ${g}${port}${c} ****${c0}`);
+
+  if (!serviceExists(serviceName)) {
+    log(`${c}**** Service ${g}${serviceName}${c} not found ****${c0}`);
+    return;
+  }
+
+  try { sh(`systemctl stop ${serviceName}`); } catch {}
+  try { sh(`systemctl disable ${serviceName}`); } catch {}
+
+  try { fs.unlinkSync(`/etc/systemd/system/${serviceName}.service`); } catch {}
+
+  // Kill any remaining process on the port
+  try {
+    const out = sh(`lsof -i tcp:${port} 2>/dev/null | grep ${port} | awk '{print $2}' | head -1`, { shell: '/bin/bash' });
+    if (out) {
+      log(`${c}**** Killing process ${g}${out}${c} on port ${g}${port}${c} ****${c0}`);
+      try { sh(`kill -9 ${out}`); } catch {}
+    }
+  } catch {}
+
+  try { sh('systemctl daemon-reload'); } catch {}
+  log(`${c}**** Service ${g}${serviceName}${c} removed ****${c0}`);
+}
+
+async function reinstallService () {
+  log(`${c}**** Reinstalling service ****${c0}`);
+  await deleteService();
+  await installService();
+  const serviceName = getServiceName();
+  log(`${c}**** Service ${g}${serviceName}${c} reinstalled ****${c0}`);
+
+  try {
+    await systemctl(`status ${serviceName}`, true);
+  } catch {}
+  log(`\n${m}Following logs (Ctrl+C to exit): ${y}journalctl -o cat -xefu ${serviceName}${c0}`);
+  // Follow logs until user interrupts
+  const p = spawn('journalctl', ['-o', 'cat', '-xefu', serviceName], { stdio: 'inherit' });
+  await new Promise(resolve => p.on('exit', resolve));
+}
+
+/* Argument parsing */
+async function main () {
+  if (process.argv.length <= 2) {
+    showUsage();
+    process.exit(1);
+  }
+
+  const args = process.argv.slice(2);
+  const cmd = args.shift();
+  switch (cmd) {
+    case 'i':
+    case 'install':
+      COMMAND = 'install';
+      break;
+    case 'd':
+    case 'delete':
+      COMMAND = 'delete';
+      break;
+    case 'r':
+    case 'reinstall':
+      COMMAND = 'reinstall';
+      break;
+    default:
+      err(`${r}**** Error: Unknown command '${cmd}' ****${c0}`);
+      showUsage();
+      process.exit(1);
+  }
+
+  // Parse options
+  while (args.length > 0) {
+    const a = args.shift();
+    switch (a) {
+      case '-n':
+        SERVICE_NAME = args.shift() || '';
+        break;
+      case '-v':
+        NODE_VERSION = args.shift() || '';
+        break;
+      case '-p':
+        PORT = args.shift() || '';
+        break;
+      default:
+        err(`${r}**** Error: Unknown option '${a}' ****${c0}`);
+        showUsage();
+        process.exit(1);
+    }
+  }
+
+  switch (COMMAND) {
+    case 'install':
+      await installService();
+      break;
+    case 'delete':
+      await deleteService();
+      break;
+    case 'reinstall':
+      await reinstallService();
+      break;
+  }
+}
+
+main().then(() => {
+  process.exit(0);
+}).catch(e => {
+  err(String(e && e.message ? e.message : e));
+  process.exit(1);
+});