unitup 0.1.5 → 0.3.0

package/src/cli.js

@@ -1,47 +1,59 @@
-import path from 'node:path';
 import fs from 'node:fs';
+import path from 'node:path';
 import readline from 'node:readline';
 import { runDoctor } from './doctor.js';
+import { getAdapter } from './platform/index.js';
+import {
+  createSchedule,
+  disableSchedule,
+  enableSchedule,
+  getScheduleStatus,
+  listSchedules,
+  removeSchedule,
+  runSchedule
+} from './schedule.js';
+import { defaultManager } from './service/manager.js';
 import {
   addService,
-  startService,
-  stopService,
-  restartService,
-  removeService,
+  executeJournalctlMaintenance,
+  findNodeExecutable,
+  getAllServicesMemoryUsage,
+  getServiceFailures,
+  getServiceMemoryUsage,
   getServiceStatus,
   getServiceStatusRaw,
-  listServices,
-  runJournalctlLogs,
-  isLinux,
-  isSystemctlAvailable,
-  findNodeExecutable,
   getServicesByGroup,
   inspectService,
-  getServiceFailures,
+  isLinux,
+  isSystemctlAvailable,
+  listServices,
+  removeService,
+  restartService,
+  runJournalctlLogs,
   setServiceLimits,
-  executeJournalctlMaintenance,
-  getServiceMemoryUsage,
-  getAllServicesMemoryUsage
+  startService,
+  stopService
 } from './systemd.js';
 import {
-  createSchedule,
-  listSchedules,
-  getScheduleStatus,
-  runSchedule,
-  enableSchedule,
-  disableSchedule,
-  removeSchedule
-} from './schedule.js';
-import {
-  sanitizeServiceName,
+  findProjectConfig,
+  formatDuration,
+  formatRelativeTime,
   formatTable,
+  parseDurationMs,
   readGlobalConfig,
-  saveGlobalConfig,
-  validateMemorySize,
-  findProjectConfig,
   readProjectConfig,
-  saveProjectConfig
+  sanitizeServiceName,
+  saveGlobalConfig,
+  saveProjectConfig,
+  validateMemorySize
 } from './utils.js';
+import { GenerationManager } from './core/generation-manager.js';
+import { IPCClient } from './core/ipc.js';
+import { Supervisor } from './core/supervisor.js';
+import {
+  defaultDeploymentManager as deploymentManager,
+  defaultRollbackManager as rollbackManager
+} from './deploy/index.js';
 
 /**
  * Custom light CLI argument parser without runtime dependencies.
@@ -75,6 +87,8 @@ export function parseArgs(argv) {
       help: false,
       version: false,
       force: false,
+      system: false,
+      verbose: false,
       memoryHigh: '',
       memoryMax: '',
       memorySwapMax: '',
@@ -98,7 +112,13 @@ export function parseArgs(argv) {
       onBoot: '',
       onActive: '',
       randomDelay: '',
-      persistent: false
+      persistent: false,
+      port: '',
+      zeroDowntime: false,
+      ready: '',
+      drain: '',
+      canary: false,
+      weight: ''
     }
   };
 
@@ -112,6 +132,12 @@ export function parseArgs(argv) {
     } else if (arg === '-v' || arg === '--version') {
       result.flags.version = true;
       i++;
+    } else if (arg === '--verbose') {
+      result.flags.verbose = true;
+      i++;
+    } else if (arg === '--system') {
+      result.flags.system = true;
+      i++;
     } else if (arg === '--runtime') {
       result.flags.runtime = argv[i + 1] || '';
       i += 2;
@@ -191,10 +217,10 @@ export function parseArgs(argv) {
       result.flags.args.push(arg.slice(7));
       i++;
     } else if (arg === '--lines' || arg === '-n') {
-      result.flags.lines = parseInt(argv[i + 1] || '100', 10);
+      result.flags.lines = Number.parseInt(argv[i + 1] || '100', 10);
       i += 2;
     } else if (arg.startsWith('--lines=')) {
-      result.flags.lines = parseInt(arg.slice(8), 10);
+      result.flags.lines = Number.parseInt(arg.slice(8), 10);
       i++;
     } else if (arg === '--start') {
       result.flags.start = true;
@@ -344,6 +370,36 @@ export function parseArgs(argv) {
     } else if (arg === '--persistent') {
       result.flags.persistent = true;
       i++;
+    } else if (arg === '--port') {
+      result.flags.port = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--port=')) {
+      result.flags.port = arg.slice(7);
+      i++;
+    } else if (arg === '--zero-downtime') {
+      result.flags.zeroDowntime = true;
+      i++;
+    } else if (arg === '--ready') {
+      result.flags.ready = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--ready=')) {
+      result.flags.ready = arg.slice(8);
+      i++;
+    } else if (arg === '--drain') {
+      result.flags.drain = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--drain=')) {
+      result.flags.drain = arg.slice(8);
+      i++;
+    } else if (arg === '--canary') {
+      result.flags.canary = true;
+      i++;
+    } else if (arg === '--weight') {
+      result.flags.weight = argv[i + 1] || '';
+      i += 2;
+    } else if (arg.startsWith('--weight=')) {
+      result.flags.weight = arg.slice(9);
+      i++;
     } else if (!arg.startsWith('-')) {
       if (!result.command) {
         result.command = arg;
@@ -352,7 +408,6 @@ export function parseArgs(argv) {
       }
       i++;
     } else {
-      // Unknown flag, treat as positional or ignore
       i++;
     }
   }
@@ -362,29 +417,37 @@ export function parseArgs(argv) {
 
 export function printHelp() {
   console.log(`
-unitup - Minimal systemd user service wrapper for any executable & runtime
+unitup - Minimal systemd user service wrapper & cross-platform service manager (Linux, macOS, Windows)
 
 Usage:
   unitup doctor                 Run system readiness and runtime check
   unitup init [script]          Create local project config file (unitup.config.json)
-  unitup add <script> [options] Add script or executable as systemd user service
+  unitup install / add <script> Install script or executable as native service (--dry-run)
   unitup start <name|@group>    Start a service (--enable to enable on boot)
   unitup stop <name|@group>     Stop a service
   unitup restart <name|@group>  Restart a service
-  unitup status <name|@group>   Show status summary (--raw for full status)
-  unitup logs <name|@group>     Show journalctl logs (-f/--follow, -n/--lines N, -c/--cat)
+  unitup deploy <name>          Perform zero-downtime deployment (--canary, --weight 10%)
+  unitup rollback <name>        Roll back a service to its previous generation or abort canary
+  unitup promote <name>         Promote a canary generation to 100% active
+  unitup generations <name>     List all runtime generations and ports for a service
+  unitup status <name|@group>   Show status summary (--raw, --verbose)
+  unitup enable <name>          Enable service on startup/boot
+  unitup disable <name>         Disable service on startup/boot
+  unitup logs <name|@group>     Show service logs (-f/--follow, -n/--lines N, -c/--cat)
   unitup inspect <name>         View detailed app configuration and status
   unitup failures               List all failed services with exit code & restarts
-  unitup remove <name|@group>   Stop, disable and delete a service
+  unitup uninstall / remove     Stop, disable and delete a service (--force)
   unitup list / unitup ls       List all services (--group <group>)
   unitup memory / unitup top    Show memory usage for all apps or a specific app
   unitup config                 Manage global configuration (--default-memory 1G)
 
 Config Options:
   --config <path>        Path to custom project config file (defaults to unitup.config.json)
+  --system               Install as system-wide service (LaunchDaemons on macOS / root systemd)
+  --dry-run              Display generated service configuration without installing
 
-Schedule Commands:
-  unitup schedule <script> [options] Create a systemd timer schedule
+Schedule Commands (systemd):
+  unitup schedule <script> [options] Create a 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
@@ -398,21 +461,13 @@ Memory Options:
   --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 --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
+  unitup install server.js --name api --start
+  unitup install ./app.js --dry-run
+  unitup start api
+  unitup status api --verbose
+  unitup logs api --follow
+  unitup uninstall api
 `);
 }
 
@@ -468,12 +523,12 @@ export async function runCli(argv = process.argv.slice(2)) {
         if (fs.existsSync(targetConfigPath) && !flags.force) {
           throw new Error(
             `Configuration file "${path.basename(targetConfigPath)}" already exists at ${targetConfigPath}.\n` +
-            `Use --force (-f) to overwrite.`
+              `Use --force (-f) to overwrite.`
           );
         }
 
         const scriptArg = positionals[0];
-        let scriptPath = scriptArg || '';
+        const scriptPath = scriptArg || '';
         let name = flags.name;
         if (!name) {
           if (scriptPath) {
@@ -521,6 +576,7 @@ export async function runCli(argv = process.argv.slice(2)) {
         break;
       }
 
+      case 'install':
       case 'add': {
         const targetCwd = flags.cwd ? path.resolve(process.cwd(), flags.cwd) : process.cwd();
         const configPath = flags.config ? path.resolve(targetCwd, flags.config) : findProjectConfig(targetCwd);
@@ -528,18 +584,23 @@ export async function runCli(argv = process.argv.slice(2)) {
 
         const scriptArg = positionals[0] || (projectCfg ? projectCfg.script : undefined);
         let name = flags.name || (projectCfg ? projectCfg.name : undefined);
-        let cmdFlag = flags.command || (projectCfg ? projectCfg.command : undefined);
-        let runtimeFlag = flags.runtime || (projectCfg ? projectCfg.runtime : undefined);
-        let groupFlag = flags.group || (projectCfg ? projectCfg.group : undefined) || 'default';
-        let restartFlag = flags.restart !== 'on-failure' ? flags.restart : ((projectCfg && projectCfg.restart) || 'on-failure');
-        let envFileFlag = flags.envFile || (projectCfg ? projectCfg.envFile : undefined);
-        let argsFlag = (flags.args && flags.args.length > 0) ? flags.args : ((projectCfg && projectCfg.args) || []);
-        let runtimeArgsFlag = (flags.runtimeArgs && flags.runtimeArgs.length > 0) ? flags.runtimeArgs : ((projectCfg && projectCfg.runtimeArgs) || []);
-        let memoryHighFlag = flags.memoryHigh || (projectCfg?.resources?.memoryHigh || projectCfg?.memoryHigh || '');
-        let memoryMaxFlag = flags.memoryMax || (projectCfg?.resources?.memoryMax || projectCfg?.memoryMax || '');
-        let memorySwapMaxFlag = flags.memorySwapMax || (projectCfg?.resources?.memorySwapMax || projectCfg?.memorySwapMax || '');
-
-        let absScriptPath = scriptArg ? path.resolve(targetCwd, scriptArg) : undefined;
+        const cmdFlag = flags.command || (projectCfg ? projectCfg.command : undefined);
+        const runtimeFlag = flags.runtime || (projectCfg ? projectCfg.runtime : undefined);
+        const groupFlag = flags.group || (projectCfg ? projectCfg.group : undefined) || 'default';
+        const restartFlag =
+          flags.restart !== 'on-failure' ? flags.restart : (projectCfg && projectCfg.restart) || 'on-failure';
+        const envFileFlag = flags.envFile || (projectCfg ? projectCfg.envFile : undefined);
+        const argsFlag = flags.args && flags.args.length > 0 ? flags.args : (projectCfg && projectCfg.args) || [];
+        const runtimeArgsFlag =
+          flags.runtimeArgs && flags.runtimeArgs.length > 0
+            ? flags.runtimeArgs
+            : (projectCfg && projectCfg.runtimeArgs) || [];
+        const memoryHighFlag = flags.memoryHigh || projectCfg?.resources?.memoryHigh || projectCfg?.memoryHigh || '';
+        const memoryMaxFlag = flags.memoryMax || projectCfg?.resources?.memoryMax || projectCfg?.memoryMax || '';
+        const memorySwapMaxFlag =
+          flags.memorySwapMax || projectCfg?.resources?.memorySwapMax || projectCfg?.memorySwapMax || '';
+
+        const absScriptPath = scriptArg ? path.resolve(targetCwd, scriptArg) : undefined;
 
         if (flags.node) {
           const resolvedNode = await findNodeExecutable(flags.node);
@@ -573,7 +634,7 @@ export async function runCli(argv = process.argv.slice(2)) {
           }
         }
 
-        const envObj = (projectCfg && projectCfg.env && typeof projectCfg.env === 'object') ? { ...projectCfg.env } : {};
+        const envObj = projectCfg && projectCfg.env && typeof projectCfg.env === 'object' ? { ...projectCfg.env } : {};
         for (const e of flags.env) {
           const idx = e.indexOf('=');
           if (idx !== -1) {
@@ -583,7 +644,7 @@ export async function runCli(argv = process.argv.slice(2)) {
           }
         }
 
-        const res = await addService({
+        const installOptions = {
           name,
           group: groupFlag,
           script: absScriptPath,
@@ -597,14 +658,34 @@ export async function runCli(argv = process.argv.slice(2)) {
           restart: restartFlag,
           args: argsFlag,
           start: flags.start,
+          system: flags.system,
           memoryHigh: memoryHighFlag,
           memoryMax: memoryMaxFlag,
           memorySwapMax: memorySwapMaxFlag,
           defaultMemory: flags.defaultMemory,
-          force: flags.force
-        });
+          force: flags.force,
+          port: flags.port ? Number(flags.port) : projectCfg?.port,
+          deploy: {
+            ...(projectCfg?.deploy || {}),
+            ...(flags.zeroDowntime ? { zeroDowntime: true } : {}),
+            ...(flags.ready ? { ready: flags.ready } : {}),
+            ...(flags.drain ? { drain: flags.drain } : {})
+          }
+        };
 
-        console.log(`✓ Service "${res.name}" created at ${res.unitPath}`);
+        if (flags.dryRun) {
+          const generated = await defaultManager.generate(installOptions);
+          if (typeof generated === 'string') {
+            console.log(generated);
+          } else {
+            console.log(JSON.stringify(generated, null, 2));
+          }
+          break;
+        }
+
+        const res = await defaultManager.install(installOptions);
+
+        console.log(`✓ Service "${res.name}" created at ${res.unitPath || res.serviceName || res.name}`);
         if (flags.start) {
           console.log(`✓ Service "${res.name}" enabled and started.`);
         } else {
@@ -638,7 +719,7 @@ export async function runCli(argv = process.argv.slice(2)) {
         }
         const targetNames = await resolveTargetNames(nameArg);
         for (const name of targetNames) {
-          await startService(name, flags.enable);
+          await defaultManager.start(name, { enable: flags.enable, system: flags.system });
           console.log(`✓ Service "${sanitizeServiceName(name)}" ${flags.enable ? 'enabled & ' : ''}started.`);
         }
         break;
@@ -651,7 +732,7 @@ export async function runCli(argv = process.argv.slice(2)) {
         }
         const targetNames = await resolveTargetNames(nameArg);
         for (const name of targetNames) {
-          await stopService(name);
+          await defaultManager.stop(name, { system: flags.system });
           console.log(`✓ Service "${sanitizeServiceName(name)}" stopped.`);
         }
         break;
@@ -660,20 +741,294 @@ export async function runCli(argv = process.argv.slice(2)) {
       case 'restart': {
         const nameArg = positionals[0];
         if (!nameArg) {
-          throw new Error('Service name or @group is required.\nExample: unitup restart api or unitup restart @myproject');
+          throw new Error(
+            'Service name or @group is required.\nExample: unitup restart api or unitup restart @myproject'
+          );
         }
         const targetNames = await resolveTargetNames(nameArg);
         for (const name of targetNames) {
-          await restartService(name);
+          await defaultManager.restart(name, { system: flags.system });
           console.log(`✓ Service "${sanitizeServiceName(name)}" restarted.`);
         }
         break;
       }
 
+      case 'deploy': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required.\nExample: unitup deploy api');
+        }
+        const safeName = sanitizeServiceName(nameArg);
+        console.log(`${safeName}\n`);
+
+        const isCanary = flags.canary;
+        const weight = flags.weight ? Number(flags.weight.replace('%', '')) : undefined;
+
+        const onProgress = (evt) => {
+          if (evt.state === 'STARTING') {
+            console.log(`✓ generation #${evt.generation} started`);
+          } else if (evt.state === 'WAITING_READY') {
+            // waiting for readiness
+          } else if (evt.state === 'SETTING_CANARY') {
+            const pct = Math.round(evt.weight > 1 ? evt.weight : evt.weight * 100);
+            console.log('✓ ready');
+            console.log(`✓ canary traffic set: ${pct}% to generation #${evt.generation}`);
+          } else if (evt.state === 'SWITCHING') {
+            console.log('✓ ready');
+            console.log('✓ traffic switched');
+          } else if (evt.state === 'STOPPING_PREVIOUS') {
+            console.log('✓ previous generation drained\n');
+          }
+        };
+
+        const res = await deploymentManager.deploy(
+          safeName,
+          {},
+          {
+            publicPort: flags.port ? Number(flags.port) : undefined,
+            readyPath: flags.ready || undefined,
+            drainTimeout: flags.drain ? parseDurationMs(flags.drain) : undefined,
+            canary: isCanary,
+            weight,
+            onProgress
+          }
+        );
+
+        if (res.isCanary) {
+          const pct = Math.round(res.canaryWeight > 1 ? res.canaryWeight : res.canaryWeight * 100);
+          console.log(
+            `\ncanary: v${res.canaryGeneration} (${pct}%) active alongside v${res.activeGeneration} (${100 - pct}%)`
+          );
+          console.log(`Run "unitup promote ${safeName}" to shift 100% traffic to v${res.canaryGeneration}.`);
+        } else {
+          const prev = res.previousGeneration ? `v${res.previousGeneration}` : 'none';
+          const curr = `v${res.currentGeneration}`;
+          console.log(`${prev} -> ${curr}`);
+          console.log(`downtime: ${res.downtimeMs ?? 0}ms`);
+        }
+        break;
+      }
+
+      case 'promote': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required.\nExample: unitup promote api');
+        }
+        const safeName = sanitizeServiceName(nameArg);
+        console.log(`Promoting canary for "${safeName}"...\n`);
+
+        const onProgress = (evt) => {
+          if (evt.state === 'PROMOTING') {
+            console.log(`✓ Promoting generation #${evt.generation} to 100%`);
+          } else if (evt.state === 'DRAINING') {
+            console.log(`✓ Draining previous generation #${evt.generation}`);
+          }
+        };
+
+        const res = await deploymentManager.promote(
+          safeName,
+          {},
+          {
+            drainTimeout: flags.drain ? parseDurationMs(flags.drain) : undefined,
+            onProgress
+          }
+        );
+
+        console.log(`\n✓ Promoted generation #${res.promotedGeneration} to 100% active.`);
+        if (res.previousGeneration) {
+          console.log(`v${res.previousGeneration} -> v${res.promotedGeneration}`);
+        }
+        break;
+      }
+
+      case 'rollback': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required.\nExample: unitup rollback api');
+        }
+        const safeName = sanitizeServiceName(nameArg);
+        console.log(`Rolling back "${safeName}"...\n`);
+
+        const onProgress = (evt) => {
+          if (evt.state === 'ABORTING_CANARY') {
+            console.log(`✓ Aborting and draining canary generation #${evt.canaryGeneration}`);
+          } else if (evt.state === 'SWITCHING') {
+            console.log(`✓ Traffic switched back to generation #${evt.targetGeneration}`);
+          } else if (evt.state === 'DRAINING_CURRENT') {
+            console.log(`✓ Draining generation #${evt.generation}`);
+          }
+        };
+
+        const res = await rollbackManager.rollback(
+          safeName,
+          {},
+          {
+            readyPath: flags.ready || undefined,
+            drainTimeout: flags.drain ? parseDurationMs(flags.drain) : undefined,
+            onProgress
+          }
+        );
+
+        if (res.abortedCanary) {
+          console.log(
+            `\n✓ Aborted canary generation #${res.abortedCanary}. 100% traffic retained on generation #${res.activeGeneration}.`
+          );
+        } else {
+          console.log(`\n✓ Rolled back service "${safeName}" to generation #${res.activeGeneration}.`);
+        }
+        break;
+      }
+
+      case 'supervisor': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required for supervisor mode.\nExample: unitup supervisor api');
+        }
+        await Supervisor.run(nameArg);
+        break;
+      }
+
+      case 'history':
+      case 'generations': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name is required.\nExample: unitup generations api');
+        }
+        const safeName = sanitizeServiceName(nameArg);
+        const gm = new GenerationManager();
+        let list = gm.listGenerations(safeName);
+
+        // Check if supervisor is running via IPC to enrich with live in-flight data
+        let liveStatus = null;
+        const ipcClient = new IPCClient(safeName);
+        if (await ipcClient.isAlive()) {
+          try {
+            liveStatus = await ipcClient.send({ action: 'status' }, null, 1000);
+            if (liveStatus?.generations) {
+              list = liveStatus.generations;
+            }
+          } catch {
+            // fallback to local state
+          }
+        }
+
+        if (!list || list.length === 0) {
+          if (flags.json) {
+            console.log(JSON.stringify([], null, 2));
+          } else {
+            console.log(`No generations recorded for service "${safeName}".`);
+          }
+          break;
+        }
+
+        const tableData = list.map((g) => {
+          let activeFor = '-';
+          if (g.status === 'active') {
+            const start = g.activatedAt
+              ? new Date(g.activatedAt).getTime()
+              : g.createdAt
+                ? new Date(g.createdAt).getTime()
+                : null;
+            if (start && !Number.isNaN(start)) {
+              activeFor = formatDuration(Date.now() - start);
+            }
+          } else if (g.activatedAt) {
+            const start = new Date(g.activatedAt).getTime();
+            const end = g.deactivatedAt
+              ? new Date(g.deactivatedAt).getTime()
+              : g.stoppedAt
+                ? new Date(g.stoppedAt).getTime()
+                : g.drainingAt
+                  ? new Date(g.drainingAt).getTime()
+                  : null;
+            if (start && end && !Number.isNaN(start) && !Number.isNaN(end) && end >= start) {
+              activeFor = formatDuration(end - start);
+            }
+          }
+
+          return {
+            gen: `#${g.id}`,
+            status: g.status || 'unknown',
+            pid: g.pid ? String(g.pid) : '-',
+            port: g.internalPort ? String(g.internalPort) : '-',
+            created: formatRelativeTime(g.createdAt),
+            activeFor,
+            raw: g
+          };
+        });
+
+        if (flags.json) {
+          console.log(
+            JSON.stringify(
+              tableData.map((d) => ({
+                id: d.raw.id,
+                status: d.raw.status,
+                pid: d.raw.pid,
+                internalPort: d.raw.internalPort,
+                createdAt: d.raw.createdAt,
+                activatedAt: d.raw.activatedAt || null,
+                stoppedAt: d.raw.stoppedAt || null,
+                deactivatedAt: d.raw.deactivatedAt || null,
+                activeFor: d.activeFor
+              })),
+              null,
+              2
+            )
+          );
+          break;
+        }
+
+        console.log(`=== Generations: ${safeName} ===\n`);
+        if (liveStatus?.routerPort) {
+          console.log(`Public Router: :${liveStatus.routerPort}`);
+          console.log(`In-Flight Requests: ${liveStatus.inFlightRequests || 0}\n`);
+        }
+
+        const table = formatTable(tableData, [
+          { key: 'gen', label: 'GEN' },
+          { key: 'status', label: 'STATUS' },
+          { key: 'pid', label: 'PID' },
+          { key: 'port', label: 'PORT' },
+          { key: 'created', label: 'CREATED' },
+          { key: 'activeFor', label: 'ACTIVE FOR' }
+        ]);
+        console.log(table);
+        break;
+      }
+
+      case 'enable': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup enable api');
+        }
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          await defaultManager.enable(name, { system: flags.system });
+          console.log(`✓ Service "${sanitizeServiceName(name)}" enabled on startup.`);
+        }
+        break;
+      }
+
+      case 'disable': {
+        const nameArg = positionals[0];
+        if (!nameArg) {
+          throw new Error('Service name or @group is required.\nExample: unitup disable api');
+        }
+        const targetNames = await resolveTargetNames(nameArg);
+        for (const name of targetNames) {
+          await defaultManager.disable(name, { system: flags.system });
+          console.log(`✓ Service "${sanitizeServiceName(name)}" disabled on startup.`);
+        }
+        break;
+      }
+
+      case 'ps':
       case 'status': {
         const nameArg = positionals[0];
         if (!nameArg) {
-          throw new Error('Service name or @group is required.\nExample: unitup status api or unitup status @myproject');
+          throw new Error(
+            'Service name or @group is required.\nExample: unitup status api or unitup status @myproject'
+          );
         }
 
         const targetNames = await resolveTargetNames(nameArg);
@@ -682,25 +1037,103 @@ export async function runCli(argv = process.argv.slice(2)) {
             const raw = await getServiceStatusRaw(name);
             console.log(raw);
           } else {
-            const status = await getServiceStatus(name);
+            const status = await defaultManager.status(name, { system: flags.system });
+
+            // Enrich with generation info if available
+            const gm = new GenerationManager();
+            const genState = gm.loadState(name);
+            let genDetails = null;
+            if (genState?.activeGeneration || genState?.canaryGeneration) {
+              const activeGen = gm.getActive(name);
+              const canaryGen = gm.getCanary(name);
+              genDetails = {
+                activeGeneration: genState.activeGeneration,
+                internalPort: activeGen?.internalPort || null,
+                canaryGeneration: canaryGen?.id || null,
+                canaryPort: canaryGen?.internalPort || null,
+                canaryWeight: canaryGen?.canaryWeight || null,
+                routerPort: null,
+                inFlightRequests: 0
+              };
+
+              const ipcClient = new IPCClient(name);
+              if (await ipcClient.isAlive()) {
+                try {
+                  const live = await ipcClient.send({ action: 'status' }, null, 500);
+                  if (live?.routerPort) {
+                    genDetails.routerPort = live.routerPort;
+                  }
+                  if (live?.inFlightRequests !== undefined) {
+                    genDetails.inFlightRequests = live.inFlightRequests;
+                  }
+                  if (live?.canaryGeneration) {
+                    genDetails.canaryGeneration = live.canaryGeneration.id;
+                    genDetails.canaryPort = live.canaryGeneration.internalPort;
+                  }
+                  if (live?.canaryWeight !== undefined) {
+                    genDetails.canaryWeight = live.canaryWeight;
+                  }
+                } catch {
+                  // ignore
+                }
+              }
+            }
+
+            if (flags.json) {
+              const jsonObj = {
+                ...status,
+                ...(genDetails ? { deployment: genDetails } : {})
+              };
+              console.log(JSON.stringify(jsonObj, null, 2));
+              continue;
+            }
+
             console.log(`${status.name}\n`);
-            console.log(`Status: ${status.status}`);
+            console.log(`Status: ${status.status || status.state}`);
             console.log(`PID: ${status.pid}`);
             console.log(`Started: ${status.started}`);
             console.log(`Restarts: ${status.restarts}`);
             console.log(`Command: ${status.command}`);
             console.log(`Arguments: ${status.arguments}`);
             console.log(`Working directory: ${status.cwd}`);
-            console.log(`Memory: ${status.memory}`);
-            console.log(`Memory Peak: ${status.memoryPeak}`);
-            console.log(`Memory High: ${status.memoryHigh}`);
-            console.log(`Memory Max: ${status.memoryMax}`);
-            console.log(`Swap Max: ${status.memorySwapMax}`);
+
+            if (genDetails) {
+              if (genDetails.activeGeneration) {
+                console.log(`Active Generation: #${genDetails.activeGeneration}`);
+              }
+              if (genDetails.canaryGeneration) {
+                const pct = Math.round(
+                  genDetails.canaryWeight > 1 ? genDetails.canaryWeight : genDetails.canaryWeight * 100
+                );
+                console.log(
+                  `Canary: #${genDetails.canaryGeneration} (${pct}% traffic) -> :${genDetails.canaryPort || 'none'}`
+                );
+              }
+              if (genDetails.routerPort) {
+                const targetPort = genDetails.internalPort ? `:${genDetails.internalPort}` : 'none';
+                console.log(`Router: :${genDetails.routerPort} -> ${targetPort}`);
+                console.log(`In-Flight Requests: ${genDetails.inFlightRequests}`);
+              } else if (genDetails.internalPort) {
+                console.log(`Internal Port: ${genDetails.internalPort}`);
+              }
+            }
+
+            if (status.memory) console.log(`Memory: ${status.memory}`);
+            if (status.memoryPeak) console.log(`Memory Peak: ${status.memoryPeak}`);
+            if (status.memoryHigh) console.log(`Memory High: ${status.memoryHigh}`);
+            if (status.memoryMax) console.log(`Memory Max: ${status.memoryMax}`);
+            if (status.memorySwapMax) console.log(`Swap Max: ${status.memorySwapMax}`);
+            if (flags.verbose) {
+              console.log(`Platform: ${status.platform}`);
+              console.log(`Manager: ${status.manager}`);
+              if (status.unitPath) console.log(`Unit Path: ${status.unitPath}`);
+            }
           }
         }
         break;
       }
 
+      case 'log':
       case 'logs': {
         const nameArg = positionals[0];
         if (!nameArg) {
@@ -712,7 +1145,7 @@ export async function runCli(argv = process.argv.slice(2)) {
           if (targetNames.length > 1) {
             console.log(`=== Logs for ${name} ===`);
           }
-          const output = await runJournalctlLogs(name, {
+          const output = await defaultManager.logs(name, {
             follow: flags.follow,
             lines: flags.lines,
             cat: flags.cat,
@@ -723,9 +1156,24 @@ export async function runCli(argv = process.argv.slice(2)) {
             grep: flags.grep,
             boot: flags.boot,
             json: flags.json,
-            diskUsage: flags.diskUsage
+            diskUsage: flags.diskUsage,
+            system: flags.system
           });
-          if (typeof output === 'string') {
+          if (output && typeof output.on === 'function') {
+            await new Promise((resolve) => {
+              const cleanup = () => {
+                if (output.stop) output.stop();
+                resolve();
+              };
+              process.on('SIGINT', cleanup);
+              process.on('SIGTERM', cleanup);
+              output.on('close', resolve);
+              output.on('error', (err) => {
+                console.error(err.message);
+                cleanup();
+              });
+            });
+          } else if (typeof output === 'string') {
             console.log(output);
           }
         }
@@ -735,16 +1183,21 @@ export async function runCli(argv = process.argv.slice(2)) {
       case 'journal': {
         const action = positionals[0];
         if (!action) {
-          throw new Error('Journal action is required (disk-usage, rotate, vacuum).\nExample: unitup journal vacuum --size 500M');
+          throw new Error(
+            'Journal action is required (disk-usage, rotate, vacuum).\nExample: unitup journal vacuum --size 500M'
+          );
         }
 
         if (action === 'vacuum' && !flags.yes && !flags.dryRun) {
           const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
           const answer = await new Promise((resolve) => {
-            rl.question('This operation affects archived journal logs system-wide,\nnot only services managed by unitup.\n\nContinue? [y/N] ', (ans) => {
-              rl.close();
-              resolve(ans.trim());
-            });
+            rl.question(
+              'This operation affects archived journal logs system-wide,\nnot only services managed by unitup.\n\nContinue? [y/N] ',
+              (ans) => {
+                rl.close();
+                resolve(ans.trim());
+              }
+            );
           });
           if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
             console.log('Aborted.');
@@ -763,14 +1216,19 @@ export async function runCli(argv = process.argv.slice(2)) {
         break;
       }
 
+      case 'uninstall':
+      case 'rm':
+      case 'delete':
       case 'remove': {
         const nameArg = positionals[0];
         if (!nameArg) {
-          throw new Error('Service name or @group is required.\nExample: unitup remove api or unitup remove @myproject');
+          throw new Error(
+            'Service name or @group is required.\nExample: unitup remove api or unitup remove @myproject'
+          );
         }
         const targetNames = await resolveTargetNames(nameArg);
         for (const name of targetNames) {
-          await removeService(name, { force: flags.force });
+          await defaultManager.uninstall(name, { force: flags.force, system: flags.system });
           console.log(`✓ Service "${sanitizeServiceName(name)}" removed.`);
         }
         break;
@@ -778,7 +1236,7 @@ export async function runCli(argv = process.argv.slice(2)) {
 
       case 'ls':
       case 'list': {
-        const services = await listServices({ group: flags.group });
+        const services = await defaultManager.list({ group: flags.group });
         if (services.length === 0) {
           if (flags.group) {
             console.log(`No services found in group "${flags.group}".`);
@@ -804,7 +1262,7 @@ export async function runCli(argv = process.argv.slice(2)) {
         if (!nameArg) {
           throw new Error('Service name is required.\nExample: unitup inspect api');
         }
-        const info = await inspectService(nameArg);
+        const info = await defaultManager.inspect(nameArg, { system: flags.system });
         console.log(`Name: ${info.name}`);
         console.log(`Runtime: ${info.runtime}`);
         console.log(`Group: ${info.group}`);
@@ -812,17 +1270,17 @@ export async function runCli(argv = process.argv.slice(2)) {
         console.log(`Command: ${info.command}`);
         console.log(`Arguments: ${info.arguments}`);
         console.log(`Working directory: ${info.cwd}`);
-        console.log(`Unit: ${info.unit}`);
-        console.log(`Memory: ${info.memory}`);
-        console.log(`Memory Peak: ${info.memoryPeak}`);
-        console.log(`Memory High: ${info.memoryHigh}`);
-        console.log(`Memory Max: ${info.memoryMax}`);
-        console.log(`Swap Max: ${info.memorySwapMax}`);
+        if (info.unit || info.unitFile) console.log(`Unit: ${info.unit || info.unitFile}`);
+        if (info.memory) console.log(`Memory: ${info.memory}`);
+        if (info.memoryPeak) console.log(`Memory Peak: ${info.memoryPeak}`);
+        if (info.memoryHigh) console.log(`Memory High: ${info.memoryHigh}`);
+        if (info.memoryMax) console.log(`Memory Max: ${info.memoryMax}`);
+        if (info.memorySwapMax) console.log(`Swap Max: ${info.memorySwapMax}`);
         break;
       }
 
       case 'failures': {
-        const failures = await getServiceFailures();
+        const failures = await defaultManager.failures();
         if (failures.length === 0) {
           console.log('✓ No failed services.');
           break;