@ebowwa/pkg-ops 0.1.20 → 0.1.22

package/src/config.ts

@@ -1,364 +0,0 @@
-/**
- * Configuration management for PkgOps.
- *
- * Handles reading/writing config file at /etc/pkg-ops/config.json
- *
- * @example
- * ```typescript
- * import { loadConfig, saveConfig, getConfigPath } from "@ebowwa/pkg-ops/config";
- *
- * const config = await loadConfig();
- * console.log(config.packages);
- *
- * config.packages["@ebowwa/stack"] = { version: "0.7.13", service: "stack.service" };
- * await saveConfig(config);
- * ```
- */
-
-import { accessSync, constants, mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
-import { dirname } from "node:path";
-
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * Metadata for a single installed version.
- */
-export interface VersionMetadata {
-  /** ISO timestamp when this version was installed */
-  installedAt: string;
-  /** Size of the dist directory in bytes */
-  distSizeBytes: number | null;
-  /** Number of files in dist */
-  fileCount: number | null;
-}
-
-export interface PackageConfig {
-  /** Currently active version (semver) */
-  version: string;
-  /** All installed versions with metadata */
-  versions: Record<string, VersionMetadata>;
-  /** Associated systemd service name (without .service suffix) */
-  service?: string;
-  /** Whether to auto-start the service after install */
-  autoStart?: boolean;
-  /** Custom environment variables for the service */
-  environment?: Record<string, string>;
-}
-
-export interface PkgOpsConfig {
-  /** Managed packages */
-  packages: Record<string, PackageConfig>;
-  /** Health check HTTP port (default: 8914) */
-  healthPort?: number;
-  /** Working directory for installations (default: /root) */
-  workDir?: string;
-  /** Log level (default: "info") */
-  logLevel?: "debug" | "info" | "warn" | "error";
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_CONFIG: PkgOpsConfig = {
-  packages: {},
-  healthPort: 8914,
-  workDir: "/root",
-  logLevel: "info",
-};
-
-export const CONFIG_DIR = "/etc/pkg-ops";
-export const CONFIG_PATH = `${CONFIG_DIR}/config.json`;
-
-// ---------------------------------------------------------------------------
-// Functions
-// ---------------------------------------------------------------------------
-
-/**
- * Get the config file path.
- * Respects PKG_OPS_CONFIG env override.
- */
-export function getConfigPath(): string {
-  return process.env.PKG_OPS_CONFIG ?? CONFIG_PATH;
-}
-
-/**
- * Ensure config directory exists (requires sudo on most systems).
- */
-export function ensureConfigDir(): void {
-  const configDir = dirname(getConfigPath());
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true, mode: constants.S_IRWXU | constants.S_IRGRP | constants.S_IXGRP });
-  }
-}
-
-/**
- * Load configuration from file.
- * Returns default config if file doesn't exist.
- */
-export function loadConfig(): PkgOpsConfig {
-  const configPath = getConfigPath();
-
-  try {
-    if (!existsSync(configPath)) {
-    return { ...DEFAULT_CONFIG };
-    }
-
-    const content = readFileSync(configPath, "utf-8");
-    const parsed = JSON.parse(content);
-
-    // Merge with defaults
-    return {
-      ...DEFAULT_CONFIG,
-      ...parsed,
-    };
-  } catch (error) {
-    console.error(`Failed to load config from ${configPath}:`, error);
-    return { ...DEFAULT_CONFIG };
-  }
-}
-
-/**
- * Save configuration to file.
- * Creates directory if it doesn't exist.
- */
-export function saveConfig(config: PkgOpsConfig): void {
-  const configPath = getConfigPath();
-  ensureConfigDir();
-
-  const content = JSON.stringify(config, null, 2);
-  writeFileSync(configPath, content, {
-    encoding: "utf-8",
-    mode: constants.S_IRUSR | constants.S_IWUSR | constants.S_IRGRP,
-  });
-}
-
-/**
- * Update a package in the config.
- */
-export function updatePackageConfig(
-  packageName: string,
-  packageConfig: PackageConfig
-): PkgOpsConfig {
-  const config = loadConfig();
-  config.packages[packageName] = packageConfig;
-  saveConfig(config);
-  return config;
-}
-
-/**
- * Remove a package from the config.
- */
-export function removePackageConfig(packageName: string): PkgOpsConfig {
-  const config = loadConfig();
-  delete config.packages[packageName];
-  saveConfig(config);
-  return config;
-}
-
-/**
- * Get a specific package config.
- */
-export function getPackageConfig(packageName: string): PackageConfig | undefined {
-  const config = loadConfig();
-  return config.packages[packageName];
-}
-
-/**
- * List all managed packages.
- */
-export function listManagedPackages(): Array<{ name: string; config: PackageConfig }> {
-  const config = loadConfig();
-  return Object.entries(config.packages).map(([name, cfg]) => ({ name, config: cfg }));
-}
-
-/**
- * Validate package name (must be @ebowwa/* scope).
- */
-export function isValidPackageName(name: string): boolean {
-  return name.startsWith("@ebowwa/");
-}
-
-/**
- * Parse package specifier into name and version.
- * @example
- * parsePackageSpec("@ebowwa/stack@0.7.12") => { name: "@ebowwa/stack", version: "0.7.12" }
- * parsePackageSpec("@ebowwa/stack") => { name: "@ebowwa/stack", version: "latest" }
- */
-export function parsePackageSpec(spec: string): { name: string; version: string } {
-  const atIndex = spec.lastIndexOf("@");
-  if (atIndex <= 0) {
-    // No version specified or scoped package without version
-    return { name: spec, version: "latest" };
-  }
-
-  const name = spec.slice(0, atIndex);
-  const version = spec.slice(atIndex + 1);
-
-  if (!version) {
-    return { name, version: "latest" };
-  }
-
-  return { name, version };
-}
-
-// ---------------------------------------------------------------------------
-// Multi-Version Helper Functions
-// ---------------------------------------------------------------------------
-
-/**
- * Get all installed versions for a package.
- */
-export function getInstalledVersions(packageName: string): VersionMetadata[] {
-  const config = loadConfig();
-  const pkgConfig = config.packages[packageName];
-  if (!pkgConfig?.versions) {
-    return [];
-  }
-  return Object.entries(pkgConfig.versions).map(([version, meta]) => ({
-    version,
-    ...meta,
-  }));
-}
-
-/**
- * Check if a specific version is installed.
- */
-export function isVersionInstalled(packageName: string, version: string): boolean {
-  const config = loadConfig();
-  const pkgConfig = config.packages[packageName];
-  return !!(pkgConfig?.versions?.[version]);
-}
-
-/**
- * Get the active version for a package.
- */
-export function getActiveVersion(packageName: string): string | null {
-  const config = loadConfig();
-  const pkgConfig = config.packages[packageName];
-  return pkgConfig?.version ?? null;
-}
-
-/**
- * Add a new version to the package config.
- */
-export function addPackageVersion(
-  packageName: string,
-  version: string,
-  metadata: Omit<VersionMetadata, "installedAt"> & { installedAt?: string }
-): void {
-  const config = loadConfig();
-
-  if (!config.packages[packageName]) {
-    config.packages[packageName] = {
-      version,
-      versions: {},
-      service: packageName.replace("@ebowwa/", ""),
-      autoStart: true,
-    };
-  }
-
-  config.packages[packageName].versions[version] = {
-    installedAt: metadata.installedAt ?? new Date().toISOString(),
-    distSizeBytes: metadata.distSizeBytes ?? null,
-    fileCount: metadata.fileCount ?? null,
-  };
-
-  saveConfig(config);
-}
-
-/**
- * Remove a version from the package config.
- * Returns true if the version was removed, false if it didn't exist.
- */
-export function removePackageVersion(packageName: string, version: string): boolean {
-  const config = loadConfig();
-  const pkgConfig = config.packages[packageName];
-
-  if (!pkgConfig?.versions?.[version]) {
-    return false;
-  }
-
-  delete pkgConfig.versions[version];
-
-  // If removing the active version, switch to the most recent remaining version
-  if (pkgConfig.version === version) {
-    const remainingVersions = Object.keys(pkgConfig.versions).sort((a, b) => {
-      // Sort by installedAt descending (most recent first)
-      const aTime = pkgConfig.versions[a]?.installedAt ?? "";
-      const bTime = pkgConfig.versions[b]?.installedAt ?? "";
-      return bTime.localeCompare(aTime);
-    });
-
-    if (remainingVersions.length > 0) {
-      pkgConfig.version = remainingVersions[0];
-    } else {
-      // No versions left, remove the package entirely
-      delete config.packages[packageName];
-    }
-  }
-
-  saveConfig(config);
-  return true;
-}
-
-/**
- * Set the active version for a package.
- * Returns true if successful, false if version not installed.
- */
-export function setActiveVersion(packageName: string, version: string): boolean {
-  const config = loadConfig();
-  const pkgConfig = config.packages[packageName];
-
-  if (!pkgConfig?.versions?.[version]) {
-    return false;
-  }
-
-  pkgConfig.version = version;
-  saveConfig(config);
-  return true;
-}
-
-/**
- * Get the count of installed versions for a package.
- */
-export function getVersionCount(packageName: string): number {
-  const config = loadConfig();
-  const pkgConfig = config.packages[packageName];
-  return Object.keys(pkgConfig?.versions ?? {}).length;
-}
-
-/**
- * Get packages with multiple versions installed.
- */
-export function getPackagesWithMultipleVersions(): Array<{
-  name: string;
-  activeVersion: string;
-  totalVersions: number;
-  versions: string[];
-}> {
-  const config = loadConfig();
-  const result: Array<{
-    name: string;
-    activeVersion: string;
-    totalVersions: number;
-    versions: string[];
-  }> = [];
-
-  for (const [name, pkgConfig] of Object.entries(config.packages)) {
-    const versions = Object.keys(pkgConfig.versions ?? {});
-    if (versions.length > 1) {
-      result.push({
-        name,
-        activeVersion: pkgConfig.version,
-        totalVersions: versions.length,
-        versions: versions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true })),
-      });
-    }
-  }
-
-  return result;
-}

package/src/health-server.ts

@@ -1,280 +0,0 @@
-/**
- * Health monitoring HTTP server.
- *
- * Provides an HTTP endpoint for health checks on port 8914 (configurable).
- *
- * @example
- * ```typescript
- * import { HealthServer, startHealthServer } from "@ebowwa/pkg-ops/health-server";
- *
- * // Start health server
- * const server = await startHealthServer(8914);
- *
- * // Custom health checks
- * server.addCheck("custom", async () => ({
- *   healthy: true,
- *   message: "Custom check passed",
- * }));
- *
- * // Stop server
- * await server.stop();
- * ```
- */
-
-import { createServer, type Server as HttpServer, type IncomingMessage, type ServerResponse } from "http";
-import { getServiceManager, type ServiceStatus } from "./service-manager.js";
-import { loadConfig, type PkgOpsConfig } from "./config.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface HealthCheckResult {
-  /** Whether the check passed */
-  healthy: boolean;
-  /** Human-readable message */
-  message: string;
-  /** Additional data */
-  data?: Record<string, unknown>;
-}
-
-export interface ServiceHealth {
-  /** Service name */
-  name: string;
-  /** Whether the service is healthy */
-  healthy: boolean;
-  /** Service status */
-  status: ServiceStatus;
-  /** Last check timestamp */
-  checkedAt: string;
-}
-
-export interface SystemHealth {
-  /** Overall health status */
-  healthy: boolean;
-  /** All services health */
-  services: ServiceHealth[];
-  /** System uptime in seconds */
-  uptime: number;
-  /** Timestamp of this check */
-  timestamp: string;
-}
-
-export type HealthCheckFn = () => Promise<HealthCheckResult> | HealthCheckResult;
-
-// ---------------------------------------------------------------------------
-// Health Server Class
-// ---------------------------------------------------------------------------
-
-/**
- * HTTP server for health monitoring.
- */
-export class HealthServer {
-  private server: HttpServer | null = null;
-  private checks = new Map<string, HealthCheckFn>();
-  private startTime = Date.now();
-  private port: number;
-
-  constructor(port: number = 8914) {
-    this.port = port;
-  }
-
-  /**
-   * Start the health server.
-   */
-  async start(): Promise<void> {
-    if (this.server) {
-      return;
-    }
-
-    return new Promise((resolve, reject) => {
-      this.server = createServer((req, res) => this.handleRequest(req, res));
-
-      this.server.on("error", reject);
-
-      this.server.listen(this.port, () => {
-        console.log(`Health server listening on port ${this.port}`);
-        this.server?.off("error", reject);
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Stop the health server.
-   */
-  async stop(): Promise<void> {
-    if (!this.server) {
-      return;
-    }
-
-    return new Promise((resolve) => {
-      this.server?.close(() => {
-        this.server = null;
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Add a custom health check.
-   */
-  addCheck(name: string, check: HealthCheckFn): void {
-    this.checks.set(name, check);
-  }
-
-  /**
-   * Remove a health check.
-   */
-  removeCheck(name: string): void {
-    this.checks.delete(name);
-  }
-
-  /**
-   * Check health of all services or a specific service.
-   * Public method for CLI usage.
-   */
-  async checkHealth(serviceName?: string): Promise<SystemHealth | ServiceHealth | null> {
-    if (serviceName) {
-      return this.getServiceHealth(serviceName);
-    }
-    return this.getSystemHealth();
-  }
-
-  // ---------------------------------------------------------------------------
-  // Private Methods
-  // ---------------------------------------------------------------------------
-
-  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
-    const url = req.url ?? "/";
-    const method = req.method ?? "GET";
-
-    try {
-      if (method === "GET" && url === "/health") {
-        const health = await this.getSystemHealth();
-        this.sendJson(res, 200, health);
-      } else if (method === "GET" && url.startsWith("/health/")) {
-        const serviceName = url.slice(8).replace(".service", "");
-        const health = await this.getServiceHealth(serviceName);
-        this.sendJson(res, health ? 200 : 404, health ?? { error: "Service not found" });
-      } else if (method === "GET" && url === "/ready") {
-        const health = await this.getSystemHealth();
-        this.sendJson(res, health.healthy ? 200 : 503, { ready: health.healthy });
-      } else if (method === "GET" && url === "/live") {
-        this.sendJson(res, 200, { alive: true });
-      } else {
-        this.sendJson(res, 404, { error: "Not found" });
-      }
-    } catch (error) {
-      console.error("Health check error:", error);
-      this.sendJson(res, 500, { error: "Internal server error" });
-    }
-  }
-
-  private async getSystemHealth(): Promise<SystemHealth> {
-    const config = loadConfig();
-    const serviceManager = getServiceManager();
-
-    const services: ServiceHealth[] = [];
-
-    for (const [packageName, pkgConfig] of Object.entries(config.packages)) {
-      if (!pkgConfig.service) continue;
-
-      const status = await serviceManager.status(pkgConfig.service);
-      const healthy = status.active && status.subState === "running";
-
-      services.push({
-        name: pkgConfig.service,
-        healthy,
-        status,
-        checkedAt: new Date().toISOString(),
-      });
-    }
-
-    // Run custom checks
-    const customResults: Record<string, HealthCheckResult> = {};
-    for (const [name, check] of this.checks) {
-      try {
-        customResults[name] = await check();
-      } catch (error) {
-        customResults[name] = {
-          healthy: false,
-          message: error instanceof Error ? error.message : "Unknown error",
-        };
-      }
-    }
-
-    const allHealthy = services.every((s) => s.healthy) &&
-      Object.values(customResults).every((r) => r.healthy);
-
-    return {
-      healthy: allHealthy,
-      services,
-      uptime: Math.floor((Date.now() - this.startTime) / 1000),
-      timestamp: new Date().toISOString(),
-    };
-  }
-
-  private async getServiceHealth(serviceName: string): Promise<ServiceHealth | null> {
-    const serviceManager = getServiceManager();
-
-    const exists = await serviceManager.exists(serviceName);
-    if (!exists) {
-      return null;
-    }
-
-    const status = await serviceManager.status(serviceName);
-    const healthy = status.active && status.subState === "running";
-
-    return {
-      name: serviceName,
-      healthy,
-      status,
-      checkedAt: new Date().toISOString(),
-    };
-  }
-
-  private sendJson(res: ServerResponse, statusCode: number, data: unknown): void {
-    res.statusCode = statusCode;
-    res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify(data, null, 2));
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Singleton Instance
-// ---------------------------------------------------------------------------
-
-let healthServer: HealthServer | null = null;
-
-/**
- * Start the health server with config port.
- */
-export async function startHealthServer(port?: number): Promise<HealthServer> {
-  const config = loadConfig();
-  const actualPort = port ?? config.healthPort ?? 8914;
-
-  if (!healthServer) {
-    healthServer = new HealthServer(actualPort);
-  }
-
-  await healthServer.start();
-  return healthServer;
-}
-
-/**
- * Stop the health server.
- */
-export async function stopHealthServer(): Promise<void> {
-  if (healthServer) {
-    await healthServer.stop();
-    healthServer = null;
-  }
-}
-
-/**
- * Get the health server instance.
- */
-export function getHealthServer(): HealthServer | null {
-  return healthServer;
-}