magalh 1.0.13 → 1.0.15

package/bin/mgl.js

@@ -8,255 +8,391 @@ const { spawn, execFileSync } = require("child_process");
 
 const args = process.argv.slice(2);
 const rootDir = path.resolve(__dirname, "..");
+const entryFile = path.join(rootDir, "msh.js");
+
+const SERVICE_NAME = "magalh";
+const SERVICE_DISPLAY_NAME = "Magala Media Server";
+const SERVICE_DESCRIPTION = "Magala self-hosted media streaming server";
+
+function hasArg(name) {
+  return args.includes(name);
+}
+
+function log(message) {
+  console.log(`[magalh] ${message}`);
+}
+
+function warn(message) {
+  console.warn(`[magalh] ${message}`);
+}
+
+function fail(message, exitCode = 1) {
+  try {
+    process.stderr.write(`[magalh] ${message}\n`);
+  } catch {
+    console.error(`[magalh] ${message}`);
+  }
+  process.exit(exitCode);
+}
+
+function isRootOnLinux() {
+  return typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+function isWindowsAdminLike() {
+  try {
+    fs.accessSync(
+      path.join(process.env.SystemRoot || "C:\\Windows", "System32"),
+      fs.constants.W_OK,
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function fileExists(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runCommand(command, commandArgs, options = {}) {
+  return execFileSync(command, commandArgs, {
+    stdio: "inherit",
+    ...options,
+  });
+}
 
-if (args.includes("--help") || args.includes("-h")) {
+function runCommandQuiet(command, commandArgs, options = {}) {
+  try {
+    return execFileSync(command, commandArgs, {
+      stdio: "pipe",
+      encoding: "utf8",
+      ...options,
+    });
+  } catch {
+    return null;
+  }
+}
+
+function printHelp() {
   process.stdout.write(
     [
       "magalh - Magala Media Server",
       "",
       "Usage:",
-      "  magalh [--help]",
+      "  magalh",
+      "  magalh --help",
       "  magalh --install-service",
-      "  magalh --upgrade-node",
+      "  magalh --uninstall-service",
+      "  magalh --service-status",
+      "",
+      "Notes:",
+      "  - The server starts normally with: magalh",
+      "  - Service installation is explicit only; it is never done automatically.",
       "",
     ].join("\n"),
   );
-  process.exit(0);
 }
 
-if (args.includes("--upgrade-node")) {
-  if (process.platform !== "linux") {
-    console.log("[magalh] --upgrade-node is only supported on Linux.");
-    process.exit(0);
+function getCliBin() {
+  return path.join(rootDir, "bin", "mgl.js");
+}
+
+function getLinuxServiceFile() {
+  return `/etc/systemd/system/${SERVICE_NAME}.service`;
+}
+
+function ensureEntryFileExists() {
+  if (!fileExists(entryFile)) {
+    fail(`Entry file not found: ${entryFile}`);
   }
+}
 
-  var MIN_NODE_MAJOR = 20;
-  var current = parseInt(process.versions.node.split(".")[0], 10);
+function getLinuxServiceContent() {
+  const nodeBin = process.execPath;
+  const cliBin = getCliBin();
 
-  if (current >= MIN_NODE_MAJOR) {
-    console.log("[magalh] Node.js v" + process.versions.node + " is already v" + MIN_NODE_MAJOR + "+. No upgrade needed.");
-    process.exit(0);
+  return [
+    "[Unit]",
+    `Description=${SERVICE_DISPLAY_NAME}`,
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `WorkingDirectory=${rootDir}`,
+    `ExecStart=${nodeBin} ${cliBin}`,
+    "Restart=on-failure",
+    "RestartSec=5",
+    "StandardOutput=journal",
+    "StandardError=journal",
+    `SyslogIdentifier=${SERVICE_NAME}`,
+    "",
+    "[Install]",
+    "WantedBy=multi-user.target",
+    "",
+  ].join("\n");
+}
+
+function isLinuxServiceInstalled() {
+  return fileExists(getLinuxServiceFile());
+}
+
+function isWindowsServiceInstalled() {
+  const out = runCommandQuiet("sc", ["query", SERVICE_NAME]);
+  return typeof out === "string" && out.includes("SERVICE_NAME");
+}
+
+function installLinuxService() {
+  if (!isRootOnLinux()) {
+    fail("Linux service installation requires root. Run: sudo magalh --install-service");
+  }
+
+  const systemdDir = "/etc/systemd/system";
+  if (!fileExists(systemdDir)) {
+    fail("systemd directory not found. Service install is not supported on this Linux system.");
   }
 
-  console.log("[magalh] Node.js v" + process.versions.node + " is too old. Upgrading to v" + MIN_NODE_MAJOR + " via nvm...");
+  const cliBin = getCliBin();
+  if (!fileExists(cliBin)) {
+    fail(`CLI file not found: ${cliBin}`);
+  }
+
+  const serviceFile = getLinuxServiceFile();
+  const content = getLinuxServiceContent();
+
+  try {
+    fs.writeFileSync(serviceFile, content, { mode: 0o644 });
+    log(`Service file written -> ${serviceFile}`);
 
-  var nvmDir = (process.env.NVM_DIR) ||
-    (process.env.HOME ? path.join(process.env.HOME, ".nvm") : "");
-  var nvmScript = nvmDir ? path.join(nvmDir, "nvm.sh") : "";
+    runCommand("systemctl", ["daemon-reload"]);
+    runCommand("systemctl", ["enable", SERVICE_NAME]);
+    runCommand("systemctl", ["restart", SERVICE_NAME]);
+
+    log(
+      "systemd service enabled and started.\n" +
+      `         Status : systemctl status ${SERVICE_NAME}\n` +
+      `         Logs   : journalctl -u ${SERVICE_NAME} -f`,
+    );
+  } catch (error) {
+    fail(`Linux service installation failed: ${error.message || String(error)}`);
+  }
+}
+
+function uninstallLinuxService() {
+  if (!isRootOnLinux()) {
+    fail("Linux service removal requires root. Run: sudo magalh --uninstall-service");
+  }
+
+  const serviceFile = getLinuxServiceFile();
+
+  try {
+    runCommandQuiet("systemctl", ["stop", SERVICE_NAME]);
+    runCommandQuiet("systemctl", ["disable", SERVICE_NAME]);
+
+    if (fileExists(serviceFile)) {
+      fs.unlinkSync(serviceFile);
+      log(`Removed service file -> ${serviceFile}`);
+    } else {
+      log("Service file does not exist. Nothing to remove.");
+    }
+
+    runCommand("systemctl", ["daemon-reload"]);
+    log("Linux service removed.");
+  } catch (error) {
+    fail(`Linux service removal failed: ${error.message || String(error)}`);
+  }
+}
+
+function printLinuxServiceStatus() {
+  if (!isLinuxServiceInstalled()) {
+    log("Linux service is not installed.");
+    process.exit(0);
+  }
 
-  var installCmd;
-  if (nvmScript && fs.existsSync(nvmScript)) {
-    installCmd = [
-      "source " + nvmScript,
-      "nvm install " + MIN_NODE_MAJOR,
-      "nvm alias default " + MIN_NODE_MAJOR,
-      "nvm use " + MIN_NODE_MAJOR,
-    ].join(" && ");
+  log(`Linux service file exists -> ${getLinuxServiceFile()}`);
+  const status = runCommandQuiet("systemctl", ["status", SERVICE_NAME, "--no-pager"]);
+  if (status) {
+    process.stdout.write(`${status}\n`);
   } else {
-    installCmd = [
-      'if curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh -o /tmp/_nvm_setup.sh 2>/dev/null && bash /tmp/_nvm_setup.sh; then',
-      '  export NVM_DIR="$HOME/.nvm" && source "$NVM_DIR/nvm.sh" && nvm install ' + MIN_NODE_MAJOR + ' && nvm alias default ' + MIN_NODE_MAJOR,
-      'else',
-      '  echo "[magalh] curl failed, trying npm n..." && npm install -g n && n ' + MIN_NODE_MAJOR,
-      'fi',
-    ].join('\n');
+    warn("Could not read systemd status output.");
+  }
+}
+
+function installWindowsService() {
+  if (!isWindowsAdminLike()) {
+    fail("Windows service installation requires Administrator privileges.");
   }
 
+  const cliBin = getCliBin();
+  if (!fileExists(cliBin)) {
+    fail(`CLI file not found: ${cliBin}`);
+  }
+
+  const nodeBin = process.execPath;
+  const binPath = `"${nodeBin}" "${cliBin}"`;
+
   try {
-    execFileSync("bash", ["-c", installCmd], { stdio: "inherit" });
-    console.log("[magalh] Node.js v" + MIN_NODE_MAJOR + " installed. Run: npm install -g magalh");
-  } catch (err) {
-    console.error("[magalh] Upgrade failed: " + ((err && err.message) || String(err)));
-    process.exit(1);
+    runCommandQuiet("sc", ["stop", SERVICE_NAME]);
+    runCommandQuiet("sc", ["delete", SERVICE_NAME]);
+
+    runCommand("sc", [
+      "create",
+      SERVICE_NAME,
+      "binPath=",
+      binPath,
+      "start=",
+      "auto",
+      "DisplayName=",
+      SERVICE_DISPLAY_NAME,
+    ]);
+
+    runCommand("sc", [
+      "description",
+      SERVICE_NAME,
+      SERVICE_DESCRIPTION,
+    ]);
+
+    runCommand("sc", [
+      "failure",
+      SERVICE_NAME,
+      "reset=",
+      "60",
+      "actions=",
+      "restart/5000/restart/5000/restart/5000",
+    ]);
+
+    runCommand("sc", ["start", SERVICE_NAME]);
+
+    log(
+      "Windows service created and started.\n" +
+      `         Status : sc query ${SERVICE_NAME}\n` +
+      `         Stop   : sc stop ${SERVICE_NAME}\n` +
+      "         Logs   : Event Viewer -> Windows Logs -> Application",
+    );
+  } catch (error) {
+    fail(`Windows service installation failed: ${error.message || String(error)}`);
   }
-  process.exit(0);
 }
 
-if (args.includes("--install-service")) {
-  const SERVICE_NAME = "magalh";
-  const nodeBin      = process.execPath;
-  const mglBin       = path.join(rootDir, "bin", "mgl.js");
-
-  function installLinux() {
-    if (typeof process.getuid !== "function" || process.getuid() !== 0) {
-      console.log(
-        "[magalh] Skipping systemd setup (not running as root).\n" +
-        "         To install manually:  sudo npm install -g magalh",
-      );
-      return;
-    }
-    const SYSTEMD_DIR = "/etc/systemd/system";
-    if (!fs.existsSync(SYSTEMD_DIR)) {
-      console.log("[magalh] Skipping systemd setup (systemd not found).");
-      return;
-    }
-    const serviceFile = path.join(SYSTEMD_DIR, `${SERVICE_NAME}.service`);
-    const content = [
-      "[Unit]",
-      "Description=Magala Media Server",
-      "After=network-online.target",
-      "Wants=network-online.target",
-      "",
-      "[Service]",
-      "Type=simple",
-      `WorkingDirectory=${rootDir}`,
-      `ExecStart=${nodeBin} ${mglBin}`,
-      "Restart=on-failure",
-      "RestartSec=5",
-      "StandardOutput=journal",
-      "StandardError=journal",
-      `SyslogIdentifier=${SERVICE_NAME}`,
-      "",
-      "[Install]",
-      "WantedBy=multi-user.target",
-      "",
-    ].join("\n");
-    try {
-      fs.writeFileSync(serviceFile, content, { mode: 0o644 });
-      console.log(`[magalh] Service file written -> ${serviceFile}`);
-      execFileSync("systemctl", ["daemon-reload"],         { stdio: "inherit" });
-      execFileSync("systemctl", ["enable", SERVICE_NAME],  { stdio: "inherit" });
-      execFileSync("systemctl", ["restart", SERVICE_NAME], { stdio: "inherit" });
-      console.log(
-        `[magalh] systemd service enabled and started.\n` +
-        `         Status : systemctl status ${SERVICE_NAME}\n` +
-        `         Logs   : journalctl -u ${SERVICE_NAME} -f`,
-      );
-    } catch (err) {
-      console.warn("[magalh] Warning: systemd setup failed: " + ((err && err.message) || String(err)));
-    }
+function uninstallWindowsService() {
+  if (!isWindowsAdminLike()) {
+    fail("Windows service removal requires Administrator privileges.");
   }
 
-  function installWindows() {
-    try {
-      fs.accessSync(
-        path.join(process.env.SystemRoot || "C:\\Windows", "System32"),
-        fs.constants.W_OK,
-      );
-    } catch (_e) {
-      console.log(
-        "[magalh] Skipping Windows service setup (not running as Administrator).\n" +
-        "         To install manually: run  npm install -g magalh  as Administrator.",
-      );
-      return;
-    }
-    const binPath = `"${nodeBin}" "${mglBin}"`;
-    try {
-      try { execFileSync("sc", ["stop",   SERVICE_NAME], { stdio: "pipe" }); } catch (_e) { }
-      try { execFileSync("sc", ["delete", SERVICE_NAME], { stdio: "pipe" }); } catch (_e) { }
-      execFileSync("sc", [
-        "create", SERVICE_NAME,
-        "binPath=", binPath,
-        "start=",   "auto",
-        "DisplayName=", "Magala Media Server",
-      ], { stdio: "inherit" });
-      execFileSync("sc", [
-        "description", SERVICE_NAME,
-        "Magala self-hosted media streaming server",
-      ], { stdio: "inherit" });
-      execFileSync("sc", [
-        "failure", SERVICE_NAME,
-        "reset=",   "60",
-        "actions=", "restart/5000/restart/5000/restart/5000",
-      ], { stdio: "inherit" });
-      execFileSync("sc", ["start", SERVICE_NAME], { stdio: "inherit" });
-      console.log(
-        `[magalh] Windows service created and started.\n` +
-        `         Status : sc query ${SERVICE_NAME}\n` +
-        `         Stop   : sc stop  ${SERVICE_NAME}\n` +
-        `         Logs   : Event Viewer -> Windows Logs -> Application`,
-      );
-    } catch (err) {
-      console.warn("[magalh] Warning: Windows service setup failed: " + ((err && err.message) || String(err)));
-    }
+  try {
+    runCommandQuiet("sc", ["stop", SERVICE_NAME]);
+    runCommandQuiet("sc", ["delete", SERVICE_NAME]);
+    log("Windows service removed.");
+  } catch (error) {
+    fail(`Windows service removal failed: ${error.message || String(error)}`);
+  }
+}
+
+function printWindowsServiceStatus() {
+  if (!isWindowsServiceInstalled()) {
+    log("Windows service is not installed.");
+    process.exit(0);
   }
 
-  if (process.platform === "linux")      installLinux();
-  else if (process.platform === "win32") installWindows();
-  process.exit(0);
+  const status = runCommandQuiet("sc", ["query", SERVICE_NAME]);
+  if (status) {
+    process.stdout.write(`${status}\n`);
+  } else {
+    warn("Could not read Windows service status output.");
+  }
 }
 
-if (process.platform === "linux" && !process.env.MAGALH_UPGRADED) {
-  var _MIN    = 20;
-  var _curMaj = parseInt(process.versions.node.split(".")[0], 10);
-  if (_curMaj < _MIN) {
-    console.log("[magalh] Node.js v" + process.versions.node + " detected (need v" + _MIN + "+). Auto-upgrading...");
-    var _nvmHome = process.env.NVM_DIR || path.join(process.env.HOME || "/root", ".nvm");
-    var _nvmSh   = path.join(_nvmHome, "nvm.sh");
-    var _upCmd   = [
-      'export NVM_DIR="' + _nvmHome + '"',
-      'if [ -s "' + _nvmSh + '" ]; then',
-      '  source "' + _nvmSh + '" && nvm install ' + _MIN + ' && nvm alias default ' + _MIN,
-      'elif curl -fsSL https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh -o /tmp/_nvm_setup.sh 2>/dev/null && bash /tmp/_nvm_setup.sh && [ -s "' + _nvmSh + '" ]; then',
-      '  source "' + _nvmSh + '" && nvm install ' + _MIN + ' && nvm alias default ' + _MIN,
-      'else',
-      '  echo "[magalh] Falling back to npm n..." && npm install -g n && n ' + _MIN,
-      'fi',
-    ].join('\n');
-    var _newNode = null;
-    try {
-      execFileSync("bash", ["-c", _upCmd], { stdio: "inherit" });
-      if (fs.existsSync(_nvmSh)) {
-        try {
-          _newNode = execFileSync("bash", ["-c", 'source "' + _nvmSh + '" && nvm which ' + _MIN], { encoding: "utf8" }).trim();
-        } catch (_e) {}
-      }
-      if (!_newNode) {
-        var _cands = ["/usr/local/bin/node", "/usr/bin/node"];
-        for (var _ci = 0; _ci < _cands.length; _ci++) {
-          if (fs.existsSync(_cands[_ci])) {
-            try {
-              var _nv = execFileSync(_cands[_ci], ["--version"], { encoding: "utf8" }).trim();
-              if (parseInt(_nv.replace("v", "").split(".")[0], 10) >= _MIN) {
-                _newNode = _cands[_ci];
-                break;
-              }
-            } catch (_e) {}
-          }
-        }
-      }
-    } catch (_e) {
-      console.warn("[magalh] Auto-upgrade failed. Run manually: magalh --upgrade-node");
-    }
-    if (_newNode && fs.existsSync(_newNode)) {
-      var _newNpm = path.join(path.dirname(_newNode), "npm");
-      if (fs.existsSync(_newNpm)) {
-        console.log("[magalh] Reinstalling magalh with Node v" + _MIN + " (rebuilds native modules)...");
-        try {
-          execFileSync(_newNpm, ["install", "-g", "magalh"], { stdio: "inherit" });
-        } catch (_re) {
-          console.warn("[magalh] Reinstall warning: " + String(_re));
-        }
-      }
-      console.log("[magalh] Restarting with Node.js v" + _MIN + "...");
-      var _env = Object.assign({}, process.env, { MAGALH_UPGRADED: "1" });
-      var _rs  = spawn(_newNode, [__filename].concat(args), { cwd: rootDir, env: _env, stdio: "inherit" });
-      _rs.on("exit", function(c, s) { process.exit(s ? 1 : (typeof c === "number" ? c : 0)); });
-      _rs.on("error", function(e) { process.stderr.write(String(e) + "\n"); process.exit(1); });
-      return;
-    }
-    console.error("[magalh] Cannot start: requires Node.js v" + _MIN + "+. Run: magalh --upgrade-node");
-    process.exit(1);
+function installService() {
+  if (process.platform === "linux") {
+    installLinuxService();
+    return;
+  }
+
+  if (process.platform === "win32") {
+    installWindowsService();
+    return;
   }
+
+  fail(`Service installation is not supported on platform: ${process.platform}`);
 }
 
-const entryFile = path.join(rootDir, "msh.js");
+function uninstallService() {
+  if (process.platform === "linux") {
+    uninstallLinuxService();
+    return;
+  }
+
+  if (process.platform === "win32") {
+    uninstallWindowsService();
+    return;
+  }
 
-const child = spawn(process.execPath, [entryFile, ...args], {
-  cwd: rootDir,
-  env: process.env,
-  stdio: "inherit",
-  windowsHide: true,
-});
+  fail(`Service removal is not supported on platform: ${process.platform}`);
+}
 
-child.on("exit", (code, signal) => {
-  if (signal) process.exit(1);
-  process.exit(typeof code === "number" ? code : 0);
-});
+function printServiceStatus() {
+  if (process.platform === "linux") {
+    printLinuxServiceStatus();
+    return;
+  }
 
-child.on("error", (err) => {
-  try {
-    process.stderr.write("Failed to start msh: " + ((err && err.message) || String(err)) + "\n");
-  } catch (_e) { }
-  process.exit(1);
-});
+  if (process.platform === "win32") {
+    printWindowsServiceStatus();
+    return;
+  }
+
+  log(`Service status is not supported on platform: ${process.platform}`);
+}
+
+function startMainProcess() {
+  ensureEntryFileExists();
+
+  const child = spawn(process.execPath, [entryFile, ...args], {
+    cwd: rootDir,
+    env: process.env,
+    stdio: "inherit",
+    windowsHide: true,
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      process.exit(1);
+    }
+  });
+
+  child.on("error", (error) => {
+    fail(`Failed to start msh: ${error.message || String(error)}`);
+  });
+}
+
+function main() {
+  if (hasArg("--help") || hasArg("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (hasArg("--install-service")) {
+    installService();
+    process.exit(0);
+  }
+
+  if (hasArg("--uninstall-service")) {
+    uninstallService();
+    process.exit(0);
+  }
+
+  if (hasArg("--service-status")) {
+    printServiceStatus();
+    process.exit(0);
+  }
+
+  startMainProcess();
+}
+
+main();