@johpaz/hive-agents 0.0.35 → 0.0.36

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

@@ -0,0 +1,218 @@
+/**
+ * Installation Adapter System
+ * 
+ * Provides a unified interface for different Hive installation methods:
+ * - Docker Compose (standard)
+ * - Bun Global (npm-style installation)
+ * - Binary (standalone compiled binary)
+ */
+
+import { z } from "zod";
+
+/**
+ * Installation type identifier
+ */
+export type InstallationType = "docker" | "bun-global" | "binary";
+
+/**
+ * Installation paths for different methods
+ */
+export interface InstallationPaths {
+  /** Base directory for Hive data and configuration */
+  hiveDir: string;
+  /** Database file path */
+  dbPath: string;
+  /** Log file path */
+  logPath: string;
+  /** PID file path */
+  pidPath: string;
+  /** UI assets directory (null for embedded UI, undefined if not set) */
+  uiDir?: string | null;
+  /** Workspace directory for agent file access (undefined if not set) */
+  workspaceDir?: string | null;
+}
+
+/**
+ * Runtime configuration for the gateway
+ */
+export interface GatewayConfig {
+  /** Host to bind the gateway server */
+  host: string;
+  /** Port for the gateway HTTP server */
+  port: number;
+  /** Port for the UI server (if separate) */
+  uiPort?: number;
+  /** WebSocket port for real-time connections */
+  wsPort: number;
+  /** Public URL for external access */
+  publicUrl?: string;
+  /** Whether to open browser on start */
+  openBrowser: boolean;
+  /** Whether to run as daemon */
+  daemon: boolean;
+}
+
+/**
+ * Complete installation configuration
+ */
+export interface InstallationConfig {
+  /** Installation type */
+  type: InstallationType;
+  /** Gateway runtime configuration */
+  gateway: GatewayConfig;
+  /** File paths */
+  paths: InstallationPaths;
+  /** Environment variables */
+  env: Record<string, string>;
+  /** Whether this is a development installation */
+  isDev: boolean;
+  /** Whether UI is embedded in binary */
+  hasEmbeddedUI: boolean;
+}
+
+/**
+ * Installation adapter interface
+ * 
+ * Each installation method implements this interface to provide
+ * a consistent API for the gateway and CLI commands.
+ */
+export interface InstallationAdapter {
+  /**
+   * Installation type identifier
+   */
+  readonly type: InstallationType;
+
+  /**
+   * Human-readable name for this installation method
+   */
+  readonly name: string;
+
+  /**
+   * Detect if this installation method is available
+   * @returns true if this method can be used in the current environment
+   */
+  detect(): Promise<boolean>;
+
+  /**
+   * Get the installation configuration
+   * @returns Configuration object with paths, ports, and settings
+   */
+  getConfig(): Promise<InstallationConfig>;
+
+  /**
+   * Start the Hive gateway using this installation method
+   * @param config Gateway configuration
+   */
+  start(config: GatewayConfig): Promise<void>;
+
+  /**
+   * Stop the Hive gateway
+   */
+  stop(): Promise<void>;
+
+  /**
+   * Check if the gateway is currently running
+   * @returns true if gateway is running
+   */
+  isRunning(): Promise<boolean>;
+
+  /**
+   * Get the process ID of the running gateway
+   * @returns PID or null if not running
+   */
+  getPid(): Promise<number | null>;
+
+  /**
+   * Get installation-specific environment variables
+   * @returns Environment variables object
+   */
+  getEnvironment(): Promise<Record<string, string>>;
+
+  /**
+   * Validate the installation
+   * @returns Validation result with any errors or warnings
+   */
+  validate(): Promise<ValidationResult>;
+}
+
+/**
+ * Validation result for installation health checks
+ */
+export interface ValidationResult {
+  /** Whether validation passed */
+  valid: boolean;
+  /** List of validation errors */
+  errors: string[];
+  /** List of validation warnings */
+  warnings: string[];
+  /** List of validation info messages */
+  info: string[];
+}
+
+/**
+ * Adapter factory options
+ */
+export interface AdapterOptions {
+  /** Force a specific adapter type (skip auto-detection) */
+  forceType?: InstallationType;
+  /** Enable verbose logging */
+  verbose?: boolean;
+  /** Custom Hive home directory */
+  hiveDir?: string;
+}
+
+/**
+ * Schema for gateway configuration validation
+ */
+export const gatewayConfigSchema = z.object({
+  host: z.string().optional().default("127.0.0.1"),
+  port: z.number().int().min(1).max(65535).default(18790),
+  uiPort: z.number().int().min(1).max(65535).optional(),
+  wsPort: z.number().int().min(1).max(65535).default(18790),
+  publicUrl: z.string().url().optional(),
+  openBrowser: z.boolean().default(true),
+  daemon: z.boolean().default(false),
+});
+
+/**
+ * Schema for installation paths validation
+ */
+export const installationPathsSchema = z.object({
+  hiveDir: z.string(),
+  dbPath: z.string(),
+  logPath: z.string(),
+  pidPath: z.string(),
+  uiDir: z.string().nullable().optional(),
+  workspaceDir: z.string().nullable().optional(),
+});
+
+/**
+ * Schema for complete installation configuration validation
+ */
+export const installationConfigSchema = z.object({
+  type: z.enum(["docker", "bun-global", "binary"]),
+  gateway: gatewayConfigSchema,
+  paths: installationPathsSchema,
+  env: z.record(z.string(), z.string()),
+  isDev: z.boolean(),
+  hasEmbeddedUI: z.boolean(),
+});
+
+/**
+ * Default gateway configuration
+ */
+export const DEFAULT_GATEWAY_CONFIG: GatewayConfig = {
+  host: "127.0.0.1",
+  port: 18790,
+  wsPort: 18790,
+  openBrowser: true,
+  daemon: false,
+};
+
+/**
+ * Common ports used by Hive
+ */
+export const PORTS = {
+  GATEWAY: 18790,
+  VITE_DEV: 5173,
+} as const;

package/packages/cli/src/commands/agent-run.ts

@@ -0,0 +1,168 @@
+import * as p from "@clack/prompts";
+import { loadConfig } from "@johpaz/hive-agents-core/config/loader";
+
+function getGatewayUrl(config: any): string {
+  const gateway = config?.gateway;
+  const host = gateway?.host ?? "localhost";
+  const port = gateway?.port ?? 3000;
+  return `http://${host}:${port}`;
+}
+
+export async function agent(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "run":
+      await agentRun(args);
+      break;
+    default:
+      console.log(`
+Usage: hive agent <command>
+
+Commands:
+  run --message <text>     Ejecutar agente con mensaje
+  run --thinking <level>   Nivel de razonamiento (low/medium/high)
+  run --wait               Esperar respuesta completa
+`);
+  }
+}
+
+async function agentRun(args: string[]): Promise<void> {
+  const messageIndex = args.indexOf("--message");
+  const thinkingIndex = args.indexOf("--thinking");
+  const toolsIndex = args.indexOf("--tools");
+  const agentIndex = args.indexOf("--agent");
+  const waitIndex = args.indexOf("--wait");
+
+  if (messageIndex === -1) {
+    const msg = await p.text({
+      message: "Mensaje para el agente:",
+      placeholder: "Analiza el archivo README.md",
+      validate: (v) => (!v ? "El mensaje es requerido" : undefined),
+    });
+
+    if (p.isCancel(msg)) {
+      p.cancel("Cancelado");
+      return;
+    }
+
+    args.push("--message", msg as string);
+    return agentRun(args);
+  }
+
+  const message = args[messageIndex + 1];
+  const thinking = thinkingIndex !== -1 ? args[thinkingIndex + 1] : "medium";
+  const tools = toolsIndex !== -1 ? args[toolsIndex + 1] : "all";
+  const agentId = agentIndex !== -1 ? args[agentIndex + 1] : "main";
+  const wait = waitIndex !== -1;
+
+  if (!message) {
+    console.log("❌ Mensaje requerido");
+    return;
+  }
+
+  const config = loadConfig();
+  const gatewayUrl = getGatewayUrl(config);
+
+  const spinner = p.spinner();
+  spinner.start("Conectando con el agente...");
+
+  try {
+    if (wait) {
+      await executeWithStream(gatewayUrl, { message, thinking, tools, agentId }, spinner);
+    } else {
+      await executeAsync(gatewayUrl, { message, thinking, tools, agentId }, spinner);
+    }
+  } catch (error) {
+    spinner.stop("Error");
+    console.log(`❌ ${(error as Error).message}`);
+    console.log("   ¿Está corriendo el Gateway? Ejecuta: hive start");
+  }
+}
+
+async function executeWithStream(
+  gatewayUrl: string,
+  payload: { message: string; thinking: string; tools: string; agentId: string },
+  spinner: ReturnType<typeof p.spinner>
+): Promise<void> {
+  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...payload, stream: true }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Error: ${response.statusText}`);
+  }
+
+  spinner.stop("Conectado");
+
+  const reader = response.body?.getReader();
+  if (!reader) {
+    throw new Error("No se pudo obtener el stream");
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let thinking = true;
+
+  process.stdout.write("\n");
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+
+    for (const line of lines) {
+      if (!line.trim() || !line.startsWith("data: ")) continue;
+
+      try {
+        const data = JSON.parse(line.slice(6));
+
+        if (data.type === "thinking" && thinking) {
+          process.stdout.write(".");
+        } else if (data.type === "response") {
+          if (thinking) {
+            process.stdout.write("\n\n");
+            thinking = false;
+          }
+          process.stdout.write(data.content ?? "");
+        } else if (data.type === "tool_call") {
+          process.stdout.write(`\n[Tool: ${data.toolName}]`);
+        } else if (data.type === "complete") {
+          process.stdout.write("\n\n");
+        }
+      } catch {
+        // Ignore parse errors
+      }
+    }
+  }
+}
+
+async function executeAsync(
+  gatewayUrl: string,
+  payload: { message: string; thinking: string; tools: string; agentId: string },
+  spinner: ReturnType<typeof p.spinner>
+): Promise<void> {
+  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...payload, stream: false }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Error: ${response.statusText}`);
+  }
+
+  const result = await response.json() as { taskId?: string; success: boolean };
+
+  spinner.stop("Enviado");
+
+  if (result.taskId) {
+    console.log(`✓ Tarea enviada: ${result.taskId}`);
+    console.log("  Usa `hive tasks list` para ver el estado");
+  } else {
+    console.log("✓ Tarea enviada");
+  }
+}