unitup 0.1.5 → 0.2.0

package/src/logs.js

@@ -0,0 +1,148 @@
+import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+
+/**
+ * Reads lines from one or more log files with tailing, filtering, and follow support.
+ *
+ * @param {string|string[]} filePaths
+ * @param {object} [options]
+ * @param {number} [options.lines=100]
+ * @param {boolean} [options.follow=false]
+ * @param {string} [options.grep]
+ * @param {string} [options.since]
+ * @param {boolean} [options.json=false]
+ * @returns {Promise<string|EventEmitter>}
+ */
+export async function readServiceLogs(filePaths, options = {}) {
+  const allCandidatePaths = (Array.isArray(filePaths) ? filePaths : [filePaths]).filter(Boolean);
+  const existingPaths = allCandidatePaths.filter((p) => fs.existsSync(p));
+  existingPaths.sort((a, b) => {
+    try {
+      return fs.statSync(a).mtimeMs - fs.statSync(b).mtimeMs;
+    } catch {
+      return 0;
+    }
+  });
+  const maxLines = typeof options.lines === 'number' && options.lines > 0 ? options.lines : 100;
+  const grepPattern = options.grep ? new RegExp(options.grep, 'i') : null;
+
+  // Collect all lines from currently existing files
+  const allEntries = [];
+  for (const filePath of existingPaths) {
+    try {
+      const stat = fs.statSync(filePath);
+      let content = '';
+
+      // If file is larger than 1MB, read only the tail chunk
+      if (stat.size > 1024 * 1024) {
+        const chunkSize = Math.min(stat.size, Math.max(1024 * 1024, maxLines * 2048));
+        const start = Math.max(0, stat.size - chunkSize);
+        const buffer = Buffer.alloc(stat.size - start);
+        const fd = fs.openSync(filePath, 'r');
+        fs.readSync(fd, buffer, 0, buffer.length, start);
+        fs.closeSync(fd);
+        content = buffer.toString('utf8');
+      } else {
+        content = fs.readFileSync(filePath, 'utf8');
+      }
+
+      const lines = content.split('\n');
+      for (const line of lines) {
+        if (!line && line.trim() === '') continue;
+        if (grepPattern && !grepPattern.test(line)) continue;
+        allEntries.push(line);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  // Slice tail lines
+  const sliced = allEntries.slice(-maxLines);
+
+  if (options.follow) {
+    const emitter = new EventEmitter();
+    const filePositions = new Map();
+
+    for (const p of allCandidatePaths) {
+      try {
+        if (fs.existsSync(p)) {
+          const stat = fs.statSync(p);
+          filePositions.set(p, stat.size);
+        } else {
+          filePositions.set(p, 0);
+        }
+      } catch {
+        filePositions.set(p, 0);
+      }
+    }
+
+    // Print initial existing lines
+    for (const l of sliced) {
+      console.log(l);
+      emitter.emit('line', l);
+    }
+
+    let isPolling = false;
+    const interval = setInterval(() => {
+      if (isPolling) return;
+      isPolling = true;
+
+      try {
+        for (const p of allCandidatePaths) {
+          try {
+            if (!fs.existsSync(p)) continue;
+            const stat = fs.statSync(p);
+            const lastPos = filePositions.get(p) || 0;
+
+            if (stat.size > lastPos) {
+              const stream = fs.createReadStream(p, { start: lastPos, end: stat.size, encoding: 'utf8' });
+              let buffer = '';
+              stream.on('data', (chunk) => {
+                buffer += chunk;
+              });
+              stream.on('end', () => {
+                filePositions.set(p, stat.size);
+                const newLines = buffer.split('\n');
+                for (const line of newLines) {
+                  if (!line || !line.trim()) continue;
+                  if (grepPattern && !grepPattern.test(line)) continue;
+                  console.log(line);
+                  emitter.emit('line', line);
+                }
+              });
+            } else if (stat.size < lastPos) {
+              // File truncated or rotated
+              filePositions.set(p, 0);
+            }
+          } catch {
+            // ignore
+          }
+        }
+      } finally {
+        isPolling = false;
+      }
+    }, 250);
+
+    emitter.stop = () => {
+      clearInterval(interval);
+      emitter.emit('close');
+    };
+
+    return emitter;
+  }
+
+  if (options.json) {
+    return JSON.stringify(
+      sliced.map((line) => ({ message: line })),
+      null,
+      2
+    );
+  }
+
+  if (sliced.length === 0) {
+    return 'No logs found.';
+  }
+
+  return sliced.join('\n');
+}

package/src/platform/base.js

@@ -0,0 +1,211 @@
+import { UnsupportedPlatformError } from '../errors.js';
+import { runCommand } from '../systemd.js';
+
+/**
+ * Base ServiceAdapter class defining the cross-platform contract for service management.
+ */
+export class ServiceAdapter {
+  /**
+   * @param {object} [options]
+   */
+  constructor(options = {}) {
+    this.options = options;
+  }
+
+  /**
+   * Platform identifier name.
+   * @type {string}
+   */
+  get name() {
+    return 'base';
+  }
+
+  /**
+   * Platform capabilities metadata.
+   * @type {object}
+   */
+  get capabilities() {
+    return {
+      serviceManager: 'none',
+      supports: {
+        install: false,
+        uninstall: false,
+        start: false,
+        stop: false,
+        restart: false,
+        enable: false,
+        disable: false,
+        status: false,
+        logs: false,
+        restartPolicy: false,
+        userServices: false,
+        systemServices: false,
+        memoryLimits: false,
+        schedule: false
+      }
+    };
+  }
+
+  /**
+   * Executes a command using the configured command runner.
+   *
+   * @param {string} cmd
+   * @param {string[]} args
+   * @param {object} [opts]
+   * @returns {Promise<{ stdout: string, stderr: string, code: number }>}
+   */
+  async run(cmd, args, opts) {
+    return runCommand(cmd, args, opts);
+  }
+
+  /**
+   * Generates the service definition (unit file, plist, etc.) from normalized config.
+   *
+   * @param {object} config - NormalizedServiceConfig
+   * @returns {string|object}
+   */
+  generateService(config) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Installs a service from normalized config.
+   *
+   * @param {object} config - NormalizedServiceConfig
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async install(config, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Uninstalls a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async uninstall(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Starts a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async start(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Stops a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async stop(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Restarts a service by name.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async restart(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Enables automatic startup for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async enable(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Disables automatic startup for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>}
+   */
+  async disable(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Gets normalized status for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async status(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Inspects detailed configuration and runtime info for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<object>}
+   */
+  async inspect(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Retrieves or streams logs for a service.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<any>}
+   */
+  async logs(name, options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Lists all services.
+   *
+   * @param {object} [options]
+   * @returns {Promise<Array<object>>}
+   */
+  async list(options = {}) {
+    throw new UnsupportedPlatformError(this.name);
+  }
+
+  /**
+   * Checks if a service is installed.
+   *
+   * @param {string} name
+   * @param {object} [options]
+   * @returns {Promise<boolean>|boolean}
+   */
+  isInstalled(name, options = {}) {
+    return false;
+  }
+
+  /**
+   * Lists failed services.
+   *
+   * @param {object} [options]
+   * @returns {Promise<Array<object>>}
+   */
+  async failures(options = {}) {
+    return [];
+  }
+}

package/src/platform/index.js

@@ -0,0 +1,43 @@
+import { UnsupportedPlatformError } from '../errors.js';
+import { ServiceAdapter } from './base.js';
+import { LinuxAdapter } from './linux.js';
+import { MacOSAdapter } from './macos.js';
+import { WindowsAdapter } from './windows.js';
+
+export { ServiceAdapter, LinuxAdapter, MacOSAdapter, WindowsAdapter };
+
+/**
+ * Returns the appropriate platform service adapter for the given OS.
+ *
+ * @param {string} [platform]
+ * @param {object} [options]
+ * @returns {ServiceAdapter}
+ */
+export function getAdapter(platform, options = {}) {
+  const targetPlatform =
+    platform || process.env.UNITUP_PLATFORM || (process.env.XDG_CONFIG_HOME ? 'linux' : process.platform);
+
+  switch (targetPlatform) {
+    case 'linux':
+      return new LinuxAdapter(options);
+    case 'darwin':
+    case 'macos':
+      return new MacOSAdapter(options);
+    case 'win32':
+    case 'windows':
+      return new WindowsAdapter(options);
+    default:
+      throw new UnsupportedPlatformError(targetPlatform);
+  }
+}
+
+/**
+ * Returns platform capabilities for the target or current OS.
+ *
+ * @param {string} [platform]
+ * @returns {object}
+ */
+export function getPlatformCapabilities(platform) {
+  const adapter = getAdapter(platform);
+  return adapter.capabilities;
+}

package/src/platform/linux.js

@@ -0,0 +1,155 @@
+import {
+  addService,
+  getServiceFailures,
+  getServiceShow,
+  getServiceStatus,
+  inspectService,
+  listServices,
+  removeService,
+  restartService,
+  runJournalctlLogs,
+  startService,
+  stopService
+} from '../systemd.js';
+import { generateUnitContent, getUnitPath, unitFileExists } from '../unit.js';
+import { getUnitFilename, sanitizeServiceName } from '../utils.js';
+import { ServiceAdapter } from './base.js';
+
+/**
+ * Linux platform service adapter using systemd and journald.
+ */
+export class LinuxAdapter extends ServiceAdapter {
+  get name() {
+    return 'linux';
+  }
+
+  get capabilities() {
+    return {
+      serviceManager: 'systemd',
+      supports: {
+        install: true,
+        uninstall: true,
+        start: true,
+        stop: true,
+        restart: true,
+        enable: true,
+        disable: true,
+        status: true,
+        logs: true,
+        restartPolicy: true,
+        userServices: true,
+        systemServices: true,
+        memoryLimits: true,
+        schedule: true
+      }
+    };
+  }
+
+  generateService(config) {
+    return generateUnitContent({
+      name: config.name,
+      command: config.command,
+      args: config.args,
+      script: config.script,
+      cwd: config.cwd,
+      env: config.env,
+      envFile: config.envFile,
+      restart: config.restart?.policy || 'on-failure',
+      memoryHigh: config.resources?.memoryHigh,
+      memoryMax: config.resources?.memoryMax,
+      memorySwapMax: config.resources?.memorySwapMax
+    });
+  }
+
+  async install(config, options = {}) {
+    return addService({
+      ...config,
+      ...options,
+      name: config.name,
+      command: config.command,
+      args: config.args,
+      cwd: config.cwd,
+      env: config.env,
+      envFile: config.envFile,
+      restart: config.restart?.policy || 'on-failure',
+      memoryHigh: config.resources?.memoryHigh,
+      memoryMax: config.resources?.memoryMax,
+      memorySwapMax: config.resources?.memorySwapMax,
+      force: options.force || config.raw?.force
+    });
+  }
+
+  async uninstall(name, options = {}) {
+    return removeService(name, options);
+  }
+
+  async start(name, options = {}) {
+    return startService(name, options.enable || false);
+  }
+
+  async stop(name, options = {}) {
+    return stopService(name);
+  }
+
+  async restart(name, options = {}) {
+    return restartService(name);
+  }
+
+  async enable(name, options = {}) {
+    const safeName = sanitizeServiceName(name);
+    const unitFilename = getUnitFilename(safeName);
+    const res = await this.run('systemctl', ['--user', 'enable', unitFilename]);
+    if (res.code !== 0) {
+      throw new Error(`Failed to enable service "${safeName}": ${res.stderr || res.stdout}`);
+    }
+    return true;
+  }
+
+  async disable(name, options = {}) {
+    const safeName = sanitizeServiceName(name);
+    const unitFilename = getUnitFilename(safeName);
+    const res = await this.run('systemctl', ['--user', 'disable', unitFilename]);
+    if (res.code !== 0) {
+      throw new Error(`Failed to disable service "${safeName}": ${res.stderr || res.stdout}`);
+    }
+    return true;
+  }
+
+  async status(name, options = {}) {
+    const statusObj = await getServiceStatus(name);
+    return {
+      ...statusObj,
+      installed: true,
+      state: statusObj.status,
+      enabled: statusObj.enabled !== undefined ? statusObj.enabled : true,
+      platform: 'linux',
+      manager: 'systemd'
+    };
+  }
+
+  async inspect(name, options = {}) {
+    return inspectService(name);
+  }
+
+  async logs(name, options = {}) {
+    return runJournalctlLogs(name, options);
+  }
+
+  async list(options = {}) {
+    const list = await listServices(options);
+    return list.map((item) => ({
+      ...item,
+      platform: 'linux',
+      manager: 'systemd'
+    }));
+  }
+
+  isInstalled(name, options = {}) {
+    const safeName = sanitizeServiceName(name);
+    return unitFileExists(safeName);
+  }
+
+  async failures(options = {}) {
+    return getServiceFailures();
+  }
+}