@ebowwa/pkg-ops 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ebowwa/pkg-ops",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "type": "module",
   "description": "Package operations CLI - installs @ebowwa/* npm packages and manages systemd services",
   "bin": {
@@ -14,7 +14,6 @@
   },
   "files": [
     "dist",
-    "src",
     "rust/src",
     "rust/Cargo.toml",
     "rust/Cargo.lock",

package/rust/src/lib.rs

@@ -838,6 +838,8 @@ pub fn get_installed_info() -> Vec<InstalledPackageInfo> {
             version: pkg.version.clone(),
             dist_size_bytes: dist_size,
             installed_at,
+            total_versions: None,
+            versions: None,
         });
     }
 
@@ -1086,7 +1088,7 @@ pub fn switch_version(package_name: &str, target_version: &str) -> SwitchResult
     SwitchResult {
         success: true,
         package_name: package_name.to_string(),
-        from_version: current_version,
+        from_version: current_version.clone(),
         to_version: target_version.to_string(),
         message: format!("Switched from {} to {}", current_version, target_version),
     }

package/src/bridge.ts

@@ -1,506 +0,0 @@
-/**
- * Bridge to Rust worker for package operations.
- *
- * Communicates with the Rust core via JSON-RPC 2.0 over stdin/stdout.
- *
- * @example
- * ```typescript
- * import { RustBridge } from "@ebowwa/pkg-ops/bridge";
- *
- * const bridge = new RustBridge();
- * await bridge.start();
- *
- * // Install a package
- * const result = await bridge.install("@ebowwa/stack", "0.7.12");
- * console.log(result);
- *
- * // List packages
- * const packages = await bridge.list();
- *
- * await bridge.stop();
- * ```
- */
-
-import { spawn, type ChildProcess } from "child_process";
-import { accessSync, constants as fsConstants } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export interface InstallResult {
-  success: boolean;
-  version: string;
-  previousVersion?: string;
-  message: string;
-}
-
-export interface PackageInfo {
-  name: string;
-  version: string;
-  installed: boolean;
-  service?: string;
-}
-
-export interface RollbackResult {
-  success: boolean;
-  previousVersion: string;
-  currentVersion: string;
-  message: string;
-}
-
-export interface HealthCheckResult {
-  healthy: boolean;
-  services: Array<{
-    name: string;
-    status: string;
-    pid: number;
-  }>;
-}
-
-export interface VerifyResult {
-  packageName: string;
-  version: string;
-  success: boolean;
-  distExists: boolean;
-  checksum: string | null;
-  message: string;
-}
-
-export interface AuditResult {
-  packageName: string;
-  severity: string;
-  vulnerability: string;
-  description: string;
-}
-
-export interface BundleSize {
-  packageName: string;
-  version: string;
-  distSizeBytes: number;
-  fileCount: number;
-}
-
-export interface InstalledPackageInfo {
-  packageName: string;
-  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 {
-  jsonrpc: "2.0";
-  id: string;
-  method: string;
-  params?: Record<string, unknown>;
-}
-
-interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  id: string;
-  result?: unknown;
-  error?: {
-    code: number;
-    message: string;
-    data?: unknown;
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const REQUEST_TIMEOUT = 30000;
-
-// ---------------------------------------------------------------------------
-// Rust Bridge Class
-// ---------------------------------------------------------------------------
-
-/**
- * Bridge to the Rust worker process.
- *
- * Handles JSON-RPC communication over stdin/stdout.
- */
-export class RustBridge {
-  private process: ChildProcess | null = null;
-  private pendingRequests = new Map<string, {
-    resolve: (value: unknown) => void;
-    reject: (error: Error) => void;
-    timeout: ReturnType<typeof setTimeout>;
-  }>();
-  private requestId = 0;
-  private buffer = "";
-
-  /**
-   * Start the Rust worker process.
-   */
-  async start(): Promise<void> {
-    if (this.process) {
-      return;
-    }
-
-    const binaryPath = this.getBinaryPath();
-
-    // Check if binary exists
-    try {
-      accessSync(binaryPath, fsConstants.X_OK);
-    } catch {
-      throw new Error(
-        `Rust binary not found at ${binaryPath}. ` +
-        `Run 'bun run build:rust' in the pkg-ops package.`
-      );
-    }
-
-    this.process = spawn(binaryPath, [], {
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-
-    if (!this.process.stdin || !this.process.stdout) {
-      throw new Error("Failed to create stdin/stdout pipes");
-    }
-
-    // Handle stdout (JSON-RPC responses)
-    this.process.stdout.on("data", (data: Buffer) => {
-      this.buffer += data.toString("utf-8");
-      this.processBuffer();
-    });
-
-    // Handle stderr (logs)
-    this.process.stderr?.on("data", (data: Buffer) => {
-      console.error("[rust-worker]", data.toString("utf-8").trim());
-    });
-
-    // Handle process exit
-    this.process.on("exit", (code: number | null) => {
-      console.error(`Rust worker exited with code ${code}`);
-      this.process = null;
-    });
-  }
-
-  /**
-   * Stop the Rust worker process.
-   */
-  async stop(): Promise<void> {
-    if (!this.process) {
-      return;
-    }
-
-    // Send shutdown request
-    try {
-      await this.sendRequest("shutdown", {});
-    } catch {
-      // Ignore errors on shutdown
-    }
-
-    // Give it time to shutdown gracefully
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-
-    // Force kill if still running
-    if (this.process) {
-      this.process.kill("SIGTERM");
-      this.process = null;
-    }
-
-    // Clear pending requests
-    for (const [id, pending] of this.pendingRequests) {
-      clearTimeout(pending.timeout);
-      pending.reject(new Error("Bridge shutdown"));
-    }
-    this.pendingRequests.clear();
-  }
-
-  /**
-   * Install a package.
-   */
-  async install(packageName: string, version: string): Promise<InstallResult> {
-    return this.sendRequest("install", { packageName, version }) as Promise<InstallResult>;
-  }
-
-  /**
-   * Update a package to latest version.
-   */
-  async update(packageName: string): Promise<InstallResult> {
-    return this.sendRequest("update", { packageName }) as Promise<InstallResult>;
-  }
-
-  /**
-   * Update all managed packages.
-   */
-  async updateAll(): Promise<InstallResult[]> {
-    return this.sendRequest("updateAll", {}) as Promise<InstallResult[]>;
-  }
-
-  /**
-   * List installed packages.
-   */
-  async list(): Promise<PackageInfo[]> {
-    return this.sendRequest("list", {}) as Promise<PackageInfo[]>;
-  }
-
-  /**
-   * Rollback a package to previous version.
-   */
-  async rollback(packageName: string): Promise<RollbackResult> {
-    return this.sendRequest("rollback", { packageName }) as Promise<RollbackResult>;
-  }
-
-  /**
-   * Check health of all services.
-   */
-  async health(): Promise<HealthCheckResult> {
-    return this.sendRequest("health", {}) as Promise<HealthCheckResult>;
-  }
-
-  /**
-   * Verify package integrity.
-   */
-  async verify(packageName: string): Promise<VerifyResult> {
-    return this.sendRequest("verify", { packageName }) as Promise<VerifyResult>;
-  }
-
-  /**
-   * Run vulnerability scan.
-   */
-  async audit(): Promise<AuditResult[]> {
-    return this.sendRequest("audit", {}) as Promise<AuditResult[]>;
-  }
-
-  /**
-   * Get bundle sizes.
-   */
-  async getBundleSizes(): Promise<BundleSize[]> {
-    return this.sendRequest("sizes", {}) as Promise<BundleSize[]>;
-  }
-
-  /**
-   * Get detailed installed package info.
-   */
-  async getInstalledInfo(): Promise<InstalledPackageInfo[]> {
-    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
-  // ---------------------------------------------------------------------------
-
-  private getBinaryPath(): string {
-    // Get the directory of this module
-    const currentDir = dirname(fileURLToPath(import.meta.url));
-
-    // Paths to check (in order of preference)
-    const paths = [
-      // Cargo build output (works on VPS after `cargo build --release`)
-      join(currentDir, "..", "rust", "target", "release", "pkg-ops-core"),
-      // Pre-built binary in rust folder (for npm package distribution)
-      join(currentDir, "..", "rust", "pkg-ops-core"),
-      // Linux-specific cargo output
-      join(currentDir, "..", "rust", "target", "x86_64-unknown-linux-gnu", "release", "pkg-ops-core"),
-    ];
-
-    for (const path of paths) {
-      try {
-        accessSync(path, fsConstants.X_OK);
-        return path;
-      } catch {
-        // Try next path
-      }
-    }
-
-    // Return the most likely path for error message
-    throw new Error(
-      `Rust binary not found. Tried:\n${paths.map(p => `  - ${p}`).join("\n")}\n` +
-      `Run 'bun run build:rust' or 'cargo build --release' in the pkg-ops package.`
-    );
-  }
-
-  private sendRequest<T>(method: string, params: Record<string, unknown>): Promise<T> {
-    return new Promise((resolve, reject) => {
-      if (!this.process?.stdin) {
-        reject(new Error("Rust worker not started"));
-        return;
-      }
-
-      const id = String(++this.requestId);
-      const request: JsonRpcRequest = {
-        jsonrpc: "2.0",
-        id,
-        method,
-        params,
-      };
-
-      // Set up timeout
-      const timeout = setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new Error(`Request timeout: ${method}`));
-      }, REQUEST_TIMEOUT);
-
-      // Store pending request
-      this.pendingRequests.set(id, {
-        resolve: resolve as (value: unknown) => void,
-        reject,
-        timeout,
-      });
-
-      // Send request
-      const json = JSON.stringify(request) + "\n";
-      this.process.stdin.write(json, "utf-8", (err: Error | null | undefined) => {
-        if (err) {
-          this.pendingRequests.delete(id);
-          clearTimeout(timeout);
-          reject(err);
-        }
-      });
-    });
-  }
-
-  private processBuffer(): void {
-    const lines = this.buffer.split("\n");
-    this.buffer = lines.pop() ?? "";
-
-    for (const line of lines) {
-      if (!line.trim()) continue;
-
-      try {
-        const response: JsonRpcResponse = JSON.parse(line);
-        const pending = this.pendingRequests.get(response.id);
-
-        if (pending) {
-          clearTimeout(pending.timeout);
-          this.pendingRequests.delete(response.id);
-
-          if (response.error) {
-            pending.reject(new Error(response.error.message));
-          } else {
-            pending.resolve(response.result);
-          }
-        }
-      } catch (err) {
-        console.error("Failed to parse response:", line, err);
-      }
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Singleton Instance
-// ---------------------------------------------------------------------------
-
-let defaultBridge: RustBridge | null = null;
-
-/**
- * Get the default bridge instance.
- */
-export function getBridge(): RustBridge {
-  if (!defaultBridge) {
-    defaultBridge = new RustBridge();
-  }
-  return defaultBridge;
-}
-
-/**
- * Start the default bridge.
- */
-export async function startBridge(): Promise<RustBridge> {
-  const bridge = getBridge();
-  await bridge.start();
-  return bridge;
-}
-
-/**
- * Stop the default bridge.
- */
-export async function stopBridge(): Promise<void> {
-  if (defaultBridge) {
-    await defaultBridge.stop();
-    defaultBridge = null;
-  }
-}