@johpaz/hive-agents 0.0.34 → 0.0.36

package/packages/cli/src/adapters/bun-global.ts

@@ -0,0 +1,378 @@
+/**
+ * Bun Global Adapter
+ * 
+ * Handles Hive installation via `bun install -g @johpaz/hive-agents`.
+ * Uses global npm-style installation with local filesystem paths.
+ */
+
+import { spawn, execSync } from "node:child_process";
+import * as path from "node:path";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import type {
+  InstallationAdapter,
+  InstallationConfig,
+  GatewayConfig,
+  ValidationResult,
+} from "./types";
+import {
+  getHiveDir,
+  getDefaultPaths,
+  loadEnvFile,
+  mergeEnv,
+  expandPath,
+  waitForHttpPort,
+  isPortAvailable,
+} from "./config";
+import { PORTS } from "./types";
+
+type SpawnedProcess = {
+  on(event: "close", listener: (code: number | null) => void): void;
+  on(event: "error", listener: (error: Error) => void): void;
+};
+
+/**
+ * Bun Global installation adapter
+ */
+export class BunGlobalAdapter implements InstallationAdapter {
+  readonly type = "bun-global" as const;
+  readonly name = "Bun Global (npm-style)";
+
+  private hiveDir: string;
+  private pidFile: string;
+
+  constructor(options?: { hiveDir?: string }) {
+    this.hiveDir = options?.hiveDir || getHiveDir();
+    this.pidFile = path.join(this.hiveDir, "gateway.pid");
+  }
+
+  /**
+   * Check if Bun global installation is available
+   */
+  async detect(): Promise<boolean> {
+    try {
+      // Check if Bun is installed
+      execSync("bun --version", { stdio: "ignore" });
+
+      // Check if hive is installed globally
+      try {
+        const output = execSync("bun which hive", {
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "ignore"],
+        });
+
+        const hivePath = output.trim();
+        if (hivePath && existsSync(hivePath)) {
+          return true;
+        }
+      } catch {
+        // Try alternative detection
+        const output = execSync("bun pm ls -g", {
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "ignore"],
+        });
+
+        if (output.includes("@johpaz/hive-agents") || output.includes("hive")) {
+          return true;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get Bun Global installation configuration
+   */
+  async getConfig(): Promise<InstallationConfig> {
+    const env = await this.getEnvironment();
+    const paths = getDefaultPaths(this.hiveDir);
+
+    // For global installation, try to find UI directory
+    let uiDir: string | null = null;
+
+    // Check in dist directory relative to hive binary
+    try {
+      const hivePath = execSync("bun which hive", {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+
+      const distDir = path.dirname(hivePath);
+      const potentialUiDir = path.join(distDir, "ui");
+
+      if (existsSync(potentialUiDir)) {
+        uiDir = potentialUiDir;
+      }
+    } catch {
+      // Binary location not found, will use embedded UI fallback
+    }
+
+    // Also check current working directory for development
+    if (!uiDir) {
+      const cwdUiDir = path.join(process.cwd(), "packages/hive-ui/dist");
+      if (existsSync(cwdUiDir)) {
+        uiDir = cwdUiDir;
+      }
+    }
+
+    paths.uiDir = uiDir;
+
+    const port = parseInt(env.HIVE_PORT || "18790", 10) || PORTS.GATEWAY;
+    const publicUrl = env.HIVE_PUBLIC_URL || undefined;
+
+    return {
+      type: this.type,
+      gateway: {
+        host: env.HIVE_HOST || "127.0.0.1",
+        port,
+        wsPort: port,
+        publicUrl,
+        openBrowser: !env.NO_BROWSER,
+        daemon: !!env.HIVE_DAEMON,
+      },
+      paths,
+      env,
+      isDev: process.env.HIVE_DEV === "true" || process.env.HIVE_DEV === "1",
+      hasEmbeddedUI: false,
+    };
+  }
+
+  /**
+   * Start Hive gateway using Bun
+   */
+  async start(config: GatewayConfig): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const args = ["hive", "start", "--skip-check"];
+
+      if (config.daemon) {
+        args.push("--daemon");
+      }
+
+      const child = spawn("bun", args, {
+        stdio: "inherit",
+        detached: false,
+        env: mergeEnv(process.env, {
+          HIVE_HOME: this.hiveDir,
+        }),
+      });
+
+      const childProcess = child as unknown as SpawnedProcess;
+      childProcess.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Bun hive exited with code ${code}`));
+        }
+      });
+
+      childProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Stop Hive gateway
+   */
+  async stop(): Promise<void> {
+    try {
+      if (existsSync(this.pidFile)) {
+        const pid = parseInt(readFileSync(this.pidFile, "utf-8").trim(), 10);
+
+        if (!isNaN(pid)) {
+          try {
+            process.kill(pid, "SIGTERM");
+            console.log(`✅ Hive Gateway detenido (PID: ${pid})`);
+          } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ESRCH") {
+              console.log("⚠️  Hive Gateway no está corriendo");
+            } else {
+              throw error;
+            }
+          } finally {
+            try {
+              unlinkSync(this.pidFile);
+            } catch {
+              // Ignore errors removing PID file
+            }
+          }
+        }
+      } else {
+        // Try to kill by process name
+        try {
+          execSync("pkill -f 'bun.*hive.*start'", { stdio: "ignore" });
+          console.log("✅ Hive Gateway detenido");
+        } catch {
+          console.log("⚠️  Hive Gateway no está corriendo");
+        }
+      }
+    } catch (error) {
+      console.error("❌ Error deteniendo Hive Gateway:", (error as Error).message);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if gateway is running
+   */
+  async isRunning(): Promise<boolean> {
+    try {
+      if (existsSync(this.pidFile)) {
+        const pid = parseInt(readFileSync(this.pidFile, "utf-8").trim(), 10);
+
+        if (!isNaN(pid)) {
+          try {
+            process.kill(pid, 0);
+            return true;
+          } catch {
+            // Process not running, clean up stale PID file
+            try {
+              unlinkSync(this.pidFile);
+            } catch {
+              // Ignore
+            }
+          }
+        }
+      }
+
+      // Alternative: check if port is in use
+      const config = await this.getConfig();
+      const portAvailable = await isPortAvailable(config.gateway.port);
+      return !portAvailable;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get gateway process ID
+   */
+  async getPid(): Promise<number | null> {
+    try {
+      if (existsSync(this.pidFile)) {
+        const pid = parseInt(readFileSync(this.pidFile, "utf-8").trim(), 10);
+        if (!isNaN(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            return pid;
+          } catch {
+            // Process not running
+          }
+        }
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get Bun Global environment variables
+   */
+  async getEnvironment(): Promise<Record<string, string>> {
+    const fileEnv = loadEnvFile();
+    const homeEnv = loadEnvFile(path.join(this.hiveDir, ".env"));
+
+    const defaults = {
+      HIVE_HOST: "127.0.0.1",
+      HIVE_PORT: String(PORTS.GATEWAY),
+      HIVE_HOME: this.hiveDir,
+      NO_BROWSER: "0",
+      HIVE_PUBLIC_URL: "",
+      HIVE_DAEMON: "0",
+    };
+
+    return mergeEnv(defaults, fileEnv, homeEnv, process.env);
+  }
+
+  /**
+   * Validate Bun Global installation
+   */
+  async validate(): Promise<ValidationResult> {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+    const info: string[] = [];
+
+    // Check Bun installation
+    try {
+      const version = execSync("bun --version", { encoding: "utf-8" }).trim();
+      info.push(`Bun: v${version}`);
+    } catch {
+      errors.push("Bun is not installed or not in PATH");
+    }
+
+    // Check global hive installation
+    try {
+      const hivePath = execSync("bun which hive", {
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "ignore"],
+      }).trim();
+
+      if (hivePath && existsSync(hivePath)) {
+        info.push(`Hive binary: ${hivePath}`);
+
+        // Check if UI directory exists
+        const distDir = path.dirname(hivePath);
+        const uiDir = path.join(distDir, "ui");
+
+        if (existsSync(uiDir)) {
+          info.push(`UI directory: ${uiDir}`);
+        } else {
+          warnings.push("UI directory not found - may use embedded UI");
+        }
+      } else {
+        errors.push("Hive is not installed globally");
+      }
+    } catch {
+      errors.push("Hive is not installed globally (try: bun install -g @johpaz/hive-agents)");
+    }
+
+    // Check Hive directory
+    if (existsSync(this.hiveDir)) {
+      info.push(`Hive home: ${this.hiveDir}`);
+    } else {
+      warnings.push(`Hive home directory does not exist: ${this.hiveDir}`);
+    }
+
+    // Check if gateway is running
+    const running = await this.isRunning();
+    if (running) {
+      info.push("Hive Gateway is running");
+
+      // Check health endpoint
+      const config = await this.getConfig();
+      const healthy = await waitForHttpPort(config.gateway.port, "/health", 5000);
+
+      if (healthy) {
+        info.push("Hive health check passed");
+      } else {
+        warnings.push("Hive Gateway is running but health check failed");
+      }
+    } else {
+      warnings.push("Hive Gateway is not running");
+    }
+
+    // Check for conflicting installations
+    try {
+      execSync("docker --version", { stdio: "ignore" });
+      const dockerAdapter = new (await import("./docker")).DockerAdapter();
+      const dockerInstalled = await dockerAdapter.detect();
+
+      if (dockerInstalled) {
+        info.push("Note: Docker installation also detected");
+      }
+    } catch {
+      // Docker not installed, no conflict
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings,
+      info,
+    };
+  }
+}

package/packages/cli/src/adapters/config.ts

@@ -0,0 +1,314 @@
+/**
+ * Configuration utilities for installation adapters
+ * 
+ * Provides shared configuration loading, validation, and normalization
+ * across different installation methods.
+ */
+
+import { z } from "zod";
+import * as path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import type { GatewayConfig, InstallationConfig, InstallationPaths } from "./types";
+import { DEFAULT_GATEWAY_CONFIG, PORTS, gatewayConfigSchema, installationConfigSchema } from "./types";
+
+/**
+ * Get the base Hive directory from environment or default
+ */
+export function getHiveDir(customDir?: string): string {
+  if (customDir) {
+    return path.resolve(customDir);
+  }
+  
+  // Check environment variable
+  if (process.env.HIVE_HOME) {
+    return path.resolve(process.env.HIVE_HOME);
+  }
+  
+  // Development mode
+  if (process.env.HIVE_DEV === "true") {
+    return path.join(process.env.HOME || "", ".hive-dev");
+  }
+  
+  // Default production location
+  return path.join(process.env.HOME || "", ".hive");
+}
+
+/**
+ * Get default installation paths for the current environment
+ */
+export function getDefaultPaths(hiveDir?: string): InstallationPaths {
+  const dir = getHiveDir(hiveDir);
+  const dataDir = path.join(dir, "data");
+  const logsDir = path.join(dir, "logs");
+  
+  return {
+    hiveDir: dir,
+    dbPath: path.join(dataDir, "hive.db"),
+    logPath: path.join(logsDir, "gateway.log"),
+    pidPath: path.join(dir, "gateway.pid"),
+    uiDir: null, // Will be set by adapter
+    workspaceDir: null, // Will be set from config
+  };
+}
+
+/**
+ * Load environment variables from .env file if it exists
+ */
+export function loadEnvFile(envPath?: string): Record<string, string> {
+  const filePath = envPath || path.join(process.cwd(), ".env");
+  
+  if (!existsSync(filePath)) {
+    return {};
+  }
+  
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const env: Record<string, string> = {};
+    
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith("#")) {
+        continue;
+      }
+      
+      const [key, ...valueParts] = trimmed.split("=");
+      if (key && valueParts.length > 0) {
+        const value = valueParts.join("=").trim();
+        // Remove quotes if present
+        const cleanValue = value.replace(/^["']|["']$/g, "");
+        env[key.trim()] = cleanValue;
+      }
+    }
+    
+    return env;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Merge environment variables with precedence
+ */
+export function mergeEnv(...envs: Array<Record<string, string>>): Record<string, string> {
+  const result: Record<string, string> = {};
+  
+  for (const env of envs) {
+    Object.assign(result, env);
+  }
+  
+  return result;
+}
+
+/**
+ * Validate and normalize gateway configuration
+ */
+export function validateGatewayConfig(
+  config: Partial<GatewayConfig>
+): GatewayConfig {
+  const merged = { ...DEFAULT_GATEWAY_CONFIG, ...config };
+  
+  try {
+    return gatewayConfigSchema.parse(merged);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const messages = error.issues.map((e) => `${e.path.join(".")}: ${e.message}`);
+      throw new Error(`Invalid gateway configuration:\n${messages.join("\n")}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Validate complete installation configuration
+ */
+export function validateInstallationConfig(
+  config: unknown
+): InstallationConfig {
+  try {
+    return installationConfigSchema.parse(config);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const messages = error.issues.map((e) => `${e.path.join(".")}: ${e.message}`);
+      throw new Error(`Invalid installation configuration:\n${messages.join("\n")}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Find a free port starting from the given port
+ */
+export async function findFreePort(startPort: number, maxAttempts: number = 100): Promise<number> {
+  for (let port = startPort; port < startPort + maxAttempts; port++) {
+    try {
+      const server = Bun.serve({
+        port,
+        hostname: "0.0.0.0",
+        fetch: () => new Response(""),
+      });
+      server.stop();
+      return port;
+    } catch {
+      // Port is in use, try next
+    }
+  }
+  throw new Error(`No free port found starting from ${startPort}`);
+}
+
+/**
+ * Check if a port is available
+ */
+export async function isPortAvailable(port: number): Promise<boolean> {
+  try {
+    const server = Bun.serve({
+      port,
+      hostname: "0.0.0.0",
+      fetch: () => new Response(""),
+    });
+    server.stop();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Wait for a port to become available
+ */
+export async function waitForPort(
+  port: number,
+  timeout: number = 30000,
+  interval: number = 500
+): Promise<boolean> {
+  const start = Date.now();
+  
+  while (Date.now() - start < timeout) {
+    if (await isPortAvailable(port)) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  
+  return false;
+}
+
+/**
+ * Wait for a port to respond to HTTP requests
+ */
+export async function waitForHttpPort(
+  port: number,
+  path: string = "/health",
+  timeout: number = 30000
+): Promise<boolean> {
+  const start = Date.now();
+  
+  while (Date.now() - start < timeout) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}${path}`, {
+        signal: AbortSignal.timeout(1000),
+      });
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+      // Port not ready yet
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  }
+  
+  return false;
+}
+
+/**
+ * Expand a path that may contain ~ or environment variables
+ */
+export function expandPath(input: string): string {
+  if (!input) {
+    return input;
+  }
+  
+  // Expand ~ to home directory
+  if (input.startsWith("~/")) {
+    return path.join(process.env.HOME || "", input.slice(2));
+  }
+  
+  // Expand environment variables ${VAR} or $VAR
+  return input.replace(/\$\{?([A-Z_][A-Z0-9_]*)\}?/gi, (_, name) => {
+    return process.env[name] || name;
+  });
+}
+
+/**
+ * Get the distribution directory where the binary is located
+ */
+export function getDistDir(): string | null {
+  // Check environment variable
+  if (process.env.HIVE_DIST_DIR) {
+    return process.env.HIVE_DIST_DIR;
+  }
+  
+  // Try to detect from process.argv
+  const scriptPath = process.argv[1];
+  if (!scriptPath) {
+    return null;
+  }
+  
+  const dir = path.dirname(scriptPath);
+  
+  // Check if we're in a dist directory
+  if (path.basename(dir) === "dist") {
+    return dir;
+  }
+  
+  // Check if dist exists as a sibling
+  const distPath = path.join(dir, "dist");
+  if (existsSync(distPath)) {
+    return distPath;
+  }
+  
+  return null;
+}
+
+/**
+ * Check if running in development mode
+ *
+ * Development mode is ONLY activated when HIVE_DEV is set to "true" or "1".
+ * Otherwise, defaults to production mode.
+ *
+ * This is a simple and reliable check:
+ * - Set HIVE_DEV=true in your development environment
+ * - Production installations don't need to set anything
+ */
+export function isDevMode(): boolean {
+  return process.env.HIVE_DEV === "true" || process.env.HIVE_DEV === "1";
+}
+
+/**
+ * Check if running as a child process
+ */
+export function isChildProcess(): boolean {
+  return process.env.HIVE_GATEWAY_CHILD === "1";
+}
+
+/**
+ * Get platform-specific information
+ */
+export function getPlatformInfo(): {
+  platform: string;
+  arch: string;
+  isLinux: boolean;
+  isMac: boolean;
+  isWindows: boolean;
+} {
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  return {
+    platform,
+    arch,
+    isLinux: platform === "linux",
+    isMac: platform === "darwin",
+    isWindows: platform === "win32",
+  };
+}