unitup 0.0.8 → 0.0.10

package/src/doctor.js

@@ -9,6 +9,7 @@ import {
   checkNodeDiagnostics
 } from './systemd.js';
 import { getUserUnitDir } from './unit.js';
+import { findRuntimeExecutable } from './runtimes/common.js';
 
 /**
  * Runs system diagnostic checks and returns structured data.
@@ -24,14 +25,54 @@ export async function getDoctorInfo() {
   const lingering = await checkUserLinger();
   const nodeDiag = await checkNodeDiagnostics();
 
+  const nodePath = nodeDiag.execPath || (await findRuntimeExecutable(['node']));
+  const pythonPath = await findRuntimeExecutable(['python3', 'python']);
+  const rubyPath = await findRuntimeExecutable(['ruby']);
+  const phpPath = await findRuntimeExecutable(['php']);
+  const bunPath = await findRuntimeExecutable(['bun']);
+  const denoPath = await findRuntimeExecutable(['deno']);
+  const goPath = await findRuntimeExecutable(['go']);
+  const elixirPath = await findRuntimeExecutable(['elixir']);
+
+  const runtimes = {
+    'Node.js': nodePath,
+    'Python': pythonPath,
+    'Ruby': rubyPath,
+    'PHP': phpPath,
+    'Bun': bunPath,
+    'Deno': denoPath,
+    'Go': goPath,
+    'Elixir': elixirPath
+  };
+
+  let cgroupV2 = false;
+  let memoryController = false;
+  try {
+    if (fs.existsSync('/sys/fs/cgroup/cgroup.controllers')) {
+      cgroupV2 = true;
+      const controllers = fs.readFileSync('/sys/fs/cgroup/cgroup.controllers', 'utf8');
+      memoryController = controllers.includes('memory');
+    }
+  } catch {
+    // ignore
+  }
+
+  const memoryMaxSupported = linux && (cgroupV2 || userSystemd);
+  const memorySwapMaxSupported = linux && cgroupV2 && memoryController;
+
   return {
     linux,
     systemctl,
     systemdRunning: pid1,
     userSystemdAvailable: userSystemd,
+    cgroupV2,
+    memoryController,
+    memoryMaxSupported,
+    memorySwapMaxSupported,
     nodeDiag,
-    nodePath: nodeDiag.execPath || process.execPath,
+    nodePath: nodePath || process.execPath,
     nodeVersion: nodeDiag.version,
+    runtimes,
     unitDir: getUserUnitDir(),
     unitDirWritable,
     lingering,
@@ -71,24 +112,42 @@ export async function runDoctor() {
     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');
+  console.log('\nDetected runtimes:');
+  for (const [name, path] of Object.entries(info.runtimes)) {
+    if (path) {
+      console.log(`✓ ${name}: ${path}`);
     } else {
-      console.log('! node is not in standard PATH');
+      console.log(`- ${name}: not found`);
     }
+  }
+
+  console.log('\nMemory Controller Diagnostics:');
+  if (info.cgroupV2) {
+    console.log('✓ cgroup v2 detected');
   } else {
-    console.log(`✗ ${n.error || 'Node.js executable could not be resolved'}`);
-    if (n.solution) {
-      console.log(`\n${n.solution}\n`);
-    }
+    console.log('- cgroup v2 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.memorySwapMaxSupported) {
+    console.log('✓ MemorySwapMax supported');
+  } else {
+    console.log('- MemorySwapMax unavailable');
+  }
+
+  console.log('');
+
   if (info.unitDirWritable) {
     console.log('✓ Unit directory writable');
   } else {

package/src/index.js

@@ -7,7 +7,12 @@ import {
   getServiceStatus,
   getServiceStatusRaw,
   listServices,
+  inspectService,
+  getServiceFailures,
+  getServicesByGroup,
   runJournalctlLogs,
+  setServiceLimits,
+  executeJournalctlMaintenance,
   isLinux,
   isSystemctlAvailable,
   isSystemdPID1,
@@ -28,8 +33,15 @@ import {
 import {
   sanitizeServiceName,
   getUnitFilename,
-  getServiceNameFromUnit
+  getServiceNameFromUnit,
+  readAppMetadata,
+  getAppMetadataPath,
+  getAppsDir,
+  getUnitupDir,
+  validateMemorySize,
+  formatMemoryBytes
 } from './utils.js';
+import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
 
 export {
   // Main programmatic service management API
@@ -42,8 +54,27 @@ export {
   getServiceStatus,
   getServiceStatusRaw,
   listServices,
+  inspectService,
+  getServiceFailures,
+  getServicesByGroup,
+  setServiceLimits,
+  executeJournalctlMaintenance as executeJournalctlMaintenance,
   runJournalctlLogs as getServiceLogs,
 
+  // Memory & Validation helpers
+  validateMemorySize,
+  formatMemoryBytes,
+
+  // Runtime detection & resolution
+  detectRuntime,
+  resolveRuntimeConfig,
+
+  // Metadata helpers
+  readAppMetadata,
+  getAppMetadataPath,
+  getAppsDir,
+  getUnitupDir,
+
   // System & Doctor checks
   isSystemctlAvailable as isSystemdAvailable,
   isSystemctlAvailable,

package/src/runtimes/bun.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createBunAdapter(opts = {}) {
+  const customPath = opts.command;
+  let execPath = null;
+
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        execPath = absPath;
+      } catch {}
+    }
+  }
+
+  if (!execPath) {
+    execPath = await findRuntimeExecutable(['bun']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Bun runtime could not be found.\n\nInstall Bun or specify its path:\n  unitup add server.ts --command /usr/bin/bun'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '-v');
+  const scriptPath = opts.script ? path.resolve(process.cwd(), opts.script) : null;
+  const runtimeArgs = Array.isArray(opts.runtimeArgs) ? opts.runtimeArgs : [];
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  const args = [...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'bun',
+    version
+  };
+}

package/src/runtimes/common.js

@@ -0,0 +1,73 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { runCommand } from '../systemd.js';
+
+export function findExecutableInPath(binaryName) {
+  // 1. Check standard PATH env
+  const envPath = process.env.PATH || '';
+  const dirs = envPath.split(path.delimiter).filter(Boolean);
+  
+  for (const dir of dirs) {
+    const full = path.join(dir, binaryName);
+    try {
+      if (fs.existsSync(full)) {
+        fs.accessSync(full, fs.constants.X_OK);
+        return full;
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return null;
+}
+
+export async function findRuntimeExecutable(binaryNames) {
+  const names = Array.isArray(binaryNames) ? binaryNames : [binaryNames];
+
+  for (const name of names) {
+    if (path.isAbsolute(name)) {
+      if (fs.existsSync(name)) {
+        try {
+          fs.accessSync(name, fs.constants.X_OK);
+          return name;
+        } catch {
+          // ignore
+        }
+      }
+      continue;
+    }
+
+    // Try finding in system PATH directly
+    const foundInPath = findExecutableInPath(name);
+    if (foundInPath) return foundInPath;
+
+    // Fallback to which/where system call
+    try {
+      const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+      const res = await runCommand(whichCmd, [name]);
+      if (res.code === 0 && res.stdout.trim()) {
+        const p = res.stdout.trim().split('\n')[0].trim();
+        if (fs.existsSync(p)) {
+          fs.accessSync(p, fs.constants.X_OK);
+          return p;
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return null;
+}
+
+export async function getBinaryVersion(execPath, versionFlag = '-v') {
+  try {
+    const res = await runCommand(execPath, [versionFlag]);
+    if (res.code === 0 && res.stdout.trim()) {
+      return res.stdout.trim().split('\n')[0].trim();
+    }
+  } catch {
+    // ignore
+  }
+  return 'unknown';
+}

package/src/runtimes/deno.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createDenoAdapter(opts = {}) {
+  const customPath = opts.command;
+  let execPath = null;
+
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        execPath = absPath;
+      } catch {}
+    }
+  }
+
+  if (!execPath) {
+    execPath = await findRuntimeExecutable(['deno']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Deno runtime could not be found.\n\nInstall Deno or specify its path:\n  unitup add server.ts --command /usr/bin/deno'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '--version');
+  const scriptPath = opts.script ? path.resolve(process.cwd(), opts.script) : null;
+  const runtimeArgs = Array.isArray(opts.runtimeArgs) ? opts.runtimeArgs : [];
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  const args = ['run', ...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'deno',
+    version
+  };
+}

package/src/runtimes/elixir.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createElixirAdapter(opts = {}) {
+  const customPath = opts.command;
+  let execPath = null;
+
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        execPath = absPath;
+      } catch {}
+    }
+  }
+
+  if (!execPath) {
+    execPath = await findRuntimeExecutable(['elixir']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Elixir runtime could not be found.\n\nInstall Elixir or specify its path:\n  unitup add app.exs --command /usr/bin/elixir'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '-v');
+  const scriptPath = opts.script ? path.resolve(process.cwd(), opts.script) : null;
+  const runtimeArgs = Array.isArray(opts.runtimeArgs) ? opts.runtimeArgs : [];
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  const args = [...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'elixir',
+    version
+  };
+}

package/src/runtimes/go.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createGoAdapter(opts = {}) {
+  const customPath = opts.command;
+  let execPath = null;
+
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        execPath = absPath;
+      } catch {}
+    }
+  }
+
+  if (!execPath) {
+    execPath = await findRuntimeExecutable(['go']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Go runtime could not be found.\n\nInstall Go or specify its path:\n  unitup add main.go --command /usr/local/go/bin/go'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, 'version');
+  const scriptPath = opts.script ? path.resolve(process.cwd(), opts.script) : null;
+  const runtimeArgs = Array.isArray(opts.runtimeArgs) ? opts.runtimeArgs : [];
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  const args = ['run', ...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'go',
+    version
+  };
+}

package/src/runtimes/index.js

@@ -0,0 +1,155 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { createNodeAdapter } from './node.js';
+import { createPythonAdapter } from './python.js';
+import { createRubyAdapter } from './ruby.js';
+import { createPhpAdapter } from './php.js';
+import { createBunAdapter } from './bun.js';
+import { createDenoAdapter } from './deno.js';
+import { createShellAdapter } from './shell.js';
+import { createNativeAdapter } from './native.js';
+import { createGoAdapter } from './go.js';
+import { createElixirAdapter } from './elixir.js';
+
+export function detectRuntime(filepath) {
+  if (!filepath) {
+    throw new Error('Script path or command is required for runtime detection.');
+  }
+
+  const baseName = path.basename(filepath);
+  const ext = path.extname(baseName).toLowerCase();
+
+  if (ext === '.js' || ext === '.mjs' || ext === '.cjs') {
+    return 'node';
+  }
+  if (ext === '.py') {
+    return 'python';
+  }
+  if (ext === '.rb') {
+    return 'ruby';
+  }
+  if (ext === '.php') {
+    return 'php';
+  }
+  if (ext === '.sh') {
+    return 'shell';
+  }
+  if (ext === '.go') {
+    return 'go';
+  }
+  if (ext === '.ex' || ext === '.exs') {
+    return 'elixir';
+  }
+
+  // Inspect shebang header if file exists
+  const absPath = path.resolve(process.cwd(), filepath);
+  if (fs.existsSync(absPath)) {
+    try {
+      const fd = fs.openSync(absPath, 'r');
+      const buffer = Buffer.alloc(256);
+      const bytesRead = fs.readSync(fd, buffer, 0, 256, 0);
+      fs.closeSync(fd);
+
+      const header = buffer.toString('utf8', 0, bytesRead);
+      const firstLine = header.split('\n')[0].trim();
+
+      if (firstLine.startsWith('#!')) {
+        if (firstLine.includes('python')) return 'python';
+        if (firstLine.includes('node')) return 'node';
+        if (firstLine.includes('ruby')) return 'ruby';
+        if (firstLine.includes('bash') || firstLine.includes('/sh')) return 'shell';
+        if (firstLine.includes('bun')) return 'bun';
+        if (firstLine.includes('deno')) return 'deno';
+        if (firstLine.includes('php')) return 'php';
+        if (firstLine.includes('go')) return 'go';
+        if (firstLine.includes('elixir')) return 'elixir';
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  if (ext === '.ts') {
+    throw new Error(
+      `Could not determine runtime for ${baseName}.\n\nSpecify one:\n  unitup add ${baseName} --runtime bun\n  unitup add ${baseName} --runtime deno\n  unitup add ${baseName} --runtime node`
+    );
+  }
+
+  if (ext === '') {
+    return 'node';
+  }
+
+  throw new Error(
+    `Could not determine runtime for ${baseName}.\n\nSpecify runtime with --runtime <name> or custom executable with --command <path>`
+  );
+}
+
+export async function resolveRuntimeConfig(opts = {}) {
+  // 1. If explicit --command is provided, bypass runtime auto-detection
+  if (opts.command) {
+    const absCommand = path.resolve(process.cwd(), opts.command);
+    if (!fs.existsSync(absCommand)) {
+      // If binary doesn't exist as exact file path, check if it's in PATH or native executable
+      const { findRuntimeExecutable } = await import('./common.js');
+      const resolved = await findRuntimeExecutable([opts.command]);
+      if (!resolved) {
+        throw new Error(`Command executable could not be resolved: ${opts.command}`);
+      }
+      const args = Array.isArray(opts.args) ? opts.args : [];
+      return {
+        command: resolved,
+        args,
+        runtime: opts.runtime || 'custom',
+        version: 'custom'
+      };
+    }
+
+    const args = Array.isArray(opts.args) ? opts.args : [];
+    return {
+      command: absCommand,
+      args,
+      runtime: opts.runtime || 'custom',
+      version: 'custom'
+    };
+  }
+
+  // 2. Resolve target runtime name
+  let runtimeName = opts.runtime;
+  if (!runtimeName) {
+    runtimeName = detectRuntime(opts.script);
+  }
+
+  const cleanRuntime = runtimeName.toLowerCase();
+
+  switch (cleanRuntime) {
+    case 'node':
+    case 'nodejs':
+      return createNodeAdapter(opts);
+    case 'python':
+    case 'python3':
+      return createPythonAdapter(opts);
+    case 'ruby':
+      return createRubyAdapter(opts);
+    case 'php':
+      return createPhpAdapter(opts);
+    case 'bun':
+      return createBunAdapter(opts);
+    case 'deno':
+      return createDenoAdapter(opts);
+    case 'shell':
+    case 'bash':
+    case 'sh':
+      return createShellAdapter(opts);
+    case 'go':
+    case 'golang':
+      return createGoAdapter(opts);
+    case 'elixir':
+    case 'ex':
+    case 'exs':
+      return createElixirAdapter(opts);
+    case 'native':
+      return createNativeAdapter(opts);
+    default:
+      throw new Error(`Unsupported runtime: "${runtimeName}"`);
+  }
+}

package/src/runtimes/native.js

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+export async function createNativeAdapter(opts = {}) {
+  const targetPath = opts.script || opts.command;
+
+  if (!targetPath) {
+    throw new Error('Native executable path is required.');
+  }
+
+  const absPath = path.resolve(process.cwd(), targetPath);
+
+  if (!fs.existsSync(absPath)) {
+    throw new Error(`Executable file does not exist: ${absPath}`);
+  }
+
+  const stat = fs.statSync(absPath);
+  if (!stat.isFile()) {
+    throw new Error(`Executable path is not a file: ${absPath}`);
+  }
+
+  try {
+    fs.accessSync(absPath, fs.constants.X_OK);
+  } catch {
+    throw new Error(
+      `The executable is not runnable.\n\nRun:\n  chmod +x ${absPath}`
+    );
+  }
+
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  return {
+    command: absPath,
+    args: scriptArgs,
+    runtime: 'native',
+    version: 'native'
+  };
+}

package/src/runtimes/node.js

@@ -0,0 +1,57 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createNodeAdapter(opts = {}) {
+  const customPath = opts.command || opts.nodePath;
+  let execPath = null;
+
+  if (customPath) {
+    const absPath = path.resolve(process.cwd(), customPath);
+    if (fs.existsSync(absPath)) {
+      try {
+        fs.accessSync(absPath, fs.constants.X_OK);
+        execPath = absPath;
+      } catch {
+        execPath = null;
+      }
+    }
+  }
+
+  if (!execPath) {
+    if (process.execPath && fs.existsSync(process.execPath)) {
+      try {
+        fs.accessSync(process.execPath, fs.constants.X_OK);
+        execPath = process.execPath;
+      } catch {}
+    }
+  }
+
+  if (!execPath) {
+    execPath = await findRuntimeExecutable(['node']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Node.js runtime could not be found.\n\nInstall Node.js or specify its path:\n  unitup add script.js --command /usr/bin/node'
+    );
+  }
+
+  const version = await getBinaryVersion(execPath, '-v');
+  const scriptPath = opts.script ? path.resolve(process.cwd(), opts.script) : null;
+  const runtimeArgs = Array.isArray(opts.runtimeArgs) ? opts.runtimeArgs : [];
+  const scriptArgs = Array.isArray(opts.args) ? opts.args : [];
+
+  const args = [...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'node',
+    version
+  };
+}