unitup 0.0.1

package/src/cli.js

@@ -0,0 +1,351 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { runDoctor } from './doctor.js';
+import {
+  addService,
+  startService,
+  stopService,
+  restartService,
+  removeService,
+  getServiceStatus,
+  getServiceStatusRaw,
+  listServices,
+  runJournalctlLogs,
+  isLinux,
+  isSystemctlAvailable,
+  findNodeExecutable
+} from './systemd.js';
+import { sanitizeServiceName, formatTable } from './utils.js';
+
+/**
+ * Custom light CLI argument parser without runtime dependencies.
+ *
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  const result = {
+    command: '',
+    positionals: [],
+    flags: {
+      name: '',
+      node: '',
+      cwd: '',
+      env: [],
+      envFile: '',
+      restart: 'on-failure',
+      args: [],
+      start: false,
+      enable: false,
+      raw: false,
+      follow: false,
+      lines: 100,
+      help: false,
+      version: false
+    }
+  };
+
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+
+    if (arg === '-h' || arg === '--help') {
+      result.flags.help = true;
+      i++;
+    } else if (arg === '-v' || arg === '--version') {
+      result.flags.version = true;
+      i++;
+    } else if (arg === '--node') {
+      result.flags.node = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--node=')) {
+      result.flags.node = arg.slice(7);
+      i++;
+    } else if (arg === '--name') {
+      result.flags.name = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--name=')) {
+      result.flags.name = arg.slice(7);
+      i++;
+    } else if (arg === '--cwd') {
+      result.flags.cwd = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--cwd=')) {
+      result.flags.cwd = arg.slice(6);
+      i++;
+    } else if (arg === '--env') {
+      if (argv[i + 1]) result.flags.env.push(argv[i + 1]);
+      i += 2;
+    } else if (arg.startsWith('--env=')) {
+      result.flags.env.push(arg.slice(6));
+      i++;
+    } else if (arg === '--env-file') {
+      result.flags.envFile = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--env-file=')) {
+      result.flags.envFile = arg.slice(11);
+      i++;
+    } else if (arg === '--restart') {
+      result.flags.restart = argv[i + 1] || 'on-failure';
+      i += 2;
+    } else if (arg.startsWith('--restart=')) {
+      result.flags.restart = arg.slice(10);
+      i++;
+    } else if (arg === '--arg') {
+      if (argv[i + 1]) result.flags.args.push(argv[i + 1]);
+      i += 2;
+    } else if (arg.startsWith('--arg=')) {
+      result.flags.args.push(arg.slice(6));
+      i++;
+    } else if (arg === '--lines' || arg === '-n') {
+      result.flags.lines = parseInt(argv[i + 1] || '100', 10);
+      i += 2;
+    } else if (arg.startsWith('--lines=')) {
+      result.flags.lines = parseInt(arg.slice(8), 10);
+      i++;
+    } else if (arg === '--start') {
+      result.flags.start = true;
+      i++;
+    } else if (arg === '--enable') {
+      result.flags.enable = true;
+      i++;
+    } else if (arg === '--raw') {
+      result.flags.raw = true;
+      i++;
+    } else if (arg === '-f' || arg === '--follow') {
+      result.flags.follow = true;
+      i++;
+    } else if (!arg.startsWith('-')) {
+      if (!result.command) {
+        result.command = arg;
+      } else {
+        result.positionals.push(arg);
+      }
+      i++;
+    } else {
+      // Unknown flag, treat as positional or ignore
+      i++;
+    }
+  }
+
+  return result;
+}
+
+export function printHelp() {
+  console.log(`
+unitup - Minimal systemd user service wrapper for Node.js scripts
+
+Usage:
+  unitup doctor                 Run system readiness check
+  unitup add <script> [options] Add script as systemd user service
+  unitup start <name>           Start a service (--enable to enable on boot)
+  unitup stop <name>            Stop a service
+  unitup restart <name>         Restart a service
+  unitup status <name>          Show status summary (--raw for full status)
+  unitup logs <name>            Show journalctl logs (--follow, --lines N)
+  unitup remove <name>          Stop, disable and delete a service
+  unitup list                   List all unitup user services
+
+Add Options:
+  --name <name>       Service name (default: script name)
+  --cwd <path>        Working directory
+  --restart <policy>  Restart policy (on-failure, always, etc. Default: on-failure)
+  --env KEY=value     Environment variable (can be specified multiple times)
+  --env-file <file>   Path to environment file
+  --arg <value>       Script argument (can be specified multiple times)
+  --start             Enable and start service immediately after creation
+
+Examples:
+  unitup add server.js --name api --env NODE_ENV=production --start
+  unitup status api
+  unitup logs api --follow
+  unitup remove api
+`);
+}
+
+/**
+ * Main CLI runner entrypoint.
+ *
+ * @param {string[]} argv
+ */
+export async function runCli(argv = process.argv.slice(2)) {
+  const parsed = parseArgs(argv);
+
+  if (parsed.flags.version) {
+    try {
+      const pkgPath = new URL('../package.json', import.meta.url);
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      console.log(`unitup v${pkg.version}`);
+    } catch {
+      console.log('unitup v1.0.0');
+    }
+    return;
+  }
+
+  if (parsed.flags.help || !parsed.command) {
+    printHelp();
+    return;
+  }
+
+  const { command, positionals, flags } = parsed;
+
+  try {
+    switch (command) {
+      case 'doctor': {
+        await runDoctor();
+        break;
+      }
+
+      case 'add': {
+        const scriptArg = positionals[0];
+        if (!scriptArg) {
+          throw new Error('Script file path is required.\nExample: unitup add app.js');
+        }
+
+        const resolvedNode = await findNodeExecutable(flags.node);
+        if (!resolvedNode) {
+          throw new Error('Node.js is required but not found.\nRun: unitup doctor');
+        }
+
+        const absScriptPath = path.resolve(process.cwd(), scriptArg);
+        if (!fs.existsSync(absScriptPath)) {
+          throw new Error(`Script file does not exist: ${absScriptPath}`);
+        }
+
+        let name = flags.name;
+        if (!name) {
+          const baseName = path.basename(scriptArg);
+          const ext = path.extname(baseName);
+          name = ext ? baseName.slice(0, -ext.length) : baseName;
+        }
+
+        const envObj = {};
+        for (const e of flags.env) {
+          const idx = e.indexOf('=');
+          if (idx !== -1) {
+            envObj[e.slice(0, idx)] = e.slice(idx + 1);
+          } else {
+            envObj[e] = '';
+          }
+        }
+
+        const res = await addService({
+          name,
+          script: absScriptPath,
+          nodePath: resolvedNode,
+          cwd: flags.cwd ? path.resolve(process.cwd(), flags.cwd) : path.dirname(absScriptPath),
+          env: envObj,
+          envFile: flags.envFile ? path.resolve(process.cwd(), flags.envFile) : undefined,
+          restart: flags.restart,
+          args: flags.args,
+          start: flags.start
+        });
+
+        console.log(`✓ Service "${res.name}" created at ${res.unitPath}`);
+        if (flags.start) {
+          console.log(`✓ Service "${res.name}" enabled and started.`);
+        } else {
+          console.log(`Run "unitup start ${res.name}" to start it.`);
+        }
+        break;
+      }
+
+      case 'start': {
+        const name = positionals[0];
+        if (!name) {
+          throw new Error('Service name is required.\nExample: unitup start api');
+        }
+        await startService(name, flags.enable);
+        console.log(`✓ Service "${sanitizeServiceName(name)}" ${flags.enable ? 'enabled & ' : ''}started.`);
+        break;
+      }
+
+      case 'stop': {
+        const name = positionals[0];
+        if (!name) {
+          throw new Error('Service name is required.\nExample: unitup stop api');
+        }
+        await stopService(name);
+        console.log(`✓ Service "${sanitizeServiceName(name)}" stopped.`);
+        break;
+      }
+
+      case 'restart': {
+        const name = positionals[0];
+        if (!name) {
+          throw new Error('Service name is required.\nExample: unitup restart api');
+        }
+        await restartService(name);
+        console.log(`✓ Service "${sanitizeServiceName(name)}" restarted.`);
+        break;
+      }
+
+      case 'status': {
+        const name = positionals[0];
+        if (!name) {
+          throw new Error('Service name is required.\nExample: unitup status api');
+        }
+
+        if (flags.raw) {
+          const raw = await getServiceStatusRaw(name);
+          console.log(raw);
+        } else {
+          const status = await getServiceStatus(name);
+          console.log(`${status.name}\n`);
+          console.log(`Status: ${status.status}`);
+          console.log(`PID: ${status.pid}`);
+          console.log(`Started: ${status.started}`);
+          console.log(`Restarts: ${status.restarts}`);
+          console.log(`Script: ${status.script}`);
+          console.log(`Working directory: ${status.cwd}`);
+        }
+        break;
+      }
+
+      case 'logs': {
+        const name = positionals[0];
+        if (!name) {
+          throw new Error('Service name is required.\nExample: unitup logs api');
+        }
+        const output = await runJournalctlLogs(name, {
+          follow: flags.follow,
+          lines: flags.lines
+        });
+        if (typeof output === 'string') {
+          console.log(output);
+        }
+        break;
+      }
+
+      case 'remove': {
+        const name = positionals[0];
+        if (!name) {
+          throw new Error('Service name is required.\nExample: unitup remove api');
+        }
+        await removeService(name);
+        console.log(`✓ Service "${sanitizeServiceName(name)}" removed.`);
+        break;
+      }
+
+      case 'list': {
+        const services = await listServices();
+        const table = formatTable(services, [
+          { key: 'name', label: 'NAME' },
+          { key: 'status', label: 'STATUS' },
+          { key: 'enabled', label: 'ENABLED' }
+        ]);
+        console.log(table);
+        break;
+      }
+
+      default: {
+        console.error(`Unknown command: "${command}"\n`);
+        printHelp();
+        process.exitCode = 1;
+        break;
+      }
+    }
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exitCode = 1;
+  }
+}

package/src/doctor.js

@@ -0,0 +1,109 @@
+import os from 'node:os';
+import {
+  isLinux,
+  isSystemctlAvailable,
+  isSystemdPID1,
+  isUserSystemdAvailable,
+  isUserUnitDirWritable,
+  checkUserLinger,
+  checkNodeDiagnostics
+} from './systemd.js';
+import { getUserUnitDir } from './unit.js';
+
+/**
+ * Runs system diagnostic checks and returns structured data.
+ *
+ * @returns {Promise<Object>}
+ */
+export async function getDoctorInfo() {
+  const linux = isLinux();
+  const systemctl = await isSystemctlAvailable();
+  const pid1 = await isSystemdPID1();
+  const userSystemd = await isUserSystemdAvailable();
+  const unitDirWritable = await isUserUnitDirWritable();
+  const lingering = await checkUserLinger();
+  const nodeDiag = await checkNodeDiagnostics();
+
+  return {
+    linux,
+    systemctl,
+    systemdRunning: pid1,
+    userSystemdAvailable: userSystemd,
+    nodeDiag,
+    nodePath: nodeDiag.execPath || process.execPath,
+    nodeVersion: nodeDiag.version,
+    unitDir: getUserUnitDir(),
+    unitDirWritable,
+    lingering,
+    username: os.userInfo().username
+  };
+}
+
+/**
+ * Executes doctor check and prints human-readable output to terminal.
+ */
+export async function runDoctor() {
+  console.log('unitup doctor\n');
+
+  const info = await getDoctorInfo();
+
+  if (info.linux) {
+    console.log('✓ Linux detected');
+  } else {
+    console.log('✗ Non-Linux OS detected (systemd requires Linux)');
+  }
+
+  if (info.systemctl) {
+    console.log('✓ systemctl available');
+  } else {
+    console.log('✗ systemctl command not found');
+  }
+
+  if (info.systemdRunning) {
+    console.log('✓ systemd is running');
+  } else {
+    console.log('! systemd is not running as PID 1');
+  }
+
+  if (info.userSystemdAvailable) {
+    console.log('✓ systemd user services available');
+  } else {
+    console.log('! systemd user services unavailable');
+  }
+
+  const n = info.nodeDiag;
+  if (n.found && n.executable) {
+    console.log(`✓ Node.js: ${n.execPath}`);
+    if (n.version) {
+      console.log(`✓ Node version: ${n.version}`);
+    }
+    if (n.inPath) {
+      console.log('✓ PATH includes node');
+    } else {
+      console.log('! node is not in standard PATH');
+    }
+  } else {
+    console.log(`✗ ${n.error || 'Node.js executable could not be resolved'}`);
+    if (n.solution) {
+      console.log(`\n${n.solution}\n`);
+    }
+  }
+
+  if (info.unitDirWritable) {
+    console.log('✓ Unit directory writable');
+  } else {
+    console.log(`! Unit directory not writable (${info.unitDir})`);
+  }
+
+  if (info.lingering) {
+    console.log('✓ User lingering is enabled');
+  } else {
+    console.log('! User lingering is disabled');
+    console.log('\nUser lingering is disabled.');
+    console.log('The service may stop after logout.');
+    console.log('\nEnable it manually:');
+    console.log(`  loginctl enable-linger ${info.username}\n`);
+  }
+
+  return info;
+}

package/src/index.js

@@ -0,0 +1,70 @@
+import {
+  addService,
+  startService,
+  stopService,
+  restartService,
+  removeService,
+  getServiceStatus,
+  getServiceStatusRaw,
+  listServices,
+  runJournalctlLogs,
+  isLinux,
+  isSystemctlAvailable,
+  isSystemdPID1,
+  isUserSystemdAvailable,
+  checkUserLinger,
+  checkNodeDiagnostics,
+  findNodeExecutable,
+  setCommandRunner,
+  resetCommandRunner
+} from './systemd.js';
+import { getDoctorInfo } from './doctor.js';
+import {
+  getUserUnitDir,
+  getUnitPath,
+  unitFileExists,
+  parseUnitContent
+} from './unit.js';
+import {
+  sanitizeServiceName,
+  getUnitFilename,
+  getServiceNameFromUnit
+} from './utils.js';
+
+export {
+  // Main programmatic service management API
+  addService as createService,
+  addService,
+  startService,
+  stopService,
+  restartService,
+  removeService,
+  getServiceStatus,
+  getServiceStatusRaw,
+  listServices,
+  runJournalctlLogs as getServiceLogs,
+
+  // System & Doctor checks
+  isSystemctlAvailable as isSystemdAvailable,
+  isSystemctlAvailable,
+  isLinux,
+  isSystemdPID1,
+  isUserSystemdAvailable,
+  checkUserLinger,
+  checkNodeDiagnostics,
+  findNodeExecutable,
+  getDoctorInfo,
+
+  // Unit file & path helpers
+  getUserUnitDir,
+  getUnitPath,
+  unitFileExists,
+  parseUnitContent,
+  sanitizeServiceName,
+  getUnitFilename,
+  getServiceNameFromUnit,
+
+  // Runner override for testing
+  setCommandRunner,
+  resetCommandRunner
+};