@ebowwa/pkg-ops 0.1.9

package/src/index.ts

@@ -0,0 +1,860 @@
+#!/usr/bin/env node
+/**
+ * PkgOps CLI
+ *
+ * Package operations CLI that installs @ebowwa/* npm packages
+ * and manages systemd services.
+ *
+ * @example
+ * ```bash
+ * # Install a package
+ * pkg-ops install @ebowwa/stack@0.7.12
+ *
+ * # Service management
+ * pkg-ops service start stack
+ * pkg-ops service status stack
+ *
+ * # Health check
+ * pkg-ops health
+ *
+ * # List packages
+ * pkg-ops list
+ * ```
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import {
+  loadConfig,
+  parsePackageSpec,
+  isValidPackageName,
+  getPackageConfig,
+  updatePackageConfig,
+  removePackageConfig,
+  listManagedPackages,
+} from "./config.js";
+import { ServiceManager, getServiceManager } from "./service-manager.js";
+import { RustBridge, startBridge, stopBridge } from "./bridge.js";
+import { startHealthServer, stopHealthServer, getHealthServer } from "./health-server.js";
+import type { VerifyResult, AuditResult, BundleSize, InstalledPackageInfo } from "./bridge.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+interface Command {
+  name: string;
+  description: string;
+  usage: string;
+  handler: (args: string[]) => Promise<void> | void;
+}
+
+interface Subcommand {
+  name: string;
+  description: string;
+  usage: string;
+  handler: (args: string[]) => Promise<void> | void;
+}
+
+// ---------------------------------------------------------------------------
+// Package Management Commands
+// ---------------------------------------------------------------------------
+
+async function handleInstall(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops install <package>[@version]");
+    process.exit(1);
+  }
+
+  const spec = args[0];
+  const { name, version } = parsePackageSpec(spec);
+
+  if (!isValidPackageName(name)) {
+    console.error(`Invalid package name. Only @ebowwa/* packages are supported.`);
+    process.exit(1);
+  }
+
+  console.log(`Installing ${name}@${version}...`);
+
+  try {
+    const bridge = await startBridge();
+    const result = await bridge.install(name, version);
+
+    if (result.success) {
+      console.log(`Successfully installed ${name}@${result.version}`);
+      if (result.previousVersion) {
+        console.log(`  Previous version: ${result.previousVersion}`);
+      }
+
+      // Update config
+      updatePackageConfig(name, {
+        version: result.version,
+        service: name.replace("@ebowwa/", ""),
+      });
+
+      // Start service if configured
+      const config = getPackageConfig(name);
+      if (config?.service && config.autoStart !== false) {
+        const sm = getServiceManager();
+        const startResult = await sm.start(config.service);
+        if (startResult.success) {
+          console.log(`  Service ${config.service} started`);
+        } else {
+          console.warn(`  Failed to start service: ${startResult.message}`);
+        }
+      }
+    } else {
+      console.error(`Failed to install ${name}: ${result.message}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Install failed:`, error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleUpdate(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops update <package>");
+    process.exit(1);
+  }
+
+  const packageName = args[0];
+
+  if (!isValidPackageName(packageName)) {
+    console.error(`Invalid package name. Only @ebowwa/* packages are supported.`);
+    process.exit(1);
+  }
+
+  console.log(`Updating ${packageName}...`);
+
+  try {
+    const bridge = await startBridge();
+    const result = await bridge.update(packageName);
+
+    if (result.success) {
+      console.log(`Successfully updated ${packageName} to ${result.version}`);
+      if (result.previousVersion) {
+        console.log(`  Previous version: ${result.previousVersion}`);
+      }
+
+      // Update config
+      updatePackageConfig(packageName, {
+        version: result.version,
+        service: packageName.replace("@ebowwa/", ""),
+      });
+
+      // Restart service if running
+      const sm = getServiceManager();
+      const config = getPackageConfig(packageName);
+      if (config?.service) {
+        const status = await sm.status(config.service);
+        if (status.active) {
+          await sm.restart(config.service);
+          console.log(`  Service ${config.service} restarted`);
+        }
+      }
+    } else {
+      console.error(`Failed to update ${packageName}: ${result.message}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Update failed:`, error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleUpdateAll(_args: string[]): Promise<void> {
+  console.log("Updating all managed packages...");
+
+  try {
+    const bridge = await startBridge();
+    const results = await bridge.updateAll();
+
+    for (const result of results) {
+      if (result.success) {
+        console.log(`Updated ${result.version}`);
+      } else {
+        console.error(`Failed to update: ${result.message}`);
+      }
+    }
+  } catch (error) {
+    console.error("Update all failed:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleList(_args: string[]): Promise<void> {
+  console.log("Installed packages:\n");
+
+  try {
+    const bridge = await startBridge();
+    const packages = await bridge.list();
+
+    if (packages.length === 0) {
+      console.log("  No packages installed");
+      return;
+    }
+
+    for (const pkg of packages) {
+      const status = pkg.installed ? "installed" : "not installed";
+      const service = pkg.service ? ` (service: ${pkg.service})` : "";
+      console.log(`  ${pkg.name}@${pkg.version} [${status}]${service}`);
+    }
+  } catch (error) {
+    console.error("Failed to list packages:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleRollback(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops rollback <package>");
+    process.exit(1);
+  }
+
+  const packageName = args[0];
+
+  console.log(`Rolling back ${packageName}...`);
+
+  try {
+    const bridge = await startBridge();
+    const result = await bridge.rollback(packageName);
+
+    if (result.success) {
+      console.log(`Rolled back ${packageName} from ${result.currentVersion} to ${result.previousVersion}`);
+
+      // Restart service if running
+      const sm = getServiceManager();
+      const config = getPackageConfig(packageName);
+      if (config?.service) {
+        const status = await sm.status(config.service);
+        if (status.active) {
+          await sm.restart(config.service);
+          console.log(`  Service ${config.service} restarted`);
+        }
+      }
+    } else {
+      console.error(`Rollback failed: ${result.message}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("Rollback failed:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Service Management Commands
+// ---------------------------------------------------------------------------
+
+async function handleServiceStart(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service start <name>");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const sm = getServiceManager();
+
+  console.log(`Starting ${serviceName}...`);
+  const result = await sm.start(serviceName);
+
+  if (result.success) {
+    console.log(`Service ${serviceName} started`);
+  } else {
+    console.error(`Failed to start ${serviceName}: ${result.message}`);
+    process.exit(1);
+  }
+}
+
+async function handleServiceStop(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service stop <name>");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const sm = getServiceManager();
+
+  console.log(`Stopping ${serviceName}...`);
+  const result = await sm.stop(serviceName);
+
+  if (result.success) {
+    console.log(`Service ${serviceName} stopped`);
+  } else {
+    console.error(`Failed to stop ${serviceName}: ${result.message}`);
+    process.exit(1);
+  }
+}
+
+async function handleServiceRestart(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service restart <name>");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const sm = getServiceManager();
+
+  console.log(`Restarting ${serviceName}...`);
+  const result = await sm.restart(serviceName);
+
+  if (result.success) {
+    console.log(`Service ${serviceName} restarted`);
+  } else {
+    console.error(`Failed to restart ${serviceName}: ${result.message}`);
+    process.exit(1);
+  }
+}
+
+async function handleServiceStatus(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service status <name>");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const sm = getServiceManager();
+
+  const info = await sm.info(serviceName);
+
+  if (!info.exists) {
+    console.log(`Service ${serviceName} not found`);
+    return;
+  }
+
+  console.log(`Service: ${serviceName}`);
+  console.log(`  Loaded: ${info.status.loaded}`);
+  console.log(`  Active: ${info.status.active}`);
+  console.log(`  State: ${info.status.subState}`);
+  console.log(`  PID: ${info.status.mainPid || "N/A"}`);
+  console.log(`  Description: ${info.status.description || "N/A"}`);
+}
+
+async function handleServiceLogs(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service logs <name> [--lines N]");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const linesIndex = args.indexOf("--lines");
+  const lines = linesIndex >= 0 && args[linesIndex + 1]
+    ? parseInt(args[linesIndex + 1], 10)
+    : 100;
+
+  const sm = getServiceManager();
+  const logs = await sm.logs(serviceName, { lines });
+
+  console.log(logs);
+}
+
+async function handleServiceEnable(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service enable <name>");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const sm = getServiceManager();
+
+  console.log(`Enabling ${serviceName}...`);
+  const result = await sm.enable(serviceName);
+
+  if (result.success) {
+    console.log(`Service ${serviceName} enabled on boot`);
+  } else {
+    console.error(`Failed to enable ${serviceName}: ${result.message}`);
+    process.exit(1);
+  }
+}
+
+async function handleServiceDisable(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops service disable <name>");
+    process.exit(1);
+  }
+
+  const serviceName = args[0];
+  const sm = getServiceManager();
+
+  console.log(`Disabling ${serviceName}...`);
+  const result = await sm.disable(serviceName);
+
+  if (result.success) {
+    console.log(`Service ${serviceName} disabled from boot`);
+  } else {
+    console.error(`Failed to disable ${serviceName}: ${result.message}`);
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Health Commands
+// ---------------------------------------------------------------------------
+
+async function handleHealth(args: string[]): Promise<void> {
+  const serviceName = args[0];
+
+  const healthServer = getHealthServer();
+  if (!healthServer) {
+    console.error("Health server not initialized");
+    process.exit(1);
+  }
+
+  const health = await healthServer.checkHealth(serviceName);
+
+  if (!health) {
+    console.log("Service not found");
+    return;
+  }
+
+  if ("services" in health) {
+    // SystemHealth
+    if (health.healthy) {
+      console.log("All services healthy");
+    } else {
+      console.log("Some services unhealthy");
+    }
+
+    for (const service of health.services) {
+      const icon = service.healthy ? "OK" : "FAIL";
+      console.log(`  [${icon}] ${service.name}: ${service.status.subState}`);
+    }
+  } else {
+    // ServiceHealth
+    const icon = health.healthy ? "OK" : "FAIL";
+    console.log(`[${icon}] ${health.name}: ${health.status.subState}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Config Commands
+// ---------------------------------------------------------------------------
+
+async function handleConfigShow(_args: string[]): Promise<void> {
+  const config = loadConfig();
+
+  console.log("VPS Manager Configuration");
+  console.log(`Config path: /etc/pkg-ops/config.json`);
+  console.log(`Health port: ${config.healthPort}`);
+  console.log(`Work dir: ${config.workDir}`);
+  console.log(`Log level: ${config.logLevel}`);
+  console.log("\nPackages:");
+
+  const packages = listManagedPackages();
+  if (packages.length === 0) {
+    console.log("  No packages configured");
+    return;
+  }
+
+  for (const { name, config: pkgConfig } of packages) {
+    console.log(`  ${name}:`);
+    console.log(`    Version: ${pkgConfig.version}`);
+    if (pkgConfig.service) {
+      console.log(`    Service: ${pkgConfig.service}`);
+    }
+    if (pkgConfig.autoStart !== undefined) {
+      console.log(`    Auto-start: ${pkgConfig.autoStart}`);
+    }
+  }
+}
+
+async function handleConfigSet(args: string[]): Promise<void> {
+  if (args.length < 3) {
+    console.error("Usage: pkg-ops config set <package> <key> <value>");
+    process.exit(1);
+  }
+
+  const packageName = args[0];
+  const key = args[1];
+  const value = args[2];
+
+  if (!isValidPackageName(packageName)) {
+    console.error(`Invalid package name. Only @ebowwa/* packages are supported.`);
+    process.exit(1);
+  }
+
+  const config = getPackageConfig(packageName) ?? {
+    version: "latest",
+  };
+
+  // Handle different value types
+  switch (key) {
+    case "version":
+      config.version = value;
+      break;
+    case "service":
+      config.service = value;
+      break;
+    case "autoStart":
+      config.autoStart = value === "true";
+      break;
+    default:
+      console.error(`Unknown config key: ${key}`);
+      console.error("Valid keys: version, service, autoStart");
+      process.exit(1);
+  }
+
+  updatePackageConfig(packageName, config);
+  console.log(`Updated ${packageName}.${key} = ${value}`);
+}
+
+// ---------------------------------------------------------------------------
+// Verification & Audit Commands
+// ---------------------------------------------------------------------------
+
+async function handleVerify(args: string[]): Promise<void> {
+  if (args.length === 0) {
+    console.error("Usage: pkg-ops verify <package>");
+    process.exit(1);
+  }
+
+  const packageName = args[0];
+
+  if (!isValidPackageName(packageName)) {
+    console.error(`Invalid package name. Only @ebowwa/* packages are supported.`);
+    process.exit(1);
+  }
+
+  console.log(`Verifying ${packageName}...`);
+
+  try {
+    const bridge = await startBridge();
+    const result = await bridge.verify(packageName);
+
+    console.log(`\nPackage: ${result.packageName}@${result.version}`);
+    console.log(`  Status: ${result.success ? "VALID" : "INVALID"}`);
+    console.log(`  Dist exists: ${result.distExists ? "Yes" : "No"}`);
+    if (result.checksum) {
+      console.log(`  Checksum: ${result.checksum}`);
+    }
+    console.log(`  Message: ${result.message}`);
+  } catch (error) {
+    console.error("Verification failed:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleSyncStatus(args: string[]): Promise<void> {
+  const localIndex = args.indexOf("--local");
+  const localPathIndex = args.indexOf("--local-path");
+
+  let localPath = "./package.json";
+  if (localPathIndex >= 0 && args[localPathIndex + 1]) {
+    localPath = args[localPathIndex + 1];
+  }
+
+  const showLocal = localIndex >= 0 || localPathIndex >= 0;
+
+  try {
+    const bridge = await startBridge();
+    const vpsPackages = await bridge.getInstalledInfo();
+
+    console.log("Sync Status: Local vs VPS\n");
+
+    if (showLocal && existsSync(localPath)) {
+      const localContent = readFileSync(localPath, "utf-8");
+      const localPkg = JSON.parse(localContent);
+      const deps = { ...localPkg.dependencies, ...localPkg.devDependencies };
+
+      // Build a map of VPS packages
+      const vpsMap = new Map<string, string>();
+      for (const pkg of vpsPackages) {
+        vpsMap.set(pkg.packageName, pkg.version);
+      }
+
+      // Compare local vs VPS
+      for (const [name, localVersion] of Object.entries(deps)) {
+        if (!name.startsWith("@ebowwa/")) continue;
+
+        const vpsVersion = vpsMap.get(name);
+        const cleanLocal = (localVersion as string).replace(/^[\^~]/, "");
+
+        if (vpsVersion) {
+          if (cleanLocal === vpsVersion) {
+            console.log(`  ${name}: local=${cleanLocal}, vps=${vpsVersion} (in sync)`);
+          } else if (cleanLocal > vpsVersion) {
+            console.log(`  ${name}: local=${cleanLocal}, vps=${vpsVersion} (VPS behind)`);
+          } else {
+            console.log(`  ${name}: local=${cleanLocal}, vps=${vpsVersion} (local behind)`);
+          }
+          vpsMap.delete(name);
+        } else {
+          console.log(`  ${name}: local=${cleanLocal}, vps=not installed`);
+        }
+      }
+
+      // Show VPS-only packages
+      for (const [name, version] of vpsMap) {
+        console.log(`  ${name}: local=not in package.json, vps=${version}`);
+      }
+    } else {
+      // Just show VPS installed versions
+      if (vpsPackages.length === 0) {
+        console.log("  No packages installed on VPS");
+      } else {
+        for (const pkg of vpsPackages) {
+          const sizeInfo = pkg.distSizeBytes
+            ? ` (${(pkg.distSizeBytes / 1024).toFixed(1)} KB)`
+            : "";
+          console.log(`  ${pkg.packageName}@${pkg.version}${sizeInfo}`);
+        }
+      }
+    }
+  } catch (error) {
+    console.error("Failed to get sync status:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleAudit(_args: string[]): Promise<void> {
+  console.log("Running vulnerability scan...\n");
+
+  try {
+    const bridge = await startBridge();
+    const results = await bridge.audit();
+
+    if (results.length === 0) {
+      console.log("No vulnerabilities found.");
+      return;
+    }
+
+    console.log(`Found ${results.length} vulnerability(es):\n`);
+
+    for (const vuln of results) {
+      console.log(`[${vuln.severity.toUpperCase()}] ${vuln.packageName}`);
+      console.log(`  Vulnerability: ${vuln.vulnerability}`);
+      console.log(`  Description: ${vuln.description}`);
+      console.log("");
+    }
+  } catch (error) {
+    console.error("Audit failed:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+async function handleScan(args: string[]): Promise<void> {
+  // Alias for audit
+  await handleAudit(args);
+}
+
+async function handleSizes(_args: string[]): Promise<void> {
+  console.log("Bundle sizes:\n");
+
+  try {
+    const bridge = await startBridge();
+    const sizes = await bridge.getBundleSizes();
+
+    if (sizes.length === 0) {
+      console.log("  No packages installed");
+      return;
+    }
+
+    // Print table header
+    console.log("  Package                         | Version  | Dist Size");
+    console.log("  --------------------------------|----------|-----------");
+
+    for (const pkg of sizes) {
+      const name = pkg.packageName.padEnd(32);
+      const version = pkg.version.padEnd(9);
+      const sizeKB = (pkg.distSizeBytes / 1024).toFixed(1) + " KB";
+      const files = pkg.fileCount ? ` (${pkg.fileCount} files)` : "";
+      console.log(`  ${name} | ${version} | ${sizeKB}${files}`);
+    }
+  } catch (error) {
+    console.error("Failed to get bundle sizes:", error);
+    process.exit(1);
+  } finally {
+    await stopBridge();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CLI Entry Point
+// ---------------------------------------------------------------------------
+
+const commands: Command[] = [
+  // Package management
+  { name: "install", description: "Install an @ebowwa/* package", usage: "pkg-ops install <package>[@version]", handler: handleInstall },
+  { name: "update", description: "Update a package to latest version", usage: "pkg-ops update <package>", handler: handleUpdate },
+  { name: "update-all", description: "Update all managed packages", usage: "pkg-ops update-all", handler: handleUpdateAll },
+  { name: "list", description: "List installed packages", usage: "pkg-ops list", handler: handleList },
+  { name: "rollback", description: "Rollback a package to previous version", usage: "pkg-ops rollback <package>", handler: handleRollback },
+  // Service management
+  { name: "start", description: "Start a systemd service", usage: "pkg-ops service start <name>", handler: handleServiceStart },
+  { name: "stop", description: "Stop a systemd service", usage: "pkg-ops service stop <name>", handler: handleServiceStop },
+  { name: "restart", description: "Restart a systemd service", usage: "pkg-ops service restart <name>", handler: handleServiceRestart },
+  { name: "status", description: "Get service status", usage: "pkg-ops service status <name>", handler: handleServiceStatus },
+  { name: "logs", description: "View service logs", usage: "pkg-ops service logs <name> [--lines N]", handler: handleServiceLogs },
+  { name: "enable", description: "Enable service on boot", usage: "pkg-ops service enable <name>", handler: handleServiceEnable },
+  { name: "disable", description: "Disable service from boot", usage: "pkg-ops service disable <name>", handler: handleServiceDisable },
+  // Health
+  { name: "health", description: "Check health of all services", usage: "pkg-ops health [service]", handler: handleHealth },
+  // Config
+  { name: "config", description: "Show configuration", usage: "pkg-ops config show", handler: handleConfigShow },
+  { name: "set-config", description: "Set a config value", usage: "pkg-ops config set <package> <key> <value>", handler: handleConfigSet },
+  // Verification & Audit
+  { name: "verify", description: "Verify package integrity", usage: "pkg-ops verify <package>", handler: handleVerify },
+  { name: "sync-status", description: "Show local vs VPS version sync", usage: "pkg-ops sync-status [--local-path path]", handler: handleSyncStatus },
+  { name: "audit", description: "Check for vulnerabilities", usage: "pkg-ops audit", handler: handleAudit },
+  { name: "scan", description: "Alias for audit", usage: "pkg-ops scan", handler: handleScan },
+  { name: "sizes", description: "Show bundle sizes", usage: "pkg-ops sizes", handler: handleSizes },
+];
+
+const serviceCommands: Subcommand[] = [
+  { name: "start", description: "Start a systemd service", usage: "pkg-ops service start <name>", handler: handleServiceStart },
+  { name: "stop", description: "Stop a systemd service", usage: "pkg-ops service stop <name>", handler: handleServiceStop },
+  { name: "restart", description: "Restart a systemd service", usage: "pkg-ops service restart <name>", handler: handleServiceRestart },
+  { name: "status", description: "Get service status", usage: "pkg-ops service status <name>", handler: handleServiceStatus },
+  { name: "logs", description: "View service logs", usage: "pkg-ops service logs <name> [--lines N]", handler: handleServiceLogs },
+  { name: "enable", description: "Enable service on boot", usage: "pkg-ops service enable <name>", handler: handleServiceEnable },
+  { name: "disable", description: "Disable service from boot", usage: "pkg-ops service disable <name>", handler: handleServiceDisable },
+];
+
+const configCommands: Subcommand[] = [
+  { name: "show", description: "Show configuration", usage: "pkg-ops config show", handler: handleConfigShow },
+  { name: "set", description: "Set a config value", usage: "pkg-ops config set <package> <key> <value>", handler: handleConfigSet },
+];
+
+function printHelp(): void {
+  console.log(`
+VPS Manager - Unified package manager for VPS
+
+Usage:
+  pkg-ops <command> [arguments]
+
+Package Management:
+  install <package>[@version]    Install an @ebowwa/* package
+  update <package>              Update a package to latest version
+  update-all                    Update all managed packages
+  list                           List installed packages
+  rollback <package>            Rollback a package to previous version
+
+Service Management:
+  service start <name>          Start a systemd service
+  service stop <name>           Stop a systemd service
+  service restart <name>        Restart a systemd service
+  service status <name>         Get service status
+  service logs <name> [--lines N]  View service logs
+  service enable <name>         Enable service on boot
+  service disable <name>        Disable service from boot
+
+Health:
+  health [service]              Check health of all services or specific one
+
+Verification & Audit:
+  verify <package>              Verify package integrity
+  sync-status [--local-path p]  Show local vs VPS version sync
+  audit                         Check for vulnerabilities
+  scan                          Alias for audit
+  sizes                         Show bundle sizes
+
+Config:
+  config show                   Show configuration
+  config set <pkg> <key> <val>  Set a config value
+
+Options:
+  --help, -h                   Show this help message
+  --version, -v                Show version
+
+Examples:
+  pkg-ops install @ebowwa/stack@0.7.12
+  pkg-ops service start stack
+  pkg-ops health
+  pkg-ops sync-status --local-path ./package.json
+  pkg-ops verify @ebowwa/stack
+  pkg-ops audit
+`);
+}
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+
+  if (args[0] === "--version" || args[0] === "-v") {
+    const config = loadConfig();
+    console.log(`pkg-ops ${config.packages?.["@ebowwa/pkg-ops"]?.version ?? "0.1.0"}`);
+    process.exit(0);
+  }
+
+  const commandName = args[0];
+  const commandArgs = args.slice(1);
+
+  // Handle service subcommands
+  if (commandName === "service") {
+    if (commandArgs.length === 0) {
+      console.error("Missing service subcommand");
+      console.error("Usage: pkg-ops service <start|stop|restart|status|logs|enable|disable> <name>");
+      process.exit(1);
+    }
+
+    const subcommandName = commandArgs[0];
+    const subcommand = serviceCommands.find((c) => c.name === subcommandName);
+
+    if (!subcommand) {
+      console.error(`Unknown service subcommand: ${subcommandName}`);
+      process.exit(1);
+    }
+
+    await subcommand.handler(commandArgs.slice(1));
+    return;
+  }
+
+  // Handle config subcommands
+  if (commandName === "config") {
+    if (commandArgs.length === 0) {
+      console.error("Missing config subcommand");
+      console.error("Usage: pkg-ops config <show|set> [args...]");
+      process.exit(1);
+    }
+
+    const subcommandName = commandArgs[0];
+    const subcommand = configCommands.find((c) => c.name === subcommandName);
+
+    if (!subcommand) {
+      console.error(`Unknown config subcommand: ${subcommandName}`);
+      process.exit(1);
+    }
+
+    await subcommand.handler(commandArgs.slice(1));
+    return;
+  }
+
+  // Handle regular commands
+  const command = commands.find((c) => c.name === commandName);
+
+  if (!command) {
+    console.error(`Unknown command: ${commandName}`);
+    console.error("Run 'pkg-ops --help' for usage");
+    process.exit(1);
+  }
+
+  await command.handler(commandArgs);
+}
+
+// Run CLI
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});