@johpaz/hive 1.7.2 → 1.7.3

package/packages/hive-ui/src/pages/WebChatPage.tsx

@@ -1,15 +0,0 @@
-import { ChatContainer } from "@/modules/chat/ChatContainer";
-import { useUserStore } from "@/stores/userStore";
-
-export function WebChatPage() {
-  const { currentUser } = useUserStore();
-  const activeSession = currentUser?.id || "default";
-
-  return (
-    <div className="h-full bg-zinc-950 overflow-hidden mt-10">
-      <div className="max-w-4xl mx-auto h-full flex flex-col border-x border-white/5">
-        <ChatContainer agentId="main" sessionId={activeSession} />
-      </div>
-    </div>
-  );
-}

package/packages/hive-ui/src/stores/agentConfigStore.ts

@@ -1,32 +0,0 @@
-import { create } from "zustand";
-import type { ConfigSnapshot, SaveStatus, ConfigSection, ConfigValidationError } from "@/types";
-
-interface AgentConfigState {
-  activeAgentId: string | null;
-  activeSection: ConfigSection;
-  saveStatus: SaveStatus;
-  snapshots: ConfigSnapshot[];
-  validationErrors: ConfigValidationError[];
-  unsavedChanges: boolean;
-  setActiveAgent: (id: string | null) => void;
-  setActiveSection: (section: ConfigSection) => void;
-  setSaveStatus: (status: SaveStatus) => void;
-  addSnapshot: (snapshot: ConfigSnapshot) => void;
-  setValidationErrors: (errors: ConfigValidationError[]) => void;
-  setUnsavedChanges: (val: boolean) => void;
-}
-
-export const useAgentConfigStore = create<AgentConfigState>((set) => ({
-  activeAgentId: null,
-  activeSection: "ethics",
-  saveStatus: "saved",
-  snapshots: [],
-  validationErrors: [],
-  unsavedChanges: false,
-  setActiveAgent: (id) => set({ activeAgentId: id }),
-  setActiveSection: (section) => set({ activeSection: section }),
-  setSaveStatus: (status) => set({ saveStatus: status }),
-  addSnapshot: (snapshot) => set((s) => ({ snapshots: [...s.snapshots, snapshot] })),
-  setValidationErrors: (errors) => set({ validationErrors: errors }),
-  setUnsavedChanges: (val) => set({ unsavedChanges: val }),
-}));

package/packages/hive-ui/src/stores/agentStore.ts

@@ -1,5 +0,0 @@
-// Re-export from global config store for backwards compatibility
-export { 
-  useAgents, 
-  useAgents as useAgentStore,  // Alias para compatibilidad
-} from "@/stores/useGlobalConfigStore";

package/packages/hive-ui/src/stores/bridgeStore.ts

@@ -1,237 +0,0 @@
-import { create } from "zustand";
-import type { BridgeProcess, BridgeLog } from "@/types";
-
-const CODE_BRIDGE_URL = "ws://localhost:18791/ws";
-const API_URL = import.meta.env.VITE_API_URL || "http://localhost:18790";
-const GATEWAY_WS_URL = API_URL.replace(/^http/, "ws");
-const GATEWAY_BRIDGE_URL = `${GATEWAY_WS_URL}/bridge-events`;
-
-function generateId(): string {
-  return Math.random().toString(36).substring(2, 15);
-}
-
-function createLog(level: BridgeLog["level"], message: string, processId: string = "system"): BridgeLog {
-  return {
-    id: generateId(),
-    processId,
-    level,
-    message,
-    timestamp: new Date().toISOString(),
-  };
-}
-
-interface BridgeState {
-  processes: BridgeProcess[];
-  logs: BridgeLog[];
-  isConnected: boolean;
-  socket: WebSocket | null;
-  gatewaySocket: WebSocket | null;
-  addProcess: (process: BridgeProcess) => void;
-  removeProcess: (id: string) => void;
-  updateProcess: (id: string, updates: Partial<BridgeProcess>) => void;
-  addLog: (log: BridgeLog) => void;
-  clearLogs: () => void;
-  connect: () => void;
-  disconnect: () => void;
-  sendCommand: (cmd: { cmd: string; [key: string]: unknown }) => void;
-  connectGateway: () => void;
-}
-
-export const useBridgeStore = create<BridgeState>((set, get) => ({
-  processes: [],
-  logs: [],
-  isConnected: false,
-  socket: null,
-  gatewaySocket: null,
-
-  addProcess: (process) => set((s) => ({ processes: [...s.processes, process] })),
-  removeProcess: (id) => set((s) => ({ processes: s.processes.filter((p) => p.id !== id) })),
-  updateProcess: (id, updates) =>
-    set((s) => ({
-      processes: s.processes.map((p) => (p.id === id ? { ...p, ...updates } : p)),
-    })),
-  addLog: (log) => set((s) => ({ logs: [log, ...s.logs].slice(0, 500) })),
-  clearLogs: () => set({ logs: [] }),
-
-  sendCommand: (cmd) => {
-    const { socket, isConnected } = get();
-    if (socket && isConnected) {
-      socket.send(JSON.stringify(cmd));
-    }
-  },
-
-  // Connect to the Code Bridge service (port 18791)
-  connect: () => {
-    const { socket: existingSocket, isConnected } = get();
-    if (existingSocket || isConnected) return;
-
-    try {
-      const ws = new WebSocket(CODE_BRIDGE_URL);
-
-      ws.onopen = () => {
-        set({ isConnected: true, socket: ws });
-        get().addLog(createLog("info", "Connected to Code Bridge"));
-        get().sendCommand({ cmd: "status" });
-      };
-
-      ws.onmessage = (event) => {
-        try {
-          const data = JSON.parse(event.data);
-
-          if (data.type === "code-bridge:status" && Array.isArray(data.agents)) {
-            const processes: BridgeProcess[] = data.agents.map((agent: { taskId: string; role: string; cli: string; pid: number; state: string }) => ({
-              id: agent.taskId,
-              name: agent.role,
-              command: agent.cli,
-              status: agent.state as BridgeProcess["status"],
-              pid: agent.pid,
-              startedAt: new Date().toISOString(),
-              output: [],
-            }));
-            set({ processes });
-          }
-
-          if (data.type === "agent:started") {
-            const newProcess: BridgeProcess = {
-              id: data.taskId,
-              name: data.role,
-              command: data.cli,
-              status: "running",
-              pid: data.pid,
-              startedAt: new Date().toISOString(),
-              output: [],
-            };
-            get().addProcess(newProcess);
-            get().addLog(createLog("info", `Agent started: ${data.role} (PID: ${data.pid})`, data.taskId));
-          }
-
-          if (data.type === "agent:output") {
-            const process = get().processes.find((p) => p.id === data.taskId);
-            if (process) {
-              get().updateProcess(data.taskId, { output: [...process.output, data.chunk] });
-            }
-          }
-
-          if (data.type === "agent:finished") {
-            get().updateProcess(data.taskId, { status: "completed" });
-            get().addLog(createLog("info", `Agent finished: ${data.role}`, data.taskId));
-          }
-
-          if (data.type === "agent:error") {
-            get().updateProcess(data.taskId, { status: "error" });
-            get().addLog(createLog("error", data.message, data.taskId));
-          }
-
-          if (data.type === "agent:cancelled") {
-            get().updateProcess(data.taskId, { status: "stopped" });
-            get().addLog(createLog("warn", `Agent cancelled: ${data.role}`, data.taskId));
-          }
-        } catch {
-          // Ignore non-JSON messages
-        }
-      };
-
-      ws.onerror = () => {
-        get().addLog(createLog("error", "Code Bridge WebSocket error"));
-      };
-
-      ws.onclose = () => {
-        set({ isConnected: false, socket: null });
-        get().addLog(createLog("info", "Disconnected from Code Bridge"));
-        setTimeout(() => {
-          if (!get().isConnected) get().connect();
-        }, 5000);
-      };
-
-      set({ socket: ws });
-    } catch {
-      set({ isConnected: false, socket: null });
-    }
-  },
-
-  // Connect to the gateway's /bridge-events endpoint to receive terminal events
-  connectGateway: () => {
-    const { gatewaySocket } = get();
-    if (gatewaySocket) return;
-
-    try {
-      const ws = new WebSocket(GATEWAY_BRIDGE_URL);
-
-      ws.onopen = () => {
-        get().addLog(createLog("info", "Connected to gateway bridge events"));
-      };
-
-      ws.onmessage = (event) => {
-        try {
-          const evt = JSON.parse(event.data);
-
-          if (evt.type === "bridge:cmd_start") {
-            const d = evt.data as { processId: string; command: string; cwd?: string; name?: string };
-            const newProcess: BridgeProcess = {
-              id: d.processId,
-              name: d.name ?? "terminal",
-              command: d.command,
-              status: "running",
-              pid: 0,
-              startedAt: new Date().toISOString(),
-              output: [],
-            };
-            get().addProcess(newProcess);
-            get().addLog(createLog("info", `$ ${d.command}${d.cwd ? ` (in ${d.cwd})` : ""}`, d.processId));
-          }
-
-          if (evt.type === "bridge:cmd_output") {
-            const d = evt.data as { processId: string; chunk: string; stream: string };
-            const process = get().processes.find((p) => p.id === d.processId);
-            if (process) {
-              get().updateProcess(d.processId, { output: [...process.output, d.chunk] });
-            }
-            get().addLog(createLog(d.stream === "stderr" ? "warn" : "info", d.chunk, d.processId));
-          }
-
-          if (evt.type === "bridge:cmd_done") {
-            const d = evt.data as { processId: string; exitCode: number; success: boolean };
-            get().updateProcess(d.processId, { status: d.success ? "completed" : "error" });
-            get().addLog(createLog(d.success ? "info" : "error", `Exit code: ${d.exitCode}`, d.processId));
-          }
-
-          if (evt.type === "bridge:cmd_error") {
-            const d = evt.data as { processId: string; message: string };
-            get().updateProcess(d.processId, { status: "error" });
-            get().addLog(createLog("error", d.message, d.processId));
-          }
-        } catch {
-          // Ignore non-JSON
-        }
-      };
-
-      ws.onerror = () => {
-        // Gateway may not be available immediately
-      };
-
-      ws.onclose = () => {
-        set({ gatewaySocket: null });
-        // Reconnect after 5 seconds
-        setTimeout(() => {
-          if (!get().gatewaySocket) get().connectGateway();
-        }, 5000);
-      };
-
-      set({ gatewaySocket: ws });
-    } catch {
-      set({ gatewaySocket: null });
-    }
-  },
-
-  disconnect: () => {
-    const { socket, gatewaySocket } = get();
-    if (socket) {
-      socket.close();
-      set({ socket: null, isConnected: false });
-    }
-    if (gatewaySocket) {
-      gatewaySocket.close();
-      set({ gatewaySocket: null });
-    }
-  },
-}));

package/packages/hive-ui/src/stores/canvasStore.ts

@@ -1,250 +0,0 @@
-import { create } from "zustand";
-import type { CanvasComponent } from "@/types/canvas";
-
-export interface GraphNode {
-  id: string;
-  name: string;
-  type: "agent" | "mcp" | "project" | "task";
-  status: string;
-  data?: Record<string, unknown>;
-}
-
-export interface GraphEdge {
-  id: string;
-  source: string;
-  target: string;
-  edgeType: string;
-}
-
-interface GatewayMessage {
-  type: string;
-  sessionId?: string;
-  component?: CanvasComponent;
-  componentId?: string;
-  data?: {
-    nodes?: GraphNode[];
-    edges?: GraphEdge[];
-    id?: string;
-    [key: string]: unknown;
-  };
-}
-
-interface CanvasState {
-  ws: WebSocket | null;
-  components: CanvasComponent[];
-  selectedComponentId: string | null;
-  sessionId: string | null;
-  isConnected: boolean;
-  graphNodes: GraphNode[];
-  graphEdges: GraphEdge[];
-
-  // Actions
-  setComponents: (components: CanvasComponent[]) => void;
-  addComponent: (component: CanvasComponent) => void;
-  removeComponent: (id: string) => void;
-  selectComponent: (id: string | null) => void;
-  setSessionId: (id: string | null) => void;
-  setIsConnected: (connected: boolean) => void;
-  setGraphSnapshot: (nodes: GraphNode[], edges: GraphEdge[]) => void;
-  addGraphNode: (node: GraphNode) => void;
-  updateGraphNode: (id: string, updates: Partial<GraphNode>) => void;
-  removeGraphNode: (id: string) => void;
-  addGraphEdge: (edge: GraphEdge) => void;
-
-  // Connection management
-  connect: (sessionId: string, userId?: string | null) => void;
-  disconnect: () => void;
-  sendMessage: (message: any) => void;
-}
-
-let heartbeatInterval: ReturnType<typeof setInterval> | null = null;
-
-export const useCanvasStore = create<CanvasState>((set, get) => ({
-  ws: null,
-  components: [],
-  selectedComponentId: null,
-  sessionId: null,
-  isConnected: false,
-  graphNodes: [],
-  graphEdges: [],
-
-  setComponents: (components) => set({ components }),
-  addComponent: (component) => set((s) => ({ components: [...s.components, component] })),
-  removeComponent: (id) => set((s) => ({ components: s.components.filter((c) => c.id !== id) })),
-  selectComponent: (id) => set({ selectedComponentId: id }),
-  setSessionId: (id) => set({ sessionId: id }),
-  setIsConnected: (connected) => set({ isConnected: connected }),
-  setGraphSnapshot: (nodes, edges) => set({ graphNodes: nodes, graphEdges: edges }),
-
-  addGraphNode: (node) =>
-    set((s) => {
-      const existing = s.graphNodes.find((n) => n.id === node.id);
-      if (existing) {
-        return { graphNodes: s.graphNodes.map((n) => (n.id === node.id ? node : n)) };
-      }
-      return { graphNodes: [...s.graphNodes, node] };
-    }),
-
-  updateGraphNode: (id, updates) =>
-    set((s) => ({
-      graphNodes: s.graphNodes.map((n) => (n.id === id ? { ...n, ...updates } : n)),
-    })),
-
-  removeGraphNode: (id) =>
-    set((s) => ({
-      graphNodes: s.graphNodes.filter((n) => n.id !== id),
-      graphEdges: s.graphEdges.filter((e) => e.source !== id && e.target !== id),
-    })),
-
-  addGraphEdge: (edge) =>
-    set((s) => {
-      const existing = s.graphEdges.find((e) => e.id === edge.id);
-      if (existing) return s;
-      return { graphEdges: [...s.graphEdges, edge] };
-    }),
-
-  connect: (sessionId, userId) => {
-    const currentState = get();
-
-    // Si ya está conectado a la misma sesión, no hacer nada
-    if (currentState.ws && currentState.sessionId === sessionId && currentState.ws.readyState === WebSocket.OPEN) {
-      console.log(`[CanvasStore] Already connected to session: ${sessionId}`);
-      return;
-    }
-
-    // Si hay una conexión previa diferente, cerrarla
-    if (currentState.ws) {
-      console.log(`[CanvasStore] Closing previous connection for session: ${currentState.sessionId}`);
-      currentState.disconnect();
-    }
-
-    const API_URL = import.meta.env.VITE_API_URL || "http://localhost:18790";
-    const GATEWAY_WS_URL = API_URL.replace(/^http/, "ws");
-    const wsUrl = `${GATEWAY_WS_URL}/canvas?sessionId=${encodeURIComponent(sessionId)}`;
-
-    console.log(`[CanvasStore] Connecting to ${wsUrl}`);
-    const socket = new WebSocket(wsUrl);
-
-    socket.onopen = () => {
-      console.log(`[CanvasStore] Connected with sessionId: ${sessionId}`);
-      set({ isConnected: true, sessionId, ws: socket });
-
-      // Handshake
-      socket.send(JSON.stringify({
-        type: "canvas:handshake",
-        sessionId,
-        userId: userId || null,
-        client: "hive-ui",
-        version: "1.0"
-      }));
-
-      // Heartbeat every 30s
-      if (heartbeatInterval) clearInterval(heartbeatInterval);
-      heartbeatInterval = setInterval(() => {
-        if (socket.readyState === WebSocket.OPEN) {
-          socket.send(JSON.stringify({ type: "canvas:ping", sessionId }));
-        }
-      }, 30000);
-    };
-
-    socket.onmessage = (event) => {
-      try {
-        const message = JSON.parse(event.data) as GatewayMessage;
-
-        if (message.type === "canvas:pong") return;
-
-        if (message.type === "canvas:render" || message.type === "canvas:update") {
-          // emitCanvas wraps payload in { type, data, timestamp } — component lives in data
-          const component = (message.data?.component ?? message.component) as CanvasComponent | undefined;
-          if (component) {
-            set((s) => {
-              const existing = s.components.find((c) => c.id === component.id);
-              if (existing) {
-                return { components: s.components.map(c => c.id === component.id ? component : c) };
-              }
-              return { components: [...s.components, component] };
-            });
-          }
-        } else if (message.type === "canvas:clear") {
-          set({ components: [] });
-        } else if (message.type === "canvas:snapshot") {
-          const d = message.data;
-          if (d && Array.isArray(d.nodes) && Array.isArray(d.edges)) {
-            set({ graphNodes: d.nodes as GraphNode[], graphEdges: d.edges as GraphEdge[] });
-          }
-        } else if (message.type === "canvas:node_add") {
-          const raw = message.data as Record<string, unknown>;
-          if (raw?.id) {
-            const subData = (raw.data as Record<string, unknown>) ?? {};
-            const node: GraphNode = {
-              id: raw.id as string,
-              type: raw.type as GraphNode["type"],
-              name: (raw.label ?? raw.name ?? raw.id) as string,
-              status: (subData.status ?? raw.status ?? "pending") as string,
-              data: subData,
-            };
-            get().addGraphNode(node);
-          }
-        } else if (message.type === "canvas:node_update") {
-          const d = message.data as Record<string, unknown>;
-          const nodeId = (d?.id ?? d?.nodeId) as string;
-          if (nodeId) {
-            const subData = (d.data ?? d.changes) as Record<string, unknown> ?? {};
-            const updates: Partial<GraphNode> = {};
-            if (subData.status) updates.status = subData.status as string;
-            // Merge existing data with new data/changes
-            updates.data = subData;
-            get().updateGraphNode(nodeId, updates);
-          }
-        } else if (message.type === "canvas:node_remove") {
-          const d = message.data;
-          if (d?.id) get().removeGraphNode(d.id as string);
-        } else if (message.type === "canvas:edge_add") {
-          const edge = message.data as unknown as GraphEdge;
-          if (edge?.id) get().addGraphEdge(edge);
-        }
-      } catch (e) {
-        console.error("[CanvasStore] Parse error:", e);
-      }
-    };
-
-    socket.onerror = (error) => {
-      console.error("[CanvasStore] WebSocket error:", error);
-      set({ isConnected: false });
-    };
-
-    socket.onclose = (event) => {
-      console.log("[CanvasStore] Disconnected:", event.code, event.reason);
-      set({ isConnected: false, ws: null });
-
-      if (heartbeatInterval) {
-        clearInterval(heartbeatInterval);
-        heartbeatInterval = null;
-      }
-
-      // Auto-reconnect after 3 seconds if not intentionally closed
-      if (event.code !== 1000 && event.code !== 1001) {
-        setTimeout(() => get().connect(sessionId, userId), 3000);
-      }
-    };
-  },
-
-  disconnect: () => {
-    const { ws } = get();
-    if (ws) {
-      ws.close(1000, "Intentional disconnect");
-      set({ ws: null, isConnected: false });
-    }
-    if (heartbeatInterval) {
-      clearInterval(heartbeatInterval);
-      heartbeatInterval = null;
-    }
-  },
-
-  sendMessage: (message) => {
-    const { ws, isConnected } = get();
-    if (ws && isConnected && ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify(message));
-    }
-  }
-}));

package/packages/hive-ui/src/stores/channelStore.ts

@@ -1,5 +0,0 @@
-// Re-export from global config store for backwards compatibility
-export { 
-  useChannels, 
-  useChannels as useChannelStore,  // Alias para compatibilidad
-} from "@/stores/useGlobalConfigStore";

package/packages/hive-ui/src/stores/chatStore.ts

@@ -1,42 +0,0 @@
-import { create } from "zustand";
-import type { Message } from "@/types";
-
-interface ChatState {
-  messages: Message[];
-  isLoading: boolean;
-  currentSteps: string[];
-  addMessage: (message: Message) => void;
-  addMessages: (messages: Message[]) => void;
-  updateMessage: (id: string, updates: Partial<Message>) => void;
-  setMessages: (messages: Message[]) => void;
-  clearMessages: () => void;
-  setLoading: (loading: boolean) => void;
-  addStep: (step: string) => void;
-  clearSteps: () => void;
-}
-
-export const useChatStore = create<ChatState>((set) => ({
-  messages: [],
-  isLoading: false,
-  currentSteps: [],
-  addMessage: (message) =>
-    set((state) => ({
-      messages: [...state.messages, message],
-    })),
-  addMessages: (messages) =>
-    set((state) => ({
-      messages: [...state.messages, ...messages],
-    })),
-  updateMessage: (id, updates) =>
-    set((state) => ({
-      messages: state.messages.map((m) => (m.id === id ? { ...m, ...updates } : m)),
-    })),
-  setMessages: (messages) => set({ messages }),
-  clearMessages: () => set({ messages: [] }),
-  setLoading: (loading) => set({ isLoading: loading }),
-  addStep: (step) =>
-    set((state) => ({
-      currentSteps: [...state.currentSteps.slice(-4), step], // keep last 5
-    })),
-  clearSteps: () => set({ currentSteps: [] }),
-}));