unitup 0.0.9 → 0.0.10

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
+  };
+}

package/src/runtimes/php.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createPhpAdapter(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(['php']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'PHP runtime could not be found.\n\nInstall PHP or specify its path:\n  unitup add index.php --command /usr/bin/php'
+    );
+  }
+
+  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: 'php',
+    version
+  };
+}

package/src/runtimes/python.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createPythonAdapter(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(['python3', 'python']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Python runtime could not be found.\n\nInstall Python or specify its path:\n  unitup add worker.py --command /usr/bin/python3'
+    );
+  }
+
+  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 = [...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'python',
+    version
+  };
+}

package/src/runtimes/ruby.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createRubyAdapter(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(['ruby']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Ruby runtime could not be found.\n\nInstall Ruby or specify its path:\n  unitup add app.rb --command /usr/bin/ruby'
+    );
+  }
+
+  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: 'ruby',
+    version
+  };
+}

package/src/runtimes/shell.js

@@ -0,0 +1,46 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { findRuntimeExecutable, getBinaryVersion } from './common.js';
+
+export async function createShellAdapter(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(['bash', 'sh']);
+  }
+
+  if (!execPath) {
+    throw new Error(
+      'Shell runtime could not be found.\n\nInstall bash/sh or specify its path:\n  unitup add script.sh --command /bin/bash'
+    );
+  }
+
+  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 = [...runtimeArgs];
+  if (scriptPath) {
+    args.push(scriptPath);
+  }
+  args.push(...scriptArgs);
+
+  return {
+    command: execPath,
+    args,
+    runtime: 'shell',
+    version
+  };
+}