unitup 0.1.4 → 0.2.0

package/src/service/normalize.js

@@ -0,0 +1,216 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { ExecutableNotFoundError, InvalidServiceConfigError } from '../errors.js';
+import { detectRuntime, resolveRuntimeConfig } from '../runtimes/index.js';
+import { getUnitupDir, resolveEffectiveMemoryLimits, resolveWorkingDirectory, sanitizeServiceName } from '../utils.js';
+
+/**
+ * Resolves a binary or command name to an absolute executable path.
+ * Supports Windows PATHEXT extensions (.exe, .cmd, .bat, etc.) and Unix executable permissions.
+ *
+ * @param {string} binaryName
+ * @param {object} [opts]
+ * @param {string} [opts.cwd]
+ * @param {string} [opts.pathEnv]
+ * @returns {string|null}
+ */
+export function resolveExecutable(binaryName, opts = {}) {
+  if (!binaryName || typeof binaryName !== 'string') {
+    return null;
+  }
+
+  const trimmed = binaryName.trim();
+  if (!trimmed) return null;
+
+  const baseDir = opts.cwd || process.cwd();
+  const isWin = process.platform === 'win32';
+  const pathext = isWin
+    ? (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD;.VBS;.JS;.WSF;.WSC;.MSI').split(';').filter(Boolean)
+    : [''];
+
+  // Helper to check if a specific file is executable
+  function isExecutableFile(targetPath) {
+    try {
+      if (!fs.existsSync(targetPath)) return false;
+      const stat = fs.statSync(targetPath);
+      if (!stat.isFile()) return false;
+      if (isWin) return true;
+      fs.accessSync(targetPath, fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // 1. If path is absolute or explicit relative path (starts with ./, ../, /)
+  if (path.isAbsolute(trimmed) || trimmed.startsWith('./') || trimmed.startsWith('../') || trimmed.startsWith('~/')) {
+    const expanded = trimmed.startsWith('~/')
+      ? path.join(process.env.HOME || process.env.USERPROFILE || '', trimmed.slice(2))
+      : path.resolve(baseDir, trimmed);
+
+    if (isExecutableFile(expanded)) {
+      return fs.realpathSync(expanded);
+    }
+
+    if (isWin) {
+      for (const ext of pathext) {
+        const withExt = expanded + ext.toLowerCase();
+        if (isExecutableFile(withExt)) {
+          return fs.realpathSync(withExt);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  // 2. Look in system PATH
+  const envPath = opts.pathEnv || process.env.PATH || '';
+  const searchDirs = envPath.split(path.delimiter).filter(Boolean);
+
+  for (const dir of searchDirs) {
+    const candidate = path.join(dir, trimmed);
+    if (isExecutableFile(candidate)) {
+      try {
+        return fs.realpathSync(candidate);
+      } catch {
+        return candidate;
+      }
+    }
+
+    if (isWin) {
+      for (const ext of pathext) {
+        const candidateWithExt = candidate + ext.toLowerCase();
+        if (isExecutableFile(candidateWithExt)) {
+          try {
+            return fs.realpathSync(candidateWithExt);
+          } catch {
+            return candidateWithExt;
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Normalizes input service options into a complete, validated NormalizedServiceConfig object.
+ *
+ * @param {object} rawOpts
+ * @returns {Promise<object>} NormalizedServiceConfig
+ */
+export async function normalizeServiceConfig(rawOpts = {}) {
+  if (!rawOpts || typeof rawOpts !== 'object') {
+    throw new InvalidServiceConfigError('Service configuration options must be an object.');
+  }
+
+  const name = rawOpts.name ? sanitizeServiceName(rawOpts.name) : '';
+  if (!name) {
+    throw new InvalidServiceConfigError('Service name is required.', 'name');
+  }
+
+  const cwd = resolveWorkingDirectory(rawOpts);
+  const runtimeConfig = await resolveRuntimeConfig({
+    ...rawOpts,
+    name,
+    cwd
+  });
+
+  const command = runtimeConfig.command;
+  if (!command) {
+    throw new ExecutableNotFoundError(
+      rawOpts.command || rawOpts.script || 'executable',
+      `Executable could not be resolved for service "${name}".`
+    );
+  }
+
+  const args = Array.isArray(runtimeConfig.args) ? [...runtimeConfig.args] : [];
+  const displayName = rawOpts.displayName || rawOpts.name || name;
+  const description = rawOpts.description || `unitup service: ${name}`;
+  const group = rawOpts.group || 'default';
+  const system = !!rawOpts.system;
+  const autostart = rawOpts.autostart !== undefined ? !!rawOpts.autostart : true;
+  const shutdownTimeout =
+    rawOpts.shutdownTimeout !== undefined &&
+    !Number.isNaN(Number(rawOpts.shutdownTimeout)) &&
+    Number(rawOpts.shutdownTimeout) > 0
+      ? Number(rawOpts.shutdownTimeout)
+      : 10000;
+
+  // Environment normalization
+  const env = {};
+  if (rawOpts.env && typeof rawOpts.env === 'object') {
+    for (const [k, v] of Object.entries(rawOpts.env)) {
+      if (v !== undefined && v !== null) {
+        env[k] = String(v);
+      }
+    }
+  }
+
+  // Restart policy normalization
+  let restartPolicy = 'on-failure';
+  let restartEnabled = true;
+  let restartDelay = 3000;
+  let maxRetries = null;
+  let resetAfter = null;
+
+  if (typeof rawOpts.restart === 'string') {
+    restartPolicy = rawOpts.restart;
+    restartEnabled = restartPolicy !== 'no';
+  } else if (rawOpts.restart && typeof rawOpts.restart === 'object') {
+    restartEnabled = rawOpts.restart.enabled !== false;
+    restartPolicy = rawOpts.restart.policy || (restartEnabled ? 'on-failure' : 'no');
+    if (rawOpts.restart.delay !== undefined && !Number.isNaN(Number(rawOpts.restart.delay))) {
+      restartDelay = Number(rawOpts.restart.delay);
+    }
+    if (rawOpts.restart.maxRetries !== undefined && !Number.isNaN(Number(rawOpts.restart.maxRetries))) {
+      maxRetries = Number(rawOpts.restart.maxRetries);
+    }
+    if (rawOpts.restart.resetAfter !== undefined && !Number.isNaN(Number(rawOpts.restart.resetAfter))) {
+      resetAfter = Number(rawOpts.restart.resetAfter);
+    }
+  }
+
+  // Logs normalization
+  const unitupDir = getUnitupDir();
+  const logsDir = path.join(unitupDir, 'logs');
+  const defaultStdout = path.join(logsDir, `${name}.log`);
+  const defaultStderr = path.join(logsDir, `${name}-error.log`);
+
+  const logs = {
+    stdout: rawOpts.logs?.stdout || rawOpts.stdout || defaultStdout,
+    stderr: rawOpts.logs?.stderr || rawOpts.stderr || defaultStderr
+  };
+
+  // Memory and resource limits
+  const resources = resolveEffectiveMemoryLimits(rawOpts);
+
+  return {
+    name,
+    displayName,
+    description,
+    runtime: runtimeConfig.runtime || 'custom',
+    command,
+    args,
+    script: rawOpts.script ? path.resolve(cwd, rawOpts.script) : undefined,
+    cwd,
+    env,
+    envFile: rawOpts.envFile ? path.resolve(cwd, rawOpts.envFile) : undefined,
+    autostart,
+    restart: {
+      enabled: restartEnabled,
+      policy: restartPolicy,
+      delay: restartDelay,
+      maxRetries,
+      resetAfter
+    },
+    logs,
+    group,
+    system,
+    shutdownTimeout,
+    resources,
+    raw: rawOpts
+  };
+}

package/src/systemd.js

@@ -3,22 +3,24 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import {
-  sanitizeServiceName,
-  getUnitFilename,
-  getTimerFilename,
-  formatRelativeTime,
-  readAppMetadata,
-  readScheduleMetadata
-} from './utils.js';
-import {
-  getUserUnitDir,
-  getUnitPath,
-  unitFileExists,
   deleteUnitFile,
+  getUnitPath,
+  getUserUnitDir,
   listUnitFiles,
-  writeUnitFile,
-  parseUnitContent
+  parseUnitContent,
+  unitFileExists,
+  writeUnitFile
 } from './unit.js';
+import {
+  findProjectConfig,
+  formatRelativeTime,
+  getTimerFilename,
+  getUnitFilename,
+  readAppMetadata,
+  readProjectConfig,
+  readScheduleMetadata,
+  sanitizeServiceName
+} from './utils.js';
 
 /**
  * Default runner for executing commands via child_process.execFile.
@@ -281,17 +283,44 @@ export async function resetFailed() {
 }
 
 export async function addService(opts) {
-  const safeName = sanitizeServiceName(opts.name);
+  const targetCwd = opts.cwd ? path.resolve(process.cwd(), opts.cwd) : process.cwd();
+  const configPath = opts.config ? path.resolve(targetCwd, opts.config) : findProjectConfig(targetCwd);
+  const projectCfg = configPath ? readProjectConfig(configPath) : null;
+
+  let mergedOpts = { ...opts };
+  if (projectCfg) {
+    mergedOpts = {
+      name: opts.name || projectCfg.name,
+      group: opts.group || projectCfg.group || 'default',
+      script: opts.script || projectCfg.script,
+      command: opts.command || projectCfg.command,
+      runtime: opts.runtime || projectCfg.runtime,
+      runtimeArgs: opts.runtimeArgs && opts.runtimeArgs.length > 0 ? opts.runtimeArgs : projectCfg.runtimeArgs || [],
+      args: opts.args && opts.args.length > 0 ? opts.args : projectCfg.args || [],
+      envFile: opts.envFile || projectCfg.envFile,
+      restart: opts.restart && opts.restart !== 'on-failure' ? opts.restart : projectCfg.restart || 'on-failure',
+      memoryHigh: opts.memoryHigh || projectCfg?.resources?.memoryHigh || projectCfg?.memoryHigh || '',
+      memoryMax: opts.memoryMax || projectCfg?.resources?.memoryMax || projectCfg?.memoryMax || '',
+      memorySwapMax: opts.memorySwapMax || projectCfg?.resources?.memorySwapMax || projectCfg?.memorySwapMax || '',
+      ...opts,
+      env: { ...(projectCfg.env || {}), ...(opts.env || {}) },
+      cwd: targetCwd
+    };
+  }
+
+  const safeName = sanitizeServiceName(mergedOpts.name);
+  let wasActive = false;
 
   if (unitFileExists(safeName)) {
     try {
       const show = await getServiceShow(safeName);
       if (show.ActiveState === 'active') {
-        if (!opts.force) {
+        wasActive = true;
+        if (!mergedOpts.force) {
           throw new Error(
             `Service "${safeName}" is currently running.\n` +
-            `Use --force (-f) to overwrite running services, or stop it first:\n` +
-            `  unitup stop ${safeName}`
+              `Use --force (-f) to overwrite running services, or stop it first:\n` +
+              `  unitup stop ${safeName}`
           );
         }
       }
@@ -302,20 +331,22 @@ export async function addService(opts) {
     }
   }
 
-  const runtimeConfig = await resolveRuntimeConfig({ ...opts, name: safeName });
+  const runtimeConfig = await resolveRuntimeConfig({ ...mergedOpts, name: safeName });
 
   const { path: unitPath } = writeUnitFile({
-    ...opts,
+    ...mergedOpts,
     name: safeName,
     runtime: runtimeConfig.runtime,
     command: runtimeConfig.command,
     args: runtimeConfig.args,
-    cwd: opts.cwd
+    cwd: mergedOpts.cwd
   });
 
   await daemonReload();
 
-  if (opts.start) {
+  if (wasActive && mergedOpts.force) {
+    await restartService(safeName);
+  } else if (mergedOpts.start) {
     await startService(safeName, true);
   }
 
@@ -423,8 +454,8 @@ export async function removeService(name, opts = {}) {
       if (!force) {
         throw new Error(
           `Service "${safeName}" is currently running.\n` +
-          `Use --force (-f) to remove running services, or stop it first:\n` +
-          `  unitup stop ${safeName}`
+            `Use --force (-f) to remove running services, or stop it first:\n` +
+            `  unitup stop ${safeName}`
         );
       }
     }
@@ -514,9 +545,7 @@ export async function getServiceStatus(name) {
   const pid = show.MainPID && show.MainPID !== '0' ? show.MainPID : '-';
   const restarts = show.NRestarts ?? '0';
   const startedRaw = show.ActiveEnterTimestamp;
-  const started = startedRaw && startedRaw !== '0' && startedRaw !== 'n/a'
-    ? formatRelativeTime(startedRaw)
-    : 'never';
+  const started = startedRaw && startedRaw !== '0' && startedRaw !== 'n/a' ? formatRelativeTime(startedRaw) : 'never';
 
   const meta = readAppMetadata(safeName) || readScheduleMetadata(safeName);
   const command = meta?.command || parsed.command || meta?.node || process.execPath;
@@ -589,7 +618,7 @@ export async function listServices(filterOpts = {}) {
       } else {
         const cmdBase = path.basename(meta.command);
         const argsStr = (meta.args || [])
-          .map(a => (a.startsWith('/') || a.startsWith('./') ? path.basename(a) : a))
+          .map((a) => (a.startsWith('/') || a.startsWith('./') ? path.basename(a) : a))
           .join(' ');
         commandSummary = (cmdBase + (argsStr ? ' ' + argsStr : '')).trim();
       }
@@ -641,9 +670,8 @@ export async function listServices(filterOpts = {}) {
       const pid = show.MainPID && show.MainPID !== '0' ? show.MainPID : '-';
       const restarts = show.NRestarts ?? '0';
       const startedRaw = show.ActiveEnterTimestamp;
-      const uptime = startedRaw && startedRaw !== '0' && startedRaw !== 'n/a'
-        ? formatRelativeTime(startedRaw)
-        : 'never';
+      const uptime =
+        startedRaw && startedRaw !== '0' && startedRaw !== 'n/a' ? formatRelativeTime(startedRaw) : 'never';
 
       result.push({
         name: unit.name,
@@ -757,8 +785,13 @@ export async function runJournalctlLogs(name, opts = {}) {
 
   if (opts.diskUsage) {
     const res = await runCommand('journalctl', ['--disk-usage']);
-    if (res.code !== 0 && (res.stderr.toLowerCase().includes('permission') || res.stderr.toLowerCase().includes('root'))) {
-      throw new Error('Journal maintenance requires additional privileges on this system.\nRun the command manually with the appropriate permissions.');
+    if (
+      res.code !== 0 &&
+      (res.stderr.toLowerCase().includes('permission') || res.stderr.toLowerCase().includes('root'))
+    ) {
+      throw new Error(
+        'Journal maintenance requires additional privileges on this system.\nRun the command manually with the appropriate permissions.'
+      );
     }
     return res.stdout || res.stderr;
   }
@@ -920,7 +953,7 @@ export async function executeJournalctlMaintenance(action, opts = {}) {
       }
       args.push(`--vacuum-time=${timeStr}`);
     } else if (opts.files) {
-      const filesNum = parseInt(opts.files, 10);
+      const filesNum = Number.parseInt(opts.files, 10);
       if (Number.isNaN(filesNum) || filesNum <= 0) {
         throw new Error(`Invalid vacuum files count: "${opts.files}". Must be a positive integer.`);
       }
@@ -937,8 +970,15 @@ export async function executeJournalctlMaintenance(action, opts = {}) {
   }
 
   const res = await runCommand('journalctl', args);
-  if (res.code !== 0 && (res.stderr.toLowerCase().includes('permission') || res.stderr.toLowerCase().includes('root') || res.stderr.toLowerCase().includes('access denied'))) {
-    throw new Error('Journal maintenance requires additional privileges on this system.\nRun the command manually with the appropriate permissions.');
+  if (
+    res.code !== 0 &&
+    (res.stderr.toLowerCase().includes('permission') ||
+      res.stderr.toLowerCase().includes('root') ||
+      res.stderr.toLowerCase().includes('access denied'))
+  ) {
+    throw new Error(
+      'Journal maintenance requires additional privileges on this system.\nRun the command manually with the appropriate permissions.'
+    );
   }
 
   return (res.stdout || res.stderr || 'Journal maintenance completed successfully.').trim();
@@ -978,9 +1018,15 @@ export async function getServiceMemoryUsage(name) {
   const effective = resolveEffectiveMemoryLimits(meta || {});
 
   const memoryCurrentBytes = Number(props.MemoryCurrent);
-  const rawBytes = !isNaN(memoryCurrentBytes) && memoryCurrentBytes > 0 && memoryCurrentBytes < 1e15 ? memoryCurrentBytes : 0;
+  const rawBytes =
+    !isNaN(memoryCurrentBytes) && memoryCurrentBytes > 0 && memoryCurrentBytes < 1e15 ? memoryCurrentBytes : 0;
 
-  const status = props.ActiveState === 'active' ? (props.SubState === 'running' ? 'running' : props.SubState || 'active') : (props.ActiveState || 'stopped');
+  const status =
+    props.ActiveState === 'active'
+      ? props.SubState === 'running'
+        ? 'running'
+        : props.SubState || 'active'
+      : props.ActiveState || 'stopped';
 
   return {
     name: safeName,
@@ -1060,7 +1106,7 @@ export async function getAllServicesMemoryUsage(opts = {}) {
     }
   }
 
-  const runningCount = items.filter(i => i.status === 'running' || i.status === 'active').length;
+  const runningCount = items.filter((i) => i.status === 'running' || i.status === 'active').length;
 
   return {
     items,

package/src/unit.js

@@ -1,21 +1,21 @@
 import fs from 'node:fs';
-import path from 'node:path';
 import os from 'node:os';
+import path from 'node:path';
 import {
-  sanitizeServiceName,
-  getUnitFilename,
-  getTimerFilename,
-  getServiceNameFromUnit,
-  formatSystemdEnv,
+  deleteAppMetadata,
+  deleteScheduleMetadata,
   escapeExecArg,
+  formatSystemdEnv,
+  getServiceNameFromUnit,
+  getTimerFilename,
+  getUnitFilename,
   resolveAbsolutePath,
+  resolveEffectiveMemoryLimits,
   resolveWorkingDirectory,
+  sanitizeServiceName,
   saveAppMetadata,
-  deleteAppMetadata,
   saveScheduleMetadata,
-  deleteScheduleMetadata,
-  validateDuration,
-  resolveEffectiveMemoryLimits
+  validateDuration
 } from './utils.js';
 
 /**
@@ -241,7 +241,7 @@ export function parseUnitContent(content) {
     } else if (trimmed.startsWith('ExecStart=')) {
       const execVal = trimmed.slice(10).trim();
       const parts = execVal.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
-      const cleanParts = parts.map(p => p.replace(/^"|"$/g, ''));
+      const cleanParts = parts.map((p) => p.replace(/^"|"$/g, '').replace(/\\"/g, '"').replace(/\\\\/g, '\\'));
       if (cleanParts.length > 0) {
         result.command = cleanParts[0];
         result.args = cleanParts.slice(1);
@@ -368,12 +368,7 @@ export function generateScheduleServiceContent(opts) {
 export function generateTimerContent(opts) {
   const safeName = sanitizeServiceName(opts.name);
 
-  const timerLines = [
-    '[Unit]',
-    `Description=unitup timer: ${safeName}`,
-    '',
-    '[Timer]'
-  ];
+  const timerLines = ['[Unit]', `Description=unitup timer: ${safeName}`, '', '[Timer]'];
 
   if (opts.every) {
     const validEvery = validateDuration(opts.every, '--every');
@@ -482,4 +477,3 @@ export function deleteScheduleUnitFiles(name) {
   }
   return removed;
 }
-

package/src/utils.js

@@ -1,6 +1,6 @@
-import path from 'node:path';
-import os from 'node:os';
 import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 
 /**
  * Returns the base unitup config directory (~/.config/unitup).
@@ -75,7 +75,14 @@ export function validateMemorySize(val, paramName = 'Memory limit') {
  * @returns {string} Formatted memory string e.g. "284 MB", "infinity", "unavailable"
  */
 export function formatMemoryBytes(bytes) {
-  if (bytes === null || bytes === undefined || bytes === '' || bytes === 'unavailable' || bytes === '[unavailable]' || bytes === '-') {
+  if (
+    bytes === null ||
+    bytes === undefined ||
+    bytes === '' ||
+    bytes === 'unavailable' ||
+    bytes === '[unavailable]' ||
+    bytes === '-'
+  ) {
     return 'unavailable';
   }
 
@@ -137,10 +144,16 @@ export function saveAppMetadata(meta) {
   }
   const filePath = getAppMetadataPath(safeName);
 
-  const command = meta.command ? resolveAbsolutePath(meta.command) : (meta.node ? resolveAbsolutePath(meta.node) : process.execPath);
-  const rawArgs = Array.isArray(meta.args) ? meta.args : (meta.script ? [meta.script] : []);
-  const args = rawArgs.map(a => (a.startsWith('/') || a.startsWith('./') || a.startsWith('../') || a.startsWith('~/')) ? resolveAbsolutePath(a) : a);
-  const scriptPath = meta.script ? resolveAbsolutePath(meta.script) : (args[0] ? resolveAbsolutePath(args[0]) : command);
+  const command = meta.command
+    ? resolveAbsolutePath(meta.command)
+    : meta.node
+      ? resolveAbsolutePath(meta.node)
+      : process.execPath;
+  const rawArgs = Array.isArray(meta.args) ? meta.args : meta.script ? [meta.script] : [];
+  const args = rawArgs.map((a) =>
+    a.startsWith('/') || a.startsWith('./') || a.startsWith('../') || a.startsWith('~/') ? resolveAbsolutePath(a) : a
+  );
+  const scriptPath = meta.script ? resolveAbsolutePath(meta.script) : args[0] ? resolveAbsolutePath(args[0]) : command;
   const cwd = resolveWorkingDirectory(meta);
 
   // Extract memory resources if present
@@ -414,7 +427,7 @@ export function formatTable(data, columns) {
     return 'No services found.';
   }
 
-  const widths = columns.map(col => col.label.length);
+  const widths = columns.map((col) => col.label.length);
 
   for (const row of data) {
     columns.forEach((col, idx) => {
@@ -429,9 +442,7 @@ export function formatTable(data, columns) {
   const lines = [headerLine];
 
   for (const row of data) {
-    const line = columns
-      .map((col, idx) => String(row[col.key] ?? '').padEnd(widths[idx]))
-      .join('   ');
+    const line = columns.map((col, idx) => String(row[col.key] ?? '').padEnd(widths[idx])).join('   ');
     lines.push(line);
   }
 
@@ -471,7 +482,9 @@ export function saveScheduleMetadata(meta) {
 
   const command = meta.command ? resolveAbsolutePath(meta.command) : process.execPath;
   const rawArgs = Array.isArray(meta.args) ? meta.args : [];
-  const args = rawArgs.map(a => (a.startsWith('/') || a.startsWith('./') || a.startsWith('../') || a.startsWith('~/')) ? resolveAbsolutePath(a) : a);
+  const args = rawArgs.map((a) =>
+    a.startsWith('/') || a.startsWith('./') || a.startsWith('../') || a.startsWith('~/') ? resolveAbsolutePath(a) : a
+  );
 
   const resources = meta.resources || {};
   if (meta.memoryHigh) resources.memoryHigh = validateMemorySize(meta.memoryHigh, 'MemoryHigh');
@@ -578,7 +591,8 @@ export function validateDuration(val, paramName = 'Duration') {
   }
 
   const tokens = str.split(/\s+/);
-  const tokenRegex = /^(\d+(?:\.\d+)?)(us|usec|ms|msec|s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|day|days?|w|week|weeks?|mth|months?|y|year|years?)$/i;
+  const tokenRegex =
+    /^(\d+(?:\.\d+)?)(us|usec|ms|msec|s|sec|seconds?|m|min|minutes?|h|hr|hours?|d|day|days?|w|week|weeks?|mth|months?|y|year|years?)$/i;
 
   for (const token of tokens) {
     if (!tokenRegex.test(token)) {
@@ -598,7 +612,9 @@ export function formatFutureTime(dateVal) {
   if (!dateVal || dateVal === 'n/a' || dateVal === '0' || dateVal === 'infinity') {
     return 'n/a';
   }
-  const date = new Date(typeof dateVal === 'number' && dateVal > 1e12 ? dateVal : (typeof dateVal === 'number' ? dateVal / 1000 : dateVal));
+  const date = new Date(
+    typeof dateVal === 'number' && dateVal > 1e12 ? dateVal : typeof dateVal === 'number' ? dateVal / 1000 : dateVal
+  );
   if (isNaN(date.getTime())) {
     return String(dateVal);
   }
@@ -691,7 +707,8 @@ export function resolveEffectiveMemoryLimits(opts = {}) {
   }
 
   if (defaultMem) {
-    const sizeStr = (typeof defaultMem === 'boolean' || defaultMem === 'true' || defaultMem === '') ? '1G' : String(defaultMem);
+    const sizeStr =
+      typeof defaultMem === 'boolean' || defaultMem === 'true' || defaultMem === '' ? '1G' : String(defaultMem);
     const validSize = validateMemorySize(sizeStr, 'Default memory limit');
     return { memoryMax: validSize };
   }
@@ -757,6 +774,3 @@ export function saveProjectConfig(dirPathOrFile = process.cwd(), config = {}) {
   fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf8');
   return filePath;
 }
-
-
-

package/tsconfig.json

@@ -9,5 +9,5 @@
     "allowJs": true,
     "checkJs": false
   },
-  "include": ["index.d.ts"]
+  "include": ["index.d.ts", "types-test/index.ts"]
 }