unitup 0.0.12 → 0.1.1

package/src/cli.js

@@ -19,9 +19,20 @@ import {
   inspectService,
   getServiceFailures,
   setServiceLimits,
-  executeJournalctlMaintenance
+  executeJournalctlMaintenance,
+  getServiceMemoryUsage,
+  getAllServicesMemoryUsage
 } from './systemd.js';
-import { sanitizeServiceName, formatTable } from './utils.js';
+import {
+  createSchedule,
+  listSchedules,
+  getScheduleStatus,
+  runSchedule,
+  enableSchedule,
+  disableSchedule,
+  removeSchedule
+} from './schedule.js';
+import { sanitizeServiceName, formatTable, readGlobalConfig, saveGlobalConfig, validateMemorySize } from './utils.js';
 
 /**
  * Custom light CLI argument parser without runtime dependencies.
@@ -58,6 +69,8 @@ export function parseArgs(argv) {
       memoryMax: '',
       memorySwapMax: '',
       resetMemory: false,
+      defaultMemory: '',
+      resetDefaultMemory: false,
       since: '',
       until: '',
       priority: '',
@@ -69,7 +82,13 @@ export function parseArgs(argv) {
       time: '',
       files: '',
       yes: false,
-      dryRun: false
+      dryRun: false,
+      every: '',
+      calendar: '',
+      onBoot: '',
+      onActive: '',
+      randomDelay: '',
+      persistent: false
     }
   };
 
@@ -198,6 +217,21 @@ export function parseArgs(argv) {
     } else if (arg === '--reset-memory') {
       result.flags.resetMemory = true;
       i++;
+    } else if (arg === '--default-memory') {
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        result.flags.defaultMemory = next;
+        i += 2;
+      } else {
+        result.flags.defaultMemory = '1G';
+        i++;
+      }
+    } else if (arg.startsWith('--default-memory=')) {
+      result.flags.defaultMemory = arg.slice(17) || '1G';
+      i++;
+    } else if (arg === '--reset-default-memory') {
+      result.flags.resetDefaultMemory = true;
+      i++;
     } else if (arg === '--since') {
       result.flags.since = argv[i + 1] || '';
       i += 2;
@@ -255,6 +289,39 @@ export function parseArgs(argv) {
     } else if (arg === '--dry-run') {
       result.flags.dryRun = true;
       i++;
+    } else if (arg === '--every') {
+      result.flags.every = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--every=')) {
+      result.flags.every = arg.slice(8);
+      i++;
+    } else if (arg === '--calendar') {
+      result.flags.calendar = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--calendar=')) {
+      result.flags.calendar = arg.slice(11);
+      i++;
+    } else if (arg === '--on-boot') {
+      result.flags.onBoot = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--on-boot=')) {
+      result.flags.onBoot = arg.slice(10);
+      i++;
+    } else if (arg === '--on-active') {
+      result.flags.onActive = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--on-active=')) {
+      result.flags.onActive = arg.slice(12);
+      i++;
+    } else if (arg === '--random-delay') {
+      result.flags.randomDelay = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--random-delay=')) {
+      result.flags.randomDelay = arg.slice(15);
+      i++;
+    } else if (arg === '--persistent') {
+      result.flags.persistent = true;
+      i++;
     } else if (!arg.startsWith('-')) {
       if (!result.command) {
         result.command = arg;
@@ -287,25 +354,39 @@ Usage:
   unitup failures               List all failed services with exit code & restarts
   unitup remove <name|@group>   Stop, disable and delete a service
   unitup list / unitup ls       List all services (--group <group>)
-
-Add Options:
-  --name <name>          Service name (default: script/executable name)
-  --runtime <name>       Runtime (node, python, ruby, php, bun, deno, shell, go, elixir, native)
-  --runtime-arg <val>    Runtime argument (can be specified multiple times)
-  --command <path>       Custom executable command path (bypasses auto-detection)
-  --arg <value>          Argument to pass to command (can be specified multiple times)
-  --group <group>        Assign service to a group (default: default)
-  --cwd <path>           Working directory
-  --restart <policy>     Restart policy (on-failure, always, etc. Default: on-failure)
-  --env KEY=value        Environment variable (can be specified multiple times)
-  --env-file <file>      Path to environment file
-  --start                Enable and start service immediately after creation
+  unitup memory / unitup top    Show memory usage for all apps or a specific app
+  unitup config                 Manage global configuration (--default-memory 1G)
+
+Schedule Commands:
+  unitup schedule <script> [options] Create a systemd timer schedule
+  unitup schedules / unitup timers    List all schedule timers
+  unitup schedule-status <name>       Show detailed schedule timer status
+  unitup schedule-run <name>          Manually run schedule service unit once
+  unitup schedule-enable <name>       Enable and start schedule timer
+  unitup schedule-disable <name>      Disable and stop schedule timer
+  unitup schedule-remove <name>       Remove schedule timer and service
+  unitup schedule-logs <name>         View logs for a scheduled task
+
+Memory Options:
+  --memory-high <size>   Soft memory limit (e.g. 400M, 1G)
+  --memory-max <size>    Hard memory limit (e.g. 512M, 1G)
+  --default-memory [sz]  Apply default memory limit (defaults to 1G)
+
+Schedule Options:
+  --every <duration>     Execution interval (e.g., 30s, 10m, 2h, 1d)
+  --calendar <expr>      Calendar expression (e.g., daily, "Mon..Fri 09:00")
+  --on-boot <duration>   Delay relative to system boot (e.g., 5m)
+  --on-active <duration> Delay relative to timer activation
+  --random-delay <dur>   Random delay to prevent stampedes (e.g., 10m)
+  --persistent           Run immediately if a scheduled run was missed
+  --start                Enable and start timer immediately after creation
 
 Examples:
-  unitup add server.js --runtime node
-  unitup add worker.py --runtime python
-  unitup add ./server --runtime native
-  unitup add --name worker --command /usr/bin/python3 --arg worker.py --arg --port --arg 3000
+  unitup add server.js --runtime node --default-memory 1G
+  unitup config --default-memory 1G
+  unitup schedule cleanup.js --every 30m --default-memory --start
+  unitup schedule backup.py --calendar daily --random-delay 10m --start
+  unitup schedule report.js --calendar "Mon..Fri 09:00" --start
 `);
 }
 
@@ -417,6 +498,7 @@ export async function runCli(argv = process.argv.slice(2)) {
           memoryHigh: flags.memoryHigh,
           memoryMax: flags.memoryMax,
           memorySwapMax: flags.memorySwapMax,
+          defaultMemory: flags.defaultMemory,
           force: flags.force
         });
 
@@ -656,6 +738,222 @@ export async function runCli(argv = process.argv.slice(2)) {
         break;
       }
 
+      case 'schedule': {
+        const scriptArg = positionals[0];
+        const envObj = {};
+        for (const e of flags.env) {
+          const idx = e.indexOf('=');
+          if (idx !== -1) {
+            envObj[e.slice(0, idx)] = e.slice(idx + 1);
+          } else {
+            envObj[e] = '';
+          }
+        }
+
+        const res = await createSchedule({
+          name: flags.name,
+          script: scriptArg,
+          command: flags.command,
+          runtime: flags.runtime,
+          runtimeArgs: flags.runtimeArgs,
+          args: flags.args,
+          cwd: flags.cwd,
+          env: envObj,
+          envFile: flags.envFile,
+          group: flags.group,
+          memoryHigh: flags.memoryHigh,
+          memoryMax: flags.memoryMax,
+          memorySwapMax: flags.memorySwapMax,
+          defaultMemory: flags.defaultMemory,
+          every: flags.every,
+          calendar: flags.calendar,
+          onBoot: flags.onBoot,
+          onActive: flags.onActive,
+          randomDelay: flags.randomDelay,
+          persistent: flags.persistent,
+          start: flags.start || flags.enable,
+          enable: flags.enable
+        });
+
+        console.log(`✓ Schedule "${res.name}" created.`);
+        console.log(`Service unit: ${res.servicePath}`);
+        console.log(`Timer unit: ${res.timerPath}`);
+        if (flags.start || flags.enable) {
+          console.log(`✓ Timer "${res.name}" enabled and started.`);
+        } else {
+          console.log(`Run "unitup schedule-enable ${res.name}" to enable and start the timer.`);
+        }
+        break;
+      }
+
+      case 'timers':
+      case 'schedules': {
+        const schedules = await listSchedules(flags.group);
+        if (schedules.length === 0) {
+          if (flags.group) {
+            console.log(`No schedules found in group "${flags.group}".`);
+          } else {
+            console.log('No unitup schedule timers found.');
+          }
+          break;
+        }
+
+        const table = formatTable(schedules, [
+          { key: 'name', label: 'NAME' },
+          { key: 'group', label: 'GROUP' },
+          { key: 'schedule', label: 'SCHEDULE' },
+          { key: 'nextRun', label: 'NEXT RUN' },
+          { key: 'lastRun', label: 'LAST RUN' },
+          { key: 'status', label: 'STATUS' }
+        ]);
+        console.log(table);
+        break;
+      }
+
+      case 'timer-status':
+      case 'schedule-status': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Schedule name is required.\nExample: unitup schedule-status cleanup');
+        }
+        const status = await getScheduleStatus(nameArg);
+        console.log(`Name: ${status.name}`);
+        console.log(`Group: ${status.group}`);
+        console.log(`Schedule: ${status.schedule}`);
+        console.log(`Next Run: ${status.nextRun}`);
+        console.log(`Last Run: ${status.lastRun}`);
+        console.log(`Status: ${status.status}`);
+        console.log(`Timer Unit: ${status.timerUnit}`);
+        console.log(`Service Unit: ${status.serviceUnit}`);
+        break;
+      }
+
+      case 'schedule-run': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Schedule name is required.\nExample: unitup schedule-run cleanup');
+        }
+        await runSchedule(nameArg);
+        console.log(`✓ Service unit for schedule "${sanitizeServiceName(nameArg)}" triggered.`);
+        break;
+      }
+
+      case 'schedule-enable': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Schedule name is required.\nExample: unitup schedule-enable cleanup');
+        }
+        await enableSchedule(nameArg);
+        console.log(`✓ Schedule timer "${sanitizeServiceName(nameArg)}" enabled and started.`);
+        break;
+      }
+
+      case 'schedule-disable': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Schedule name is required.\nExample: unitup schedule-disable cleanup');
+        }
+        await disableSchedule(nameArg);
+        console.log(`✓ Schedule timer "${sanitizeServiceName(nameArg)}" disabled.`);
+        break;
+      }
+
+      case 'schedule-remove': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Schedule name is required.\nExample: unitup schedule-remove cleanup');
+        }
+        await removeSchedule(nameArg, { force: flags.force });
+        console.log(`✓ Schedule "${sanitizeServiceName(nameArg)}" removed.`);
+        break;
+      }
+
+      case 'schedule-logs': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Schedule name is required.\nExample: unitup schedule-logs cleanup');
+        }
+        const output = await runJournalctlLogs(nameArg, {
+          follow: flags.follow,
+          lines: flags.lines,
+          cat: flags.cat,
+          output: flags.output,
+          since: flags.since,
+          until: flags.until,
+          priority: flags.priority,
+          grep: flags.grep,
+          boot: flags.boot,
+          json: flags.json,
+          diskUsage: flags.diskUsage
+        });
+        if (typeof output === 'string') {
+          console.log(output);
+        }
+        break;
+      }
+
+      case 'config': {
+        if (flags.resetDefaultMemory) {
+          saveGlobalConfig({ defaultMemory: null });
+          console.log('✓ Default memory limit reset.');
+        } else if (flags.defaultMemory) {
+          const validSize = validateMemorySize(flags.defaultMemory, 'Default memory limit');
+          saveGlobalConfig({ defaultMemory: validSize });
+          console.log(`✓ Default memory limit set to ${validSize}.`);
+        } else {
+          const cfg = readGlobalConfig();
+          console.log(`Default Memory: ${cfg.defaultMemory || 'not set (1G on demand)'}`);
+        }
+        break;
+      }
+
+      case 'top':
+      case 'mem':
+      case 'memory': {
+        const nameArg = positionals[0];
+        if (nameArg) {
+          const targetNames = await resolveTargetNames(nameArg);
+          for (const name of targetNames) {
+            const mem = await getServiceMemoryUsage(name);
+            console.log(`=== Memory Overview: ${mem.name} ===`);
+            console.log(`Group: ${mem.group}`);
+            console.log(`Type: ${mem.type}`);
+            console.log(`Status: ${mem.status}`);
+            console.log(`PID: ${mem.pid}`);
+            console.log(`Current Memory: ${mem.memory}`);
+            console.log(`Peak Memory: ${mem.memoryPeak}`);
+            console.log(`Soft Limit (High): ${mem.memoryHigh}`);
+            console.log(`Hard Limit (Max): ${mem.memoryMax}`);
+            console.log(`Swap Limit: ${mem.memorySwapMax}`);
+            if (targetNames.length > 1) console.log('');
+          }
+        } else {
+          const overview = await getAllServicesMemoryUsage({ group: flags.group });
+          if (overview.items.length === 0) {
+            if (flags.group) {
+              console.log(`No services or schedules found in group "${flags.group}".`);
+            } else {
+              console.log('No unitup user services or schedules found.');
+            }
+            break;
+          }
+
+          const table = formatTable(overview.items, [
+            { key: 'name', label: 'NAME' },
+            { key: 'group', label: 'GROUP' },
+            { key: 'type', label: 'TYPE' },
+            { key: 'status', label: 'STATUS' },
+            { key: 'pid', label: 'PID' },
+            { key: 'memory', label: 'MEMORY' },
+            { key: 'memoryPeak', label: 'PEAK' },
+            { key: 'memoryMax', label: 'LIMIT (MAX)' }
+          ]);
+          console.log(table);
+          console.log(`\nTotal Memory Usage across ${overview.runningCount} active app(s): ${overview.totalMemory}`);
+        }
+        break;
+      }
+
       default: {
         console.error(`Unknown command: "${command}"\n`);
         printHelp();

package/src/index.js

@@ -20,25 +20,50 @@ import {
   checkUserLinger,
   checkNodeDiagnostics,
   findNodeExecutable,
+  getServiceMemoryUsage,
+  getAllServicesMemoryUsage,
   setCommandRunner,
   resetCommandRunner
 } from './systemd.js';
 import { getDoctorInfo } from './doctor.js';
+import {
+  createSchedule,
+  listSchedules,
+  getScheduleStatus,
+  runSchedule,
+  enableSchedule,
+  disableSchedule,
+  removeSchedule,
+  validateCalendar
+} from './schedule.js';
 import {
   getUserUnitDir,
   getUnitPath,
+  getTimerPath,
   unitFileExists,
-  parseUnitContent
+  timerFileExists,
+  parseUnitContent,
+  generateTimerContent,
+  generateScheduleServiceContent
 } from './unit.js';
 import {
   sanitizeServiceName,
   getUnitFilename,
+  getTimerFilename,
   getServiceNameFromUnit,
   readAppMetadata,
   getAppMetadataPath,
+  readScheduleMetadata,
+  getScheduleMetadataPath,
+  readGlobalConfig,
+  saveGlobalConfig,
+  getConfigFilepath,
+  resolveEffectiveMemoryLimits,
+  getSchedulesDir,
   getAppsDir,
   getUnitupDir,
   validateMemorySize,
+  validateDuration,
   formatMemoryBytes
 } from './utils.js';
 import { detectRuntime, resolveRuntimeConfig } from './runtimes/index.js';
@@ -58,20 +83,40 @@ export {
   getServiceFailures,
   getServicesByGroup,
   setServiceLimits,
+  getServiceMemoryUsage,
+  getAllServicesMemoryUsage,
   executeJournalctlMaintenance as executeJournalctlMaintenance,
   runJournalctlLogs as getServiceLogs,
 
-  // Memory & Validation helpers
+  // Programmatic schedule management API
+  createSchedule,
+  listSchedules,
+  getScheduleStatus,
+  runSchedule,
+  enableSchedule,
+  disableSchedule,
+  removeSchedule,
+  validateCalendar,
+
+  // Duration & Validation helpers
   validateMemorySize,
+  validateDuration,
   formatMemoryBytes,
 
   // Runtime detection & resolution
   detectRuntime,
   resolveRuntimeConfig,
 
-  // Metadata helpers
+  // Metadata & Config helpers
   readAppMetadata,
   getAppMetadataPath,
+  readScheduleMetadata,
+  getScheduleMetadataPath,
+  readGlobalConfig,
+  saveGlobalConfig,
+  getConfigFilepath,
+  resolveEffectiveMemoryLimits,
+  getSchedulesDir,
   getAppsDir,
   getUnitupDir,
 
@@ -89,10 +134,15 @@ export {
   // Unit file & path helpers
   getUserUnitDir,
   getUnitPath,
+  getTimerPath,
   unitFileExists,
+  timerFileExists,
   parseUnitContent,
+  generateTimerContent,
+  generateScheduleServiceContent,
   sanitizeServiceName,
   getUnitFilename,
+  getTimerFilename,
   getServiceNameFromUnit,
 
   // Runner override for testing