unitup 0.1.4 → 0.2.0

package/src/doctor.js

@@ -1,15 +1,18 @@
+import fs from 'node:fs';
 import os from 'node:os';
+import { findRuntimeExecutable } from './runtimes/common.js';
 import {
+  checkNodeDiagnostics,
+  checkUserLinger,
   isLinux,
   isSystemctlAvailable,
   isSystemdPID1,
   isUserSystemdAvailable,
   isUserUnitDirWritable,
-  checkUserLinger,
-  checkNodeDiagnostics
+  runCommand
 } from './systemd.js';
 import { getUserUnitDir } from './unit.js';
-import { findRuntimeExecutable } from './runtimes/common.js';
+import { getUnitupDir } from './utils.js';
 
 /**
  * Runs system diagnostic checks and returns structured data.
@@ -17,6 +20,7 @@ import { findRuntimeExecutable } from './runtimes/common.js';
  * @returns {Promise<Object>}
  */
 export async function getDoctorInfo() {
+  const platform = process.platform;
   const linux = isLinux();
   const systemctl = await isSystemctlAvailable();
   const pid1 = await isSystemdPID1();
@@ -25,6 +29,32 @@ export async function getDoctorInfo() {
   const lingering = await checkUserLinger();
   const nodeDiag = await checkNodeDiagnostics();
 
+  // macOS specific checks
+  let launchctlAvailable = false;
+  if (platform === 'darwin') {
+    try {
+      const res = await runCommand('launchctl', ['version']);
+      launchctlAvailable = res.code === 0 || (res.stdout && res.stdout.length > 0) || !res.stderr.includes('not found');
+    } catch {
+      launchctlAvailable = false;
+    }
+  }
+
+  // Windows specific checks
+  let windowsScmAvailable = false;
+  let isAdmin = false;
+  if (platform === 'win32') {
+    try {
+      const res = await runCommand('sc.exe', ['query']);
+      windowsScmAvailable = res.code === 0 || !res.stderr.includes('not found');
+      // Simple admin check: net session or whoami /priv
+      const adminRes = await runCommand('net', ['session']);
+      isAdmin = adminRes.code === 0;
+    } catch {
+      windowsScmAvailable = false;
+    }
+  }
+
   const nodePath = nodeDiag.execPath || (await findRuntimeExecutable(['node']));
   const pythonPath = await findRuntimeExecutable(['python3', 'python']);
   const rubyPath = await findRuntimeExecutable(['ruby']);
@@ -36,13 +66,13 @@ export async function getDoctorInfo() {
 
   const runtimes = {
     'Node.js': nodePath,
-    'Python': pythonPath,
-    'Ruby': rubyPath,
-    'PHP': phpPath,
-    'Bun': bunPath,
-    'Deno': denoPath,
-    'Go': goPath,
-    'Elixir': elixirPath
+    Python: pythonPath,
+    Ruby: rubyPath,
+    PHP: phpPath,
+    Bun: bunPath,
+    Deno: denoPath,
+    Go: goPath,
+    Elixir: elixirPath
   };
 
   let cgroupV2 = false;
@@ -60,11 +90,20 @@ export async function getDoctorInfo() {
   const memoryMaxSupported = linux && (cgroupV2 || userSystemd);
   const memorySwapMaxSupported = linux && cgroupV2 && memoryController;
 
+  let serviceManager = 'systemd';
+  if (platform === 'darwin') serviceManager = 'launchd';
+  else if (platform === 'win32') serviceManager = 'Windows Service Manager';
+
   return {
+    platform,
+    serviceManager,
     linux,
     systemctl,
     systemdRunning: pid1,
     userSystemdAvailable: userSystemd,
+    launchctlAvailable,
+    windowsScmAvailable,
+    isAdmin,
     cgroupV2,
     memoryController,
     memoryMaxSupported,
@@ -74,6 +113,7 @@ export async function getDoctorInfo() {
     nodeVersion: nodeDiag.version,
     runtimes,
     unitDir: getUserUnitDir(),
+    unitupDataDir: getUnitupDir(),
     unitDirWritable,
     lingering,
     username: os.userInfo().username
@@ -89,27 +129,49 @@ export async function runDoctor() {
   const info = await getDoctorInfo();
 
   if (info.linux) {
+    console.log('Platform: Linux');
+    console.log('Service manager: systemd');
+    console.log(`Node: ${info.nodePath} ${info.nodeVersion ? `(${info.nodeVersion})` : ''}`);
+    console.log(`Unitup data: ${info.unitupDataDir}`);
     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.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.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');
+    if (info.userSystemdAvailable) {
+      console.log('✓ systemd user services available');
+    } else {
+      console.log('! systemd user services unavailable');
+    }
+  } else if (info.platform === 'darwin') {
+    console.log('Platform: macOS');
+    console.log('Service manager: launchd');
+    console.log(`Node: ${info.nodePath} ${info.nodeVersion ? `(${info.nodeVersion})` : ''}`);
+    console.log(`Unitup data: ${info.unitupDataDir}`);
+    console.log('! Non-Linux OS detected (macOS uses launchd)');
+    console.log('✓ launchctl: available');
+    console.log('✓ Permissions: user services supported');
+  } else if (info.platform === 'win32') {
+    console.log('Platform: Windows');
+    console.log('Service manager: Windows Service Manager');
+    console.log(`Node: ${info.nodePath} ${info.nodeVersion ? `(${info.nodeVersion})` : ''}`);
+    console.log(`Unitup data: ${info.unitupDataDir}`);
+    console.log('! Non-Linux OS detected (Windows uses Windows Services)');
+    console.log(`Administrator: ${info.isAdmin ? 'yes' : 'no'}`);
+    if (!info.isAdmin) {
+      console.log('! Service installation requires Administrator privileges');
+    }
   } else {
-    console.log('! systemd user services unavailable');
+    console.log(`✗ Non-Linux OS detected (${info.platform})`);
   }
 
   console.log('\nDetected runtimes:');
@@ -121,48 +183,53 @@ export async function runDoctor() {
     }
   }
 
-  console.log('\nMemory Controller Diagnostics:');
-  if (info.cgroupV2) {
-    console.log('✓ cgroup v2 detected');
-  } else {
-    console.log('- cgroup v2 unavailable');
-  }
+  if (info.linux) {
+    console.log('\nMemory Controller Diagnostics:');
+    if (info.cgroupV2) {
+      console.log('✓ cgroup v2 detected');
+    } else {
+      console.log('- cgroup v2 unavailable');
+    }
 
-  if (info.memoryController) {
-    console.log('✓ Memory controller available');
-  } else {
-    console.log('- Memory controller unavailable');
-  }
+    if (info.memoryController) {
+      console.log('✓ Memory controller available');
+    } else {
+      console.log('- Memory controller unavailable');
+    }
 
-  if (info.memoryMaxSupported) {
-    console.log('✓ MemoryMax supported');
-  } else {
-    console.log('- MemoryMax unavailable');
-  }
+    if (info.memoryMaxSupported) {
+      console.log('✓ MemoryMax supported');
+    } else {
+      console.log('- MemoryMax unavailable');
+    }
 
-  if (info.memorySwapMaxSupported) {
-    console.log('✓ MemorySwapMax supported');
-  } else {
-    console.log('- MemorySwapMax unavailable');
-  }
+    if (info.memorySwapMaxSupported) {
+      console.log('✓ MemorySwapMax supported');
+    } else {
+      console.log('- MemorySwapMax unavailable');
+    }
 
-  console.log('');
+    console.log('');
 
-  if (info.unitDirWritable) {
-    console.log('✓ Unit directory writable');
-  } else {
-    console.log(`! Unit directory not writable (${info.unitDir})`);
+    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`);
+    if (info.linux) {
+      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`);
+    }
   }
 
+  console.log('\n✓ Unitup can manage services on this machine');
   return info;
 }

package/src/errors.js

@@ -0,0 +1,131 @@
+/**
+ * Base error class for all Unitup errors.
+ */
+export class UnitupError extends Error {
+  /**
+   * @param {string} message
+   * @param {string} [code]
+   */
+  constructor(message, code = 'UNITUP_ERROR') {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+}
+
+/**
+ * Thrown when an unsupported platform is encountered.
+ */
+export class UnsupportedPlatformError extends UnitupError {
+  /**
+   * @param {string} [platform]
+   */
+  constructor(platform = process.platform) {
+    super(`Platform "${platform}" is not supported by Unitup.`, 'ERR_UNSUPPORTED_PLATFORM');
+    this.platform = platform;
+  }
+}
+
+/**
+ * Thrown when a specified service is not found.
+ */
+export class ServiceNotFoundError extends UnitupError {
+  /**
+   * @param {string} name
+   */
+  constructor(name) {
+    super(`Service "${name}" does not exist.`, 'ERR_SERVICE_NOT_FOUND');
+    this.serviceName = name;
+  }
+}
+
+/**
+ * Thrown when attempting to create a service that already exists without overwrite/force.
+ */
+export class ServiceAlreadyExistsError extends UnitupError {
+  /**
+   * @param {string} name
+   */
+  constructor(name) {
+    super(`Service "${name}" already exists. Use --force to overwrite.`, 'ERR_SERVICE_ALREADY_EXISTS');
+    this.serviceName = name;
+  }
+}
+
+/**
+ * Thrown when elevated administrator or root privileges are required for an action.
+ */
+export class PermissionRequiredError extends UnitupError {
+  /**
+   * @param {string} message
+   * @param {string} [action]
+   */
+  constructor(message = 'Administrator/root privileges are required to perform this action.', action) {
+    super(message, 'ERR_PERMISSION_REQUIRED');
+    this.action = action;
+  }
+}
+
+/**
+ * Thrown when a service fails to start.
+ */
+export class ServiceStartError extends UnitupError {
+  /**
+   * @param {string} name
+   * @param {string} [reason]
+   */
+  constructor(name, reason) {
+    super(`Failed to start service "${name}"${reason ? `: ${reason}` : ''}`, 'ERR_SERVICE_START');
+    this.serviceName = name;
+    this.reason = reason;
+  }
+}
+
+/**
+ * Thrown when a service fails to stop.
+ */
+export class ServiceStopError extends UnitupError {
+  /**
+   * @param {string} name
+   * @param {string} [reason]
+   */
+  constructor(name, reason) {
+    super(`Failed to stop service "${name}"${reason ? `: ${reason}` : ''}`, 'ERR_SERVICE_STOP');
+    this.serviceName = name;
+    this.reason = reason;
+  }
+}
+
+/**
+ * Thrown when service configuration is invalid.
+ */
+export class InvalidServiceConfigError extends UnitupError {
+  /**
+   * @param {string} message
+   * @param {string} [field]
+   */
+  constructor(message, field) {
+    super(message, 'ERR_INVALID_CONFIG');
+    this.field = field;
+  }
+}
+
+/**
+ * Thrown when a required binary executable cannot be resolved.
+ */
+export class ExecutableNotFoundError extends UnitupError {
+  /**
+   * @param {string} executable
+   * @param {string} [message]
+   */
+  constructor(executable, message) {
+    super(
+      message || `Executable "${executable}" could not be found in PATH or at specified path.`,
+      'ERR_EXECUTABLE_NOT_FOUND'
+    );
+    this.executable = executable;
+  }
+}

package/src/index.js

@@ -1,78 +1,153 @@
+import { getDoctorInfo, runDoctor } from './doctor.js';
+import {
+  ExecutableNotFoundError,
+  InvalidServiceConfigError,
+  PermissionRequiredError,
+  ServiceAlreadyExistsError,
+  ServiceNotFoundError,
+  ServiceStartError,
+  ServiceStopError,
+  UnitupError,
+  UnsupportedPlatformError
+} from './errors.js';
+import { readServiceLogs } from './logs.js';
+import {
+  LinuxAdapter,
+  MacOSAdapter,
+  ServiceAdapter,
+  WindowsAdapter,
+  getAdapter,
+  getPlatformCapabilities
+} from './platform/index.js';
+import { WindowsServiceHost } from './platform/windows-host.js';
+import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
+import {
+  createSchedule,
+  disableSchedule,
+  enableSchedule,
+  getScheduleStatus,
+  listSchedules,
+  removeSchedule,
+  runSchedule,
+  validateCalendar
+} from './schedule.js';
+import { ServiceManager, defaultManager } from './service/manager.js';
+import { normalizeServiceConfig, resolveExecutable } from './service/normalize.js';
 import {
   addService,
-  startService,
-  stopService,
-  restartService,
-  removeService,
+  checkNodeDiagnostics,
+  checkUserLinger,
+  executeJournalctlMaintenance,
+  findNodeExecutable,
+  getAllServicesMemoryUsage,
+  getServiceFailures,
+  getServiceMemoryUsage,
   getServiceStatus,
   getServiceStatusRaw,
-  listServices,
-  inspectService,
-  getServiceFailures,
   getServicesByGroup,
-  runJournalctlLogs,
-  setServiceLimits,
-  executeJournalctlMaintenance,
+  inspectService,
   isLinux,
   isSystemctlAvailable,
   isSystemdPID1,
   isUserSystemdAvailable,
-  checkUserLinger,
-  checkNodeDiagnostics,
-  findNodeExecutable,
-  getServiceMemoryUsage,
-  getAllServicesMemoryUsage,
+  listServices,
+  removeService,
+  resetCommandRunner,
+  restartService,
+  runCommand,
+  runJournalctlLogs,
   setCommandRunner,
-  resetCommandRunner
+  setServiceLimits,
+  startService,
+  stopService
 } from './systemd.js';
-import { getDoctorInfo } from './doctor.js';
-import {
-  createSchedule,
-  listSchedules,
-  getScheduleStatus,
-  runSchedule,
-  enableSchedule,
-  disableSchedule,
-  removeSchedule,
-  validateCalendar
-} from './schedule.js';
 import {
-  getUserUnitDir,
-  getUnitPath,
+  generateScheduleServiceContent,
+  generateTimerContent,
   getTimerPath,
-  unitFileExists,
-  timerFileExists,
+  getUnitPath,
+  getUserUnitDir,
   parseUnitContent,
-  generateTimerContent,
-  generateScheduleServiceContent
+  timerFileExists,
+  unitFileExists
 } from './unit.js';
 import {
-  sanitizeServiceName,
-  getUnitFilename,
-  getTimerFilename,
-  getServiceNameFromUnit,
-  readAppMetadata,
+  findProjectConfig,
+  formatMemoryBytes,
   getAppMetadataPath,
-  readScheduleMetadata,
+  getAppsDir,
+  getConfigFilepath,
   getScheduleMetadataPath,
+  getSchedulesDir,
+  getServiceNameFromUnit,
+  getTimerFilename,
+  getUnitFilename,
+  getUnitupDir,
+  readAppMetadata,
   readGlobalConfig,
-  saveGlobalConfig,
-  getConfigFilepath,
-  findProjectConfig,
   readProjectConfig,
-  saveProjectConfig,
+  readScheduleMetadata,
   resolveEffectiveMemoryLimits,
-  getSchedulesDir,
-  getAppsDir,
-  getUnitupDir,
-  validateMemorySize,
+  sanitizeServiceName,
+  saveGlobalConfig,
+  saveProjectConfig,
   validateDuration,
-  formatMemoryBytes
+  validateMemorySize
 } from './utils.js';
-import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
+
+// Aliases for unified cross-platform API
+const install = (opts) => defaultManager.install(opts);
+const uninstall = (name, opts) => defaultManager.uninstall(name, opts);
+const start = (name, opts) => defaultManager.start(name, opts);
+const stop = (name, opts) => defaultManager.stop(name, opts);
+const restart = (name, opts) => defaultManager.restart(name, opts);
+const status = (name, opts) => defaultManager.status(name, opts);
+const list = (opts) => defaultManager.list(opts);
+const inspect = (name, opts) => defaultManager.inspect(name, opts);
+const logs = (name, opts) => defaultManager.logs(name, opts);
+const enable = (name, opts) => defaultManager.enable(name, opts);
+const disable = (name, opts) => defaultManager.disable(name, opts);
+const platform = (targetPlatform) => getPlatformCapabilities(targetPlatform);
 
 export {
-  // Main programmatic service management API
+  // Unified cross-platform API
+  install,
+  uninstall,
+  start,
+  stop,
+  restart,
+  status,
+  list,
+  inspect,
+  logs,
+  enable,
+  disable,
+  platform,
+  ServiceManager,
+  defaultManager,
+  // Platform Adapters & Factory
+  ServiceAdapter,
+  LinuxAdapter,
+  MacOSAdapter,
+  WindowsAdapter,
+  WindowsServiceHost,
+  getAdapter,
+  getPlatformCapabilities,
+  // Normalization & Resolution
+  normalizeServiceConfig,
+  resolveExecutable,
+  readServiceLogs,
+  // Error hierarchy
+  UnitupError,
+  UnsupportedPlatformError,
+  ServiceNotFoundError,
+  ServiceAlreadyExistsError,
+  PermissionRequiredError,
+  ServiceStartError,
+  ServiceStopError,
+  InvalidServiceConfigError,
+  ExecutableNotFoundError,
+  // Main programmatic service management API (backward compatible)
   addService as createService,
   addService,
   startService,
@@ -88,9 +163,9 @@ export {
   setServiceLimits,
   getServiceMemoryUsage,
   getAllServicesMemoryUsage,
-  executeJournalctlMaintenance as executeJournalctlMaintenance,
+  executeJournalctlMaintenance,
   runJournalctlLogs as getServiceLogs,
-
+  runJournalctlLogs,
   // Programmatic schedule management API
   createSchedule,
   listSchedules,
@@ -100,16 +175,13 @@ export {
   disableSchedule,
   removeSchedule,
   validateCalendar,
-
   // Duration & Validation helpers
   validateMemorySize,
   validateDuration,
   formatMemoryBytes,
-
   // Runtime detection & resolution
   detectRuntime,
   resolveRuntimeConfig,
-
   // Metadata & Config helpers
   readAppMetadata,
   getAppMetadataPath,
@@ -125,7 +197,6 @@ export {
   getSchedulesDir,
   getAppsDir,
   getUnitupDir,
-
   // System & Doctor checks
   isSystemctlAvailable as isSystemdAvailable,
   isSystemctlAvailable,
@@ -136,7 +207,7 @@ export {
   checkNodeDiagnostics,
   findNodeExecutable,
   getDoctorInfo,
-
+  runDoctor,
   // Unit file & path helpers
   getUserUnitDir,
   getUnitPath,
@@ -150,8 +221,10 @@ export {
   getUnitFilename,
   getTimerFilename,
   getServiceNameFromUnit,
-
   // Runner override for testing
   setCommandRunner,
-  resetCommandRunner
+  resetCommandRunner,
+  runCommand
 };
+
+export default defaultManager;