@ebowwa/pkg-ops 0.1.17 → 0.1.19

package/dist/types.d.ts

@@ -0,0 +1,204 @@
+/**
+ * Type definitions for PkgOps multi-version support.
+ *
+ * @module @ebowwa/pkg-ops/types
+ */
+/**
+ * Metadata for an installed package version.
+ */
+export interface VersionInfo {
+    /** Semver version string */
+    version: string;
+    /** ISO timestamp when this version was installed */
+    installedAt: string;
+    /** Size of the dist directory in bytes */
+    distSizeBytes: number | null;
+    /** Number of files in the dist directory */
+    fileCount: number | null;
+    /** Whether this is the currently active version */
+    active: boolean;
+}
+/**
+ * Configuration for a managed package with multi-version support.
+ */
+export interface PackageConfig {
+    /** Currently active version */
+    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>;
+    /** Maximum number of versions to keep (default: 3) */
+    maxVersions?: number;
+}
+/**
+ * Metadata stored for each 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 the dist directory */
+    fileCount: number | null;
+}
+/**
+ * Result of listing versions for a package.
+ */
+export interface VersionsListResult {
+    packageName: string;
+    versions: VersionInfo[];
+    activeVersion: string;
+    maxVersions: number;
+}
+/**
+ * Result of switching to a different version.
+ */
+export interface SwitchVersionResult {
+    success: boolean;
+    packageName: string;
+    previousVersion: string;
+    newVersion: string;
+    serviceRestarted: boolean;
+    message: string;
+}
+/**
+ * Result of pruning old versions.
+ */
+export interface PruneResult {
+    success: boolean;
+    packageName: string;
+    removedVersions: string[];
+    keptVersions: string[];
+    freedBytes: number;
+    message: string;
+}
+/**
+ * Result of installing a package (updated for multi-version).
+ */
+export interface InstallResult {
+    success: boolean;
+    version: string;
+    previousVersion?: string;
+    /** Whether this was a new version install or reinstall */
+    isNew: boolean;
+    /** Total versions now installed */
+    totalVersions: number;
+    message: string;
+}
+/**
+ * Result of rolling back a package.
+ */
+export interface RollbackResult {
+    success: boolean;
+    previousVersion: string;
+    currentVersion: string;
+    /** Available versions to rollback to */
+    availableVersions: string[];
+    message: string;
+}
+/**
+ * Package info with version details.
+ */
+export interface PackageInfo {
+    name: string;
+    version: string;
+    installed: boolean;
+    service?: string;
+    /** Total installed versions */
+    totalVersions?: number;
+    /** All installed versions */
+    versions?: VersionInfo[];
+}
+/**
+ * Main configuration structure.
+ */
+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";
+    /** Default max versions to keep per package */
+    defaultMaxVersions?: number;
+}
+/**
+ * JSON-RPC request structure.
+ */
+export interface JsonRpcRequest {
+    jsonrpc: "2.0";
+    id: string;
+    method: string;
+    params?: Record<string, unknown>;
+}
+/**
+ * JSON-RPC response structure.
+ */
+export interface JsonRpcResponse {
+    jsonrpc: "2.0";
+    id: string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/**
+ * Vulnerability audit result.
+ */
+export interface AuditResult {
+    packageName: string;
+    severity: string;
+    vulnerability: string;
+    description: string;
+}
+/**
+ * Package verification result.
+ */
+export interface VerifyResult {
+    packageName: string;
+    version: string;
+    success: boolean;
+    distExists: boolean;
+    checksum: string | null;
+    message: string;
+}
+/**
+ * Bundle size info.
+ */
+export interface BundleSize {
+    packageName: string;
+    version: string;
+    distSizeBytes: number;
+    fileCount: number;
+}
+/**
+ * Installed package detailed info.
+ */
+export interface InstalledPackageInfo {
+    packageName: string;
+    version: string;
+    distSizeBytes: number | null;
+    installedAt: string | null;
+    totalVersions?: number;
+}
+/**
+ * Health check result.
+ */
+export interface HealthCheckResult {
+    healthy: boolean;
+    services: Array<{
+        name: string;
+        status: string;
+        pid: number;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/pkg-ops",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "description": "Package operations CLI - installs @ebowwa/* npm packages and manages systemd services",
   "bin": {
@@ -21,7 +21,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --sourcemap --minify && tsc --emitDeclarationOnly --declaration",
+    "build": "bun build src/index.ts --outdir dist --target bun --sourcemap --minify && tsc --emitDeclarationOnly --declaration",
     "build:rust": "cd rust && cargo build --release",
     "dev": "bun run src/index.ts",
     "typecheck": "tsc --noEmit",

package/rust/src/lib.rs

@@ -94,6 +94,52 @@ pub struct InstalledPackageInfo {
     pub version: String,
     pub dist_size_bytes: Option<u64>,
     pub installed_at: Option<String>, // ISO timestamp
+    pub total_versions: Option<u32>,
+    pub versions: Option<Vec<VersionInfo>>,
+}
+
+/// Version information for multi-version support
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct VersionInfo {
+    pub version: String,
+    pub installed_at: String,
+    pub dist_size_bytes: Option<u64>,
+    pub file_count: Option<u32>,
+    pub active: bool,
+}
+
+/// Result of switching versions
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SwitchResult {
+    pub success: bool,
+    pub package_name: String,
+    pub from_version: String,
+    pub to_version: String,
+    pub message: String,
+}
+
+/// Result of pruning old versions
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PruneResult {
+    pub success: bool,
+    pub package_name: String,
+    pub removed_versions: Vec<String>,
+    pub kept_versions: Vec<String>,
+    pub freed_bytes: u64,
+    pub message: String,
+}
+
+/// Multi-version package summary
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MultiVersionPackage {
+    pub package_name: String,
+    pub active_version: String,
+    pub total_versions: u32,
+    pub versions: Vec<String>,
 }
 
 // ---------------------------------------------------------------------------
@@ -797,3 +843,395 @@ pub fn get_installed_info() -> Vec<InstalledPackageInfo> {
 
     info_list
 }
+
+// ---------------------------------------------------------------------------
+// Multi-Version Operations
+// ---------------------------------------------------------------------------
+
+/// Directory for storing multiple package versions
+const VERSIONS_DIR: &str = "/opt/pkg-ops/versions";
+
+/// List all installed versions of a package
+pub fn list_versions(package_name: &str) -> Vec<VersionInfo> {
+    info!("Listing versions for {}", package_name);
+
+    let mut versions = Vec::new();
+
+    // Check the multi-version directory
+    let package_versions_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"));
+
+    if package_versions_dir.exists() {
+        if let Ok(entries) = fs::read_dir(&package_versions_dir) {
+            for entry in entries.flatten() {
+                let version_dir = entry.path();
+                if !version_dir.is_dir() {
+                    continue;
+                }
+
+                let version = entry.file_name().to_string_lossy().to_string();
+                let dist_path = version_dir.join("dist");
+
+                // Get installed timestamp from directory mtime
+                let installed_at = fs::metadata(&version_dir)
+                    .ok()
+                    .and_then(|m| m.modified().ok())
+                    .map(|t| {
+                        let datetime: chrono::DateTime<chrono::Utc> = t.into();
+                        datetime.to_rfc3339()
+                    })
+                    .unwrap_or_else(|| "unknown".to_string());
+
+                let (dist_size, file_count) = if dist_path.exists() {
+                    let (size, count) = calculate_dir_size(&dist_path);
+                    (Some(size), Some(count))
+                } else {
+                    (None, None)
+                };
+
+                versions.push(VersionInfo {
+                    version,
+                    installed_at,
+                    dist_size_bytes: dist_size,
+                    file_count,
+                    active: false, // Will be set below
+                });
+            }
+        }
+    }
+
+    // Also check the active version in node_modules
+    let active_version = get_installed_version(package_name);
+    if let Some(ref active) = active_version {
+        // Mark active version
+        for v in &mut versions {
+            if &v.version == active {
+                v.active = true;
+            }
+        }
+
+        // If active version not in versions list, add it
+        if !versions.iter().any(|v| &v.version == active) {
+            let package_path = Path::new(WORK_DIR)
+                .join("node_modules")
+                .join(package_name);
+
+            let dist_path = package_path.join("dist");
+            let (dist_size, file_count) = if dist_path.exists() {
+                let (size, count) = calculate_dir_size(&dist_path);
+                (Some(size), Some(count))
+            } else {
+                (None, None)
+            };
+
+            let installed_at = package_path.join("package.json")
+                .exists()
+                .then(|| {
+                    fs::metadata(package_path.join("package.json"))
+                        .ok()
+                        .and_then(|m| m.modified().ok())
+                        .map(|t| {
+                            let datetime: chrono::DateTime<chrono::Utc> = t.into();
+                            datetime.to_rfc3339()
+                        })
+                })
+                .flatten()
+                .unwrap_or_else(|| "unknown".to_string());
+
+            versions.push(VersionInfo {
+                version: active.clone(),
+                installed_at,
+                dist_size_bytes: dist_size,
+                file_count,
+                active: true,
+            });
+        }
+    }
+
+    // Sort by version descending (newest first)
+    versions.sort_by(|a, b| {
+        // Simple semver comparison
+        let a_parts: Vec<u32> = a.version
+            .split('.')
+            .filter_map(|s| s.parse().ok())
+            .collect();
+        let b_parts: Vec<u32> = b.version
+            .split('.')
+            .filter_map(|s| s.parse().ok())
+            .collect();
+
+        for i in 0..std::cmp::min(a_parts.len(), b_parts.len()) {
+            match b_parts.get(i).cmp(&a_parts.get(i)) {
+                std::cmp::Ordering::Equal => continue,
+                other => return other,
+            }
+        }
+        b_parts.len().cmp(&a_parts.len())
+    });
+
+    versions
+}
+
+/// Switch to a specific installed version
+pub fn switch_version(package_name: &str, target_version: &str) -> SwitchResult {
+    info!("Switching {} to version {}", package_name, target_version);
+
+    let current_version = match get_installed_version(package_name) {
+        Some(v) => v,
+        None => {
+            return SwitchResult {
+                success: false,
+                package_name: package_name.to_string(),
+                from_version: "none".to_string(),
+                to_version: target_version.to_string(),
+                message: "Package not installed".to_string(),
+            };
+        }
+    };
+
+    if current_version == target_version {
+        return SwitchResult {
+            success: true,
+            package_name: package_name.to_string(),
+            from_version: current_version.clone(),
+            to_version: target_version.to_string(),
+            message: "Already on target version".to_string(),
+        };
+    }
+
+    // Check if target version exists in versions directory
+    let version_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"))
+        .join(target_version);
+
+    if !version_dir.exists() {
+        // Try installing from npm
+        let package_spec = format!("{}@{}", package_name, target_version);
+        let output = match Command::new("bun")
+            .args(["add", &package_spec])
+            .current_dir(WORK_DIR)
+            .output()
+        {
+            Ok(o) => o,
+            Err(e) => {
+                return SwitchResult {
+                    success: false,
+                    package_name: package_name.to_string(),
+                    from_version: current_version,
+                    to_version: target_version.to_string(),
+                    message: format!("Failed to run bun add: {}", e),
+                };
+            }
+        };
+
+        if !output.status.success() {
+            let stderr = String::from_utf8_lossy(&output.stderr);
+            return SwitchResult {
+                success: false,
+                package_name: package_name.to_string(),
+                from_version: current_version,
+                to_version: target_version.to_string(),
+                message: format!("Version {} not found locally or on npm: {}", target_version, stderr),
+            };
+        }
+
+        return SwitchResult {
+            success: true,
+            package_name: package_name.to_string(),
+            from_version: current_version,
+            to_version: target_version.to_string(),
+            message: format!("Installed and switched to {}", target_version),
+        };
+    }
+
+    // Backup current version to versions directory
+    let current_version_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"))
+        .join(&current_version);
+
+    let current_package_path = Path::new(WORK_DIR)
+        .join("node_modules")
+        .join(package_name);
+
+    if current_package_path.exists() {
+        // Create versions directory if needed
+        let _ = fs::create_dir_all(current_version_dir.parent().unwrap());
+
+        // Copy current version to versions dir (if not already there)
+        if !current_version_dir.exists() {
+            if let Err(e) = copy_dir_all(&current_package_path, &current_version_dir) {
+                error!("Failed to backup current version: {}", e);
+            }
+        }
+    }
+
+    // Remove current version from node_modules
+    if let Err(e) = fs::remove_dir_all(&current_package_path) {
+        error!("Failed to remove current version: {}", e);
+    }
+
+    // Copy target version to node_modules
+    if let Err(e) = copy_dir_all(&version_dir, &current_package_path) {
+        return SwitchResult {
+            success: false,
+            package_name: package_name.to_string(),
+            from_version: current_version,
+            to_version: target_version.to_string(),
+            message: format!("Failed to copy target version: {}", e),
+        };
+    }
+
+    info!("Switched {} from {} to {}", package_name, current_version, target_version);
+
+    SwitchResult {
+        success: true,
+        package_name: package_name.to_string(),
+        from_version: current_version,
+        to_version: target_version.to_string(),
+        message: format!("Switched from {} to {}", current_version, target_version),
+    }
+}
+
+/// Prune old versions, keeping only N most recent
+pub fn prune_versions(package_name: &str, keep_count: u32) -> PruneResult {
+    info!("Pruning {} versions, keeping {}", package_name, keep_count);
+
+    let versions = list_versions(package_name);
+
+    if versions.len() <= keep_count as usize {
+        return PruneResult {
+            success: true,
+            package_name: package_name.to_string(),
+            removed_versions: vec![],
+            kept_versions: versions.iter().map(|v| v.version.clone()).collect(),
+            freed_bytes: 0,
+            message: format!("Only {} versions installed, nothing to prune", versions.len()),
+        };
+    }
+
+    let package_versions_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"));
+
+    // Sort by installed date (newest first) and keep top N
+    let mut sorted_versions: Vec<_> = versions.into_iter().collect();
+    sorted_versions.sort_by(|a, b| b.installed_at.cmp(&a.installed_at));
+
+    let kept: Vec<_> = sorted_versions.iter()
+        .take(keep_count as usize)
+        .map(|v| v.version.clone())
+        .collect();
+
+    let mut removed = Vec::new();
+    let mut freed_bytes = 0u64;
+
+    for version_info in sorted_versions.iter().skip(keep_count as usize) {
+        // Don't remove active version
+        if version_info.active {
+            continue;
+        }
+
+        let version_dir = package_versions_dir.join(&version_info.version);
+        if version_dir.exists() {
+            // Calculate size before removing
+            let (size, _) = calculate_dir_size(&version_dir);
+            freed_bytes += size;
+
+            if let Err(e) = fs::remove_dir_all(&version_dir) {
+                error!("Failed to remove version {}: {}", version_info.version, e);
+            } else {
+                removed.push(version_info.version.clone());
+            }
+        }
+    }
+
+    PruneResult {
+        success: true,
+        package_name: package_name.to_string(),
+        removed_versions: removed.clone(),
+        kept_versions: kept,
+        freed_bytes,
+        message: if removed.is_empty() {
+            "No versions to remove".to_string()
+        } else {
+            format!("Removed {} version(s), freed {} bytes", removed.len(), freed_bytes)
+        },
+    }
+}
+
+/// Remove a specific version
+pub fn remove_version(package_name: &str, version: &str) -> Result<String, String> {
+    info!("Removing {}@{}", package_name, version);
+
+    // Check if this is the active version
+    let active_version = get_installed_version(package_name);
+    if active_version.as_deref() == Some(version) {
+        return Err("Cannot remove active version. Switch to another version first.".to_string());
+    }
+
+    let version_dir = Path::new(VERSIONS_DIR)
+        .join(package_name.replace("@", "").replace("/", "-"))
+        .join(version);
+
+    if !version_dir.exists() {
+        return Err(format!("Version {} not found", version));
+    }
+
+    let (size, _) = calculate_dir_size(&version_dir);
+
+    if let Err(e) = fs::remove_dir_all(&version_dir) {
+        return Err(format!("Failed to remove version: {}", e));
+    }
+
+    Ok(format!("Removed {}@{} (freed {} bytes)", package_name, version, size))
+}
+
+/// Get packages with multiple versions installed
+pub fn get_multi_version_packages() -> Vec<MultiVersionPackage> {
+    info!("Getting packages with multiple versions");
+
+    let packages = list_packages();
+    let mut result = Vec::new();
+
+    for pkg in packages {
+        if !pkg.installed {
+            continue;
+        }
+
+        let versions = list_versions(&pkg.name);
+        if versions.len() > 1 {
+            let active_version = versions.iter()
+                .find(|v| v.active)
+                .map(|v| v.version.clone())
+                .unwrap_or_else(|| pkg.version.clone());
+
+            result.push(MultiVersionPackage {
+                package_name: pkg.name.clone(),
+                active_version,
+                total_versions: versions.len() as u32,
+                versions: versions.iter().map(|v| v.version.clone()).collect(),
+            });
+        }
+    }
+
+    result
+}
+
+/// Helper to recursively copy a directory
+fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
+    fs::create_dir_all(dst)?;
+
+    for entry in fs::read_dir(src)? {
+        let entry = entry?;
+        let ty = entry.file_type()?;
+        let src_path = entry.path();
+        let dst_path = dst.join(entry.file_name());
+
+        if ty.is_dir() {
+            copy_dir_all(&src_path, &dst_path)?;
+        } else {
+            fs::copy(&src_path, &dst_path)?;
+        }
+    }
+
+    Ok(())
+}