unitup 0.0.1

package/src/systemd.js

@@ -0,0 +1,506 @@
+import { execFile, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {
+  sanitizeServiceName,
+  getUnitFilename,
+  formatRelativeTime
+} from './utils.js';
+import {
+  getUserUnitDir,
+  getUnitPath,
+  unitFileExists,
+  deleteUnitFile,
+  listUnitFiles,
+  writeUnitFile,
+  parseUnitContent
+} from './unit.js';
+
+/**
+ * Default runner for executing commands via child_process.execFile.
+ * Can be mocked during testing.
+ *
+ * @type {(cmd: string, args: string[], opts?: any) => Promise<{ stdout: string, stderr: string, code: number }>}
+ */
+let commandRunner = defaultExecFileRunner;
+
+function defaultExecFileRunner(cmd, args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    execFile(cmd, args, { ...opts, encoding: 'utf8' }, (err, stdout, stderr) => {
+      const code = err ? (typeof err.code === 'number' ? err.code : 1) : 0;
+      resolve({ stdout: stdout || '', stderr: stderr || '', code });
+    });
+  });
+}
+
+/**
+ * Overrides the internal command runner for test mocking.
+ *
+ * @param {typeof commandRunner} runner
+ */
+export function setCommandRunner(runner) {
+  commandRunner = runner;
+}
+
+/**
+ * Resets the command runner to default child_process.execFile implementation.
+ */
+export function resetCommandRunner() {
+  commandRunner = defaultExecFileRunner;
+}
+
+/**
+ * Executes a command safely without invoking a shell.
+ *
+ * @param {string} cmd
+ * @param {string[]} args
+ * @param {any} [opts]
+ */
+export async function runCommand(cmd, args, opts) {
+  return commandRunner(cmd, args, opts);
+}
+
+// ---------------------------------------------------------------------------
+// System Diagnostics & Doctor checks
+// ---------------------------------------------------------------------------
+
+export function isLinux() {
+  return process.platform === 'linux';
+}
+
+export async function isSystemctlAvailable() {
+  try {
+    const res = await runCommand('systemctl', ['--version']);
+    return res.code === 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function isSystemdPID1() {
+  if (!isLinux()) return false;
+  try {
+    if (fs.existsSync('/run/systemd/system')) {
+      return true;
+    }
+    if (fs.existsSync('/proc/1/comm')) {
+      const comm = fs.readFileSync('/proc/1/comm', 'utf8').trim();
+      return comm === 'systemd' || comm === 'init';
+    }
+  } catch {
+    // ignore
+  }
+  return false;
+}
+
+export async function isUserSystemdAvailable() {
+  try {
+    const res = await runCommand('systemctl', ['--user', 'is-system-running']);
+    // exit code 0 (running), 1 (degraded) or stderr non-fatal means user bus is accessible
+    if (res.stderr && res.stderr.includes('Failed to connect to bus')) {
+      return false;
+    }
+    return res.code === 0 || res.code === 1 || res.stdout.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+export async function isUserUnitDirWritable() {
+  const dir = getUserUnitDir();
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.accessSync(dir, fs.constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Finds and validates Node.js executable path safely using process.execPath, which, or command -v.
+ *
+ * @param {string} [customPath]
+ * @returns {Promise<string|null>}
+ */
+export async function findNodeExecutable(customPath) {
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    try {
+      if (fs.existsSync(absPath)) {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        return absPath;
+      }
+    } catch {
+      return null;
+    }
+    return null;
+  }
+
+  // 1. Try process.execPath
+  if (process.execPath && fs.existsSync(process.execPath)) {
+    try {
+      fs.accessSync(process.execPath, fs.constants.X_OK);
+      return process.execPath;
+    } catch {
+      // ignore
+    }
+  }
+
+  // 2. Try which node
+  try {
+    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+    const res = await runCommand(whichCmd, ['node']);
+    if (res.code === 0 && res.stdout.trim()) {
+      const p = res.stdout.trim().split('\n')[0].trim();
+      if (fs.existsSync(p)) {
+        return p;
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  return null;
+}
+
+/**
+ * Checks detailed Node.js runtime diagnostics.
+ *
+ * @param {string} [customNodePath]
+ * @returns {Promise<Object>}
+ */
+export async function checkNodeDiagnostics(customNodePath) {
+  const result = {
+    found: false,
+    executable: false,
+    execPath: '',
+    whichPath: '',
+    version: '',
+    inPath: false,
+    error: null,
+    solution: null
+  };
+
+  // Check which node
+  try {
+    const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+    const res = await runCommand(whichCmd, ['node']);
+    if (res.code === 0 && res.stdout.trim()) {
+      result.whichPath = res.stdout.trim().split('\n')[0].trim();
+      result.inPath = true;
+    }
+  } catch {
+    result.inPath = false;
+  }
+
+  const resolvedNode = await findNodeExecutable(customNodePath);
+  if (!resolvedNode) {
+    if (result.whichPath && fs.existsSync(result.whichPath)) {
+      result.execPath = result.whichPath;
+      result.found = true;
+      result.executable = false;
+      result.error = 'Node.js binary exists but is not executable';
+      result.solution = `Check permissions:\n  chmod +x $(which node)`;
+      return result;
+    }
+
+    result.found = false;
+    result.error = 'Node.js not found in PATH';
+    result.solution = `Install Node.js:\n  https://nodejs.org\nor via package manager:\n  sudo apt install nodejs`;
+    return result;
+  }
+
+  result.execPath = resolvedNode;
+  result.found = true;
+
+  // Test executing node -v
+  try {
+    const res = await runCommand(resolvedNode, ['-v']);
+    if (res.code === 0 && res.stdout.trim()) {
+      result.version = res.stdout.trim();
+      result.executable = true;
+    } else {
+      result.executable = false;
+      result.error = 'Node.js binary exists but fails execution';
+      result.solution = `Check Node.js installation or explicit path:\n  unitup add app.js --node ${resolvedNode}`;
+    }
+  } catch (err) {
+    result.executable = false;
+    result.error = `Node.js execution failed: ${err.message}`;
+    result.solution = `Try setting explicit path:\n  unitup add app.js --node ${resolvedNode}`;
+  }
+
+  return result;
+}
+
+export async function checkUserLinger() {
+  const username = os.userInfo().username;
+  // Method 1: check /var/lib/systemd/linger/<user>
+  try {
+    if (fs.existsSync(`/var/lib/systemd/linger/${username}`)) {
+      return true;
+    }
+  } catch {
+    // ignore
+  }
+  // Method 2: loginctl show-user $USER --property=Linger
+  try {
+    const res = await runCommand('loginctl', ['show-user', username, '--property=Linger']);
+    if (res.code === 0 && res.stdout.includes('Linger=yes')) {
+      return true;
+    }
+  } catch {
+    // ignore
+  }
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// Systemd Operations
+// ---------------------------------------------------------------------------
+
+export async function daemonReload() {
+  const res = await runCommand('systemctl', ['--user', 'daemon-reload']);
+  if (res.code !== 0) {
+    throw new Error(`Failed to reload systemd daemon: ${res.stderr || res.stdout}`);
+  }
+  return true;
+}
+
+export async function resetFailed() {
+  await runCommand('systemctl', ['--user', 'reset-failed']);
+}
+
+export async function addService(opts) {
+  const safeName = sanitizeServiceName(opts.name);
+  const { path: unitPath } = writeUnitFile({ ...opts, name: safeName });
+
+  await daemonReload();
+
+  if (opts.start) {
+    await startService(safeName, true);
+  }
+
+  return { name: safeName, unitPath };
+}
+
+export async function startService(name, enable = false) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.\nCreate it with: unitup add <script> --name ${safeName}`);
+  }
+
+  const args = enable
+    ? ['--user', 'enable', '--now', getUnitFilename(safeName)]
+    : ['--user', 'start', getUnitFilename(safeName)];
+
+  const res = await runCommand('systemctl', args);
+  if (res.code !== 0) {
+    throw new Error(`Failed to start service "${safeName}": ${res.stderr || res.stdout}`);
+  }
+  return true;
+}
+
+export async function stopService(name) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.`);
+  }
+
+  const res = await runCommand('systemctl', ['--user', 'stop', getUnitFilename(safeName)]);
+  if (res.code !== 0) {
+    throw new Error(`Failed to stop service "${safeName}": ${res.stderr || res.stdout}`);
+  }
+  return true;
+}
+
+export async function restartService(name) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.`);
+  }
+
+  const res = await runCommand('systemctl', ['--user', 'restart', getUnitFilename(safeName)]);
+  if (res.code !== 0) {
+    throw new Error(`Failed to restart service "${safeName}": ${res.stderr || res.stdout}`);
+  }
+  return true;
+}
+
+export async function removeService(name) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.`);
+  }
+
+  // Attempt disable and stop
+  await runCommand('systemctl', ['--user', 'disable', '--now', getUnitFilename(safeName)]);
+
+  deleteUnitFile(safeName);
+
+  await daemonReload();
+  await resetFailed();
+  return true;
+}
+
+export async function getServiceShow(name) {
+  const safeName = sanitizeServiceName(name);
+  const unitFilename = getUnitFilename(safeName);
+
+  const res = await runCommand('systemctl', ['--user', 'show', unitFilename]);
+  const info = {};
+
+  if (res.stdout) {
+    const lines = res.stdout.split('\n');
+    for (const line of lines) {
+      const idx = line.indexOf('=');
+      if (idx !== -1) {
+        const key = line.slice(0, idx).trim();
+        const val = line.slice(idx + 1).trim();
+        info[key] = val;
+      }
+    }
+  }
+
+  return info;
+}
+
+export async function getServiceStatusRaw(name) {
+  const safeName = sanitizeServiceName(name);
+  const res = await runCommand('systemctl', ['--user', 'status', getUnitFilename(safeName)]);
+  return res.stdout || res.stderr;
+}
+
+export async function getServiceStatus(name) {
+  const safeName = sanitizeServiceName(name);
+  if (!unitFileExists(safeName)) {
+    throw new Error(`Service "${safeName}" does not exist.`);
+  }
+
+  const show = await getServiceShow(safeName);
+
+  // Read unit file content for script and working dir
+  let script = 'unknown';
+  let cwd = 'unknown';
+
+  const unitPath = getUnitPath(safeName);
+  try {
+    const content = fs.readFileSync(unitPath, 'utf8');
+    const parsed = parseUnitContent(content);
+    if (parsed.script) script = parsed.script;
+    if (parsed.cwd) cwd = parsed.cwd;
+  } catch {
+    // ignore
+  }
+
+  let status = 'stopped';
+  const activeState = show.ActiveState || 'unknown';
+  const subState = show.SubState || 'unknown';
+
+  if (activeState === 'active' && subState === 'running') {
+    status = 'running';
+  } else if (activeState === 'active') {
+    status = subState;
+  } else if (activeState === 'failed') {
+    status = 'failed';
+  } else if (activeState === 'inactive') {
+    status = 'stopped';
+  } else {
+    status = activeState;
+  }
+
+  const pid = show.MainPID && show.MainPID !== '0' ? show.MainPID : '-';
+  const restarts = show.NRestarts ?? '0';
+  const startedRaw = show.ActiveEnterTimestamp;
+  const started = startedRaw && startedRaw !== '0' && startedRaw !== 'n/a'
+    ? formatRelativeTime(startedRaw)
+    : 'never';
+
+  return {
+    name: safeName,
+    unitFile: getUnitFilename(safeName),
+    status,
+    activeState,
+    subState,
+    pid,
+    restarts,
+    started,
+    startedRaw,
+    script,
+    cwd
+  };
+}
+
+export async function listServices() {
+  const units = listUnitFiles();
+  const result = [];
+
+  for (const unit of units) {
+    try {
+      const show = await getServiceShow(unit.name);
+      const activeState = show.ActiveState || 'inactive';
+      const subState = show.SubState || 'dead';
+      const unitFileState = show.UnitFileState || 'unknown';
+
+      let status = 'stopped';
+      if (activeState === 'active' && subState === 'running') {
+        status = 'running';
+      } else if (activeState === 'failed') {
+        status = 'failed';
+      } else if (activeState === 'active') {
+        status = subState;
+      } else {
+        status = 'stopped';
+      }
+
+      const enabled = unitFileState.startsWith('enabled') ? 'yes' : 'no';
+
+      result.push({
+        name: unit.name,
+        status,
+        enabled
+      });
+    } catch {
+      result.push({
+        name: unit.name,
+        status: 'unknown',
+        enabled: 'unknown'
+      });
+    }
+  }
+
+  return result;
+}
+
+export async function runJournalctlLogs(name, opts = {}) {
+  const safeName = sanitizeServiceName(name);
+  const unitFilename = getUnitFilename(safeName);
+
+  const args = ['--user', '-u', unitFilename];
+
+  if (opts.follow) {
+    args.push('-f');
+  } else {
+    args.push('--no-pager');
+    const lines = opts.lines ? String(opts.lines) : '100';
+    args.push('-n', lines);
+  }
+
+  if (opts.follow) {
+    // Spawn stream for follow mode
+    try {
+      const child = spawn('journalctl', args, { stdio: 'inherit', shell: false });
+      child.on('error', () => {});
+      return child;
+    } catch {
+      return null;
+    }
+  } else {
+    const res = await runCommand('journalctl', args);
+    return res.stdout || res.stderr || 'No logs found.';
+  }
+}

package/src/unit.js

@@ -0,0 +1,207 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import {
+  sanitizeServiceName,
+  getUnitFilename,
+  formatSystemdEnv,
+  escapeExecArg,
+  resolveAbsolutePath
+} from './utils.js';
+
+/**
+ * Returns the path to the systemd user service directory (~/.config/systemd/user).
+ *
+ * @returns {string}
+ */
+export function getUserUnitDir() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME;
+  if (xdgConfig) {
+    return path.join(xdgConfig, 'systemd', 'user');
+  }
+  return path.join(os.homedir(), '.config', 'systemd', 'user');
+}
+
+/**
+ * Returns the full file path for a given service unit.
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+export function getUnitPath(name) {
+  const filename = getUnitFilename(name);
+  return path.join(getUserUnitDir(), filename);
+}
+
+/**
+ * Checks if a unit file exists for the given service name.
+ *
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function unitFileExists(name) {
+  const unitPath = getUnitPath(name);
+  return fs.existsSync(unitPath);
+}
+
+/**
+ * Generates the text content of a systemd unit file.
+ *
+ * @param {Object} opts
+ * @param {string} opts.name - Service name
+ * @param {string} opts.script - Absolute path to script
+ * @param {string} [opts.cwd] - Working directory path
+ * @param {string} [opts.nodePath] - Absolute path to Node executable
+ * @param {Record<string, string>} [opts.env] - Environment variables object
+ * @param {string} [opts.envFile] - Path to environment file
+ * @param {string} [opts.restart] - Restart policy (default: 'on-failure')
+ * @param {Array<string>} [opts.args] - Extra script arguments
+ * @returns {string}
+ */
+export function generateUnitContent(opts) {
+  const safeName = sanitizeServiceName(opts.name);
+  const scriptPath = resolveAbsolutePath(opts.script);
+  const cwd = opts.cwd ? resolveAbsolutePath(opts.cwd) : path.dirname(scriptPath);
+  const nodeExec = opts.nodePath ? resolveAbsolutePath(opts.nodePath) : process.execPath;
+  const restartPolicy = opts.restart || 'on-failure';
+
+  const execArgs = [nodeExec, scriptPath];
+  if (Array.isArray(opts.args) && opts.args.length > 0) {
+    execArgs.push(...opts.args);
+  }
+
+  const execStartLine = execArgs.map(escapeExecArg).join(' ');
+
+  const nodeBinDir = path.dirname(nodeExec);
+  const defaultPath = [nodeBinDir, '/usr/local/bin', '/usr/bin', '/bin']
+    .filter((p, i, self) => p && self.indexOf(p) === i)
+    .join(':');
+
+  const serviceLines = [
+    '[Unit]',
+    `Description=unitup service: ${safeName}`,
+    'After=network.target',
+    '',
+    '[Service]',
+    'Type=simple',
+    `WorkingDirectory=${cwd}`,
+    `ExecStart=${execStartLine}`,
+    `Restart=${restartPolicy}`,
+    'RestartSec=3'
+  ];
+
+  const envObj = opts.env && typeof opts.env === 'object' ? { ...opts.env } : {};
+  if (!envObj.PATH) {
+    envObj.PATH = defaultPath;
+  }
+
+  if (opts.envFile) {
+    const absEnvFile = resolveAbsolutePath(opts.envFile);
+    serviceLines.push(`EnvironmentFile=${absEnvFile}`);
+  }
+
+  for (const [key, val] of Object.entries(envObj)) {
+    serviceLines.push(`Environment=${formatSystemdEnv(key, val)}`);
+  }
+
+  serviceLines.push('', '[Install]', 'WantedBy=default.target', '');
+
+  return serviceLines.join('\n');
+}
+
+/**
+ * Creates or updates a systemd unit file on disk.
+ *
+ * @param {Object} opts - Same options as generateUnitContent
+ * @returns {{ path: string, content: string }}
+ */
+export function writeUnitFile(opts) {
+  const safeName = sanitizeServiceName(opts.name);
+  const unitDir = getUserUnitDir();
+
+  if (!fs.existsSync(unitDir)) {
+    fs.mkdirSync(unitDir, { recursive: true });
+  }
+
+  const unitPath = getUnitPath(safeName);
+  const content = generateUnitContent({ ...opts, name: safeName });
+
+  fs.writeFileSync(unitPath, content, 'utf8');
+
+  return { path: unitPath, content };
+}
+
+/**
+ * Removes a unit file from disk.
+ *
+ * @param {string} name
+ * @returns {boolean} True if file existed and was removed
+ */
+export function deleteUnitFile(name) {
+  const unitPath = getUnitPath(name);
+  if (fs.existsSync(unitPath)) {
+    fs.unlinkSync(unitPath);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Lists all unitup-*.service files in the user unit directory.
+ *
+ * @returns {Array<{ name: string, filename: string, path: string }>}
+ */
+export function listUnitFiles() {
+  const unitDir = getUserUnitDir();
+  if (!fs.existsSync(unitDir)) {
+    return [];
+  }
+
+  const files = fs.readdirSync(unitDir);
+  const units = [];
+
+  for (const filename of files) {
+    if (filename.startsWith('unitup-') && filename.endsWith('.service')) {
+      const name = filename.slice(7, -8);
+      units.push({
+        name,
+        filename,
+        path: path.join(unitDir, filename)
+      });
+    }
+  }
+
+  return units;
+}
+
+/**
+ * Parses basic information (Script, WorkingDirectory) from a unit file content.
+ *
+ * @param {string} content
+ * @returns {{ script?: string, cwd?: string, restart?: string }}
+ */
+export function parseUnitContent(content) {
+  const result = {};
+  if (!content) return result;
+
+  const lines = content.split('\n');
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith('WorkingDirectory=')) {
+      result.cwd = trimmed.slice(17).trim();
+    } else if (trimmed.startsWith('ExecStart=')) {
+      const execVal = trimmed.slice(10).trim();
+      // Extract script from ExecStart (usually second token if node executable is first)
+      const parts = execVal.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+      if (parts.length >= 2) {
+        result.script = parts[1].replace(/^"|"$/g, '');
+      } else if (parts.length === 1) {
+        result.script = parts[0].replace(/^"|"$/g, '');
+      }
+    } else if (trimmed.startsWith('Restart=')) {
+      result.restart = trimmed.slice(8).trim();
+    }
+  }
+
+  return result;
+}