@ebowwa/pkg-ops 0.1.9

package/src/bridge.ts

@@ -0,0 +1,419 @@
+/**
+ * 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;
+}
+
+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[]>;
+  }
+
+  // ---------------------------------------------------------------------------
+  // 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;
+  }
+}

package/src/config.ts

@@ -0,0 +1,192 @@
+/**
+ * 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
+// ---------------------------------------------------------------------------
+
+export interface PackageConfig {
+  /** Package version (semver or "latest") */
+  version: string;
+  /** 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: /opt/pkg-ops) */
+  workDir?: string;
+  /** Log level (default: "info") */
+  logLevel?: "debug" | "info" | "warn" | "error";
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+export const DEFAULT_CONFIG: PkgOpsConfig = {
+  packages: {},
+  healthPort: 8914,
+  workDir: "/opt/pkg-ops",
+  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 };
+}