@ebowwa/pkg-ops 0.1.17 → 0.1.19

package/rust/src/main.rs

@@ -227,6 +227,183 @@ fn handle_installed_info(req: Request) -> ResponseEnvelope {
     }
 }
 
+// ---------------------------------------------------------------------------
+// Multi-Version Handlers
+// ---------------------------------------------------------------------------
+
+fn handle_list_versions(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let versions = list_versions(package_name);
+
+    match Response::new(req.id.clone(), &versions) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_switch_version(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let version = match params["version"].as_str() {
+        Some(v) => v,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing version"),
+            ));
+        }
+    };
+
+    let result = switch_version(package_name, version);
+
+    match Response::new(req.id.clone(), &result) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_prune_versions(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let keep_count = params["keepCount"].as_u64().unwrap_or(2) as u32;
+
+    let result = prune_versions(package_name, keep_count);
+
+    match Response::new(req.id.clone(), &result) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_remove_version(req: Request) -> ResponseEnvelope {
+    let params = match req.params.as_ref() {
+        Some(p) => p,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing params"),
+            ));
+        }
+    };
+
+    let package_name = match params["packageName"].as_str() {
+        Some(n) => n,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing packageName"),
+            ));
+        }
+    };
+
+    let version = match params["version"].as_str() {
+        Some(v) => v,
+        None => {
+            return ResponseEnvelope::Error(ErrorResponse::new(
+                req.id,
+                ErrorObject::invalid_params("Missing version"),
+            ));
+        }
+    };
+
+    let result = remove_version(package_name, version);
+
+    let response = match result {
+        Ok(msg) => serde_json::json!({
+            "success": true,
+            "message": msg
+        }),
+        Err(msg) => serde_json::json!({
+            "success": false,
+            "message": msg
+        }),
+    };
+
+    match Response::new(req.id.clone(), &response) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
+fn handle_get_multi_version_packages(req: Request) -> ResponseEnvelope {
+    let packages = get_multi_version_packages();
+
+    match Response::new(req.id.clone(), &packages) {
+        Ok(r) => ResponseEnvelope::Success(r),
+        Err(e) => ResponseEnvelope::Error(ErrorResponse::new(
+            req.id,
+            ErrorObject::internal_error(e.to_string()),
+        )),
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Router
 // ---------------------------------------------------------------------------

package/src/bridge.ts

@@ -88,6 +88,44 @@ export interface InstalledPackageInfo {
   version: string;
   distSizeBytes: number | null;
   installedAt: string | null;
+  /** Total number of installed versions */
+  totalVersions?: number;
+  /** All installed versions */
+  versions?: VersionInfo[];
+}
+
+/**
+ * Version information for a package.
+ */
+export interface VersionInfo {
+  version: string;
+  installedAt: string;
+  distSizeBytes: number | null;
+  fileCount: number | null;
+  active: boolean;
+}
+
+/**
+ * Result of switching versions.
+ */
+export interface SwitchResult {
+  success: boolean;
+  packageName: string;
+  fromVersion: string;
+  toVersion: string;
+  message: string;
+}
+
+/**
+ * Result of pruning old versions.
+ */
+export interface PruneResult {
+  success: boolean;
+  packageName: string;
+  removedVersions: string[];
+  keptVersions: string[];
+  freedBytes: number;
+  message: string;
 }
 
 interface JsonRpcRequest {
@@ -281,6 +319,55 @@ export class RustBridge {
     return this.sendRequest("installedInfo", {}) as Promise<InstalledPackageInfo[]>;
   }
 
+  // ---------------------------------------------------------------------------
+  // Multi-Version Methods
+  // ---------------------------------------------------------------------------
+
+  /**
+   * List all installed versions of a package.
+   */
+  async listVersions(packageName: string): Promise<VersionInfo[]> {
+    return this.sendRequest("listVersions", { packageName }) as Promise<VersionInfo[]>;
+  }
+
+  /**
+   * Switch to a specific installed version.
+   */
+  async switchVersion(packageName: string, version: string): Promise<SwitchResult> {
+    return this.sendRequest("switchVersion", { packageName, version }) as Promise<SwitchResult>;
+  }
+
+  /**
+   * Remove old versions, keeping only the N most recent.
+   */
+  async pruneVersions(packageName: string, keepCount: number): Promise<PruneResult> {
+    return this.sendRequest("pruneVersions", { packageName, keepCount }) as Promise<PruneResult>;
+  }
+
+  /**
+   * Remove a specific version.
+   */
+  async removeVersion(packageName: string, version: string): Promise<{ success: boolean; message: string }> {
+    return this.sendRequest("removeVersion", { packageName, version }) as Promise<{ success: boolean; message: string }>;
+  }
+
+  /**
+   * Get packages with multiple versions installed.
+   */
+  async getMultiVersionPackages(): Promise<Array<{
+    packageName: string;
+    activeVersion: string;
+    totalVersions: number;
+    versions: string[];
+  }>> {
+    return this.sendRequest("getMultiVersionPackages", {}) as Promise<Array<{
+      packageName: string;
+      activeVersion: string;
+      totalVersions: number;
+      versions: string[];
+    }>>;
+  }
+
   // ---------------------------------------------------------------------------
   // Private Methods
   // ---------------------------------------------------------------------------

package/src/config.ts

@@ -23,9 +23,23 @@ 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 {
-  /** Package version (semver or "latest") */
+  /** 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 */
@@ -190,3 +204,161 @@ export function parsePackageSpec(spec: string): { name: string; version: string
 
   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;
+}