@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,21 +0,0 @@
-import { create } from "zustand";
-
-interface LoaderState {
-    isLoading: boolean;
-    message?: string;
-    showLoader: (message?: string) => void;
-    hideLoader: () => void;
-}
-
-export const useLoaderStore = create<LoaderState>((set) => ({
-    isLoading: false,
-    message: undefined,
-    showLoader: (message) => set({ isLoading: true, message }),
-    hideLoader: () => set({ isLoading: false, message: undefined }),
-}));
-
-// Helper for non-react usage if needed (e.g. in utils)
-export const loader = {
-    show: (message?: string) => useLoaderStore.getState().showLoader(message),
-    hide: () => useLoaderStore.getState().hideLoader(),
-};

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

@@ -1,144 +0,0 @@
-import { create } from 'zustand';
-import { apiClient } from '../lib/api';
-import type { Note, CronJob, CronChannel } from '../types/notes-crons';
-
-interface CronChannelsResponse {
-    channels: CronChannel[];
-    recommended: string;
-    userPreference: string;
-}
-
-interface NotesAndCronsState {
-    notes: Note[];
-    cronJobs: CronJob[];
-    cronChannels: CronChannel[];
-    cronRecommended: string;
-    cronUserPreference: string;
-    isLoading: boolean;
-    error: string | null;
-    fetchNotes: () => Promise<void>;
-    fetchCronJobs: () => Promise<void>;
-    fetchCronChannels: () => Promise<void>;
-    toggleNoteActive: (id: string, active: boolean) => Promise<void>;
-    toggleCronJobActive: (id: string, enabled: boolean) => Promise<void>;
-    saveCronChannelPreference: (channelId: string) => Promise<void>;
-}
-
-export const useNotesAndCronsStore = create<NotesAndCronsState>((set) => ({
-    notes: [],
-    cronJobs: [],
-    cronChannels: [],
-    cronRecommended: 'webchat',
-    cronUserPreference: 'auto',
-    isLoading: false,
-    error: null,
-
-    fetchNotes: async () => {
-        set({ isLoading: true, error: null });
-        try {
-            const data = await apiClient<{ notes: Note[] }>('/api/notes');
-            set({ notes: data.notes, isLoading: false });
-        } catch (err) {
-            set({ error: (err as Error).message, isLoading: false });
-        }
-    },
-
-    fetchCronJobs: async () => {
-        set({ isLoading: true, error: null });
-        try {
-            const data = await apiClient<{ cronJobs: CronJob[] } | CronJob[]>('/api/cron-jobs');
-            console.log("[CronStore] fetchCronJobs - API Response:", data);
-            let jobs: CronJob[] = [];
-            if (Array.isArray(data)) {
-                jobs = data;
-                console.log("[CronStore] Response es array directo:", jobs.length, "jobs");
-            } else if ('cronJobs' in data) {
-                jobs = (data as { cronJobs: CronJob[] }).cronJobs;
-                console.log("[CronStore] Response tiene propiedad 'cronJobs':", jobs.length, "jobs");
-            } else if ('jobs' in data) {
-                jobs = (data as any).jobs;
-                console.log("[CronStore] Response tiene propiedad 'jobs':", jobs.length, "jobs");
-            } else {
-                console.warn("[CronStore] Formato de respuesta desconocido:", data);
-            }
-            set({ cronJobs: jobs, isLoading: false });
-        } catch (err) {
-            console.error("[CronStore] Error en fetchCronJobs:", err);
-            set({ error: (err as Error).message, isLoading: false, cronJobs: [] });
-        }
-    },
-
-    fetchCronChannels: async () => {
-        try {
-            const data = await apiClient<{ channels: string[] | CronChannel[] }>('/api/cron-jobs/channels');
-            console.log("[CronStore] fetchCronChannels - API Response:", data);
-            
-            // El backend retorna array de strings o array de objetos CronChannel
-            let channels: CronChannel[] = [];
-            if (Array.isArray(data.channels)) {
-                channels = data.channels.map(ch => {
-                    if (typeof ch === 'string') {
-                        // Convertir string a objeto CronChannel
-                        return {
-                            id: ch,
-                            type: ch,
-                            active: true,
-                            recommended: ch === 'webchat' || ch === 'telegram',
-                        } as CronChannel;
-                    }
-                    return ch as CronChannel;
-                });
-                console.log("[CronStore] CronChannels convertidos:", channels.length, "canales");
-            }
-            
-            set({
-                cronChannels: channels,
-                cronRecommended: 'webchat',
-                cronUserPreference: 'auto',
-            });
-        } catch (err) {
-            console.error("[CronStore] Error en fetchCronChannels:", err);
-            set({ error: (err as Error).message });
-        }
-    },
-
-    toggleNoteActive: async (id: string, active: boolean) => {
-        try {
-            await apiClient(`/api/notes/${id}/toggle`, {
-                method: 'PATCH',
-                body: { active: active ? 1 : 0 }
-            });
-            set((state) => ({
-                notes: state.notes.map((n) => (n.id === id ? { ...n, active: active ? 1 : 0 } : n)),
-            }));
-        } catch (err) {
-            set({ error: (err as Error).message });
-        }
-    },
-
-    toggleCronJobActive: async (id: string, enabled: boolean) => {
-        try {
-            await apiClient(`/api/cron-jobs/${id}/toggle`, {
-                method: 'PATCH',
-                body: { enabled: enabled ? 1 : 0 }
-            });
-            set((state) => ({
-                cronJobs: state.cronJobs.map((j) => (j.id === id ? { ...j, enabled: enabled ? 1 : 0 } : j)),
-            }));
-        } catch (err) {
-            set({ error: (err as Error).message });
-        }
-    },
-
-    saveCronChannelPreference: async (channelId: string) => {
-        try {
-            await apiClient('/api/user/settings', {
-                method: 'PATCH',
-                body: { preferred_cron_channel: channelId },
-            });
-            set({ cronUserPreference: channelId });
-        } catch (err) {
-            set({ error: (err as Error).message });
-        }
-    },
-}));

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

@@ -1,152 +0,0 @@
-import { create } from "zustand";
-import type { WebSocketStatus } from "@/types";
-import { useWelcomeStore, type WelcomeData } from "./useWelcomeStore";
-
-interface WebSocketMessage {
-    type: string;
-    [key: string]: any;
-}
-
-type MessageHandler = (data: any) => void;
-
-interface WebSocketStore {
-    ws: WebSocket | null;
-    status: WebSocketStatus;
-    url: string;
-    lastPing: string | null;
-    retryCount: number;
-    handlers: Map<string, Set<MessageHandler>>;
-    sessionId: string | null;
-
-    // Actions
-    connect: (sessionId?: string) => void;
-    disconnect: () => void;
-    send: (message: any) => void;
-    subscribe: (type: string, handler: MessageHandler) => () => void;
-    setStatus: (status: WebSocketStatus) => void;
-    setLastPing: (ping: string) => void;
-    setSessionId: (sessionId: string) => void;
-}
-
-export const useWebSocketStore = create<WebSocketStore>((set, get) => {
-    let reconnectTimeout: ReturnType<typeof setTimeout> | null = null;
-
-    return {
-        ws: null,
-        status: "disconnected",
-        url: import.meta.env.VITE_WS_URL ||
-            (import.meta.env.VITE_API_URL || "http://localhost:18790").replace(/^http/, "ws") + "/ws",
-        lastPing: null,
-        retryCount: 0,
-        handlers: new Map(),
-        sessionId: null,
-
-        setStatus: (status) => set({ status }),
-        setLastPing: (ping) => set({ lastPing: ping }),
-        setSessionId: (sessionId) => set({ sessionId }),
-
-        connect: (sessionId?: string) => {
-            const state = get();
-            if (state.ws) {
-                state.ws.close();
-            }
-            if (reconnectTimeout) {
-                clearTimeout(reconnectTimeout);
-            }
-
-            let wsUrl = state.url;
-            if (sessionId) {
-                const urlObj = new URL(wsUrl);
-                urlObj.searchParams.set("session", sessionId);
-                wsUrl = urlObj.toString();
-            }
-
-            set({ status: "connecting" });
-
-            try {
-                const ws = new WebSocket(wsUrl);
-
-                ws.onopen = () => {
-                    console.log("[WS-GLOBAL] Connected to", wsUrl);
-                    set({ status: "connected", retryCount: 0, ws });
-                };
-
-                ws.onclose = (event) => {
-                    console.log("[WS-GLOBAL] Disconnected from", wsUrl, "Code:", event.code);
-                    set({ status: "disconnected", ws: null });
-
-                    // Auto-reconnect after 3 seconds if not intentionally closed
-                    if (event.code !== 1000 && event.code !== 1001) {
-                        reconnectTimeout = setTimeout(() => {
-                            set((s) => ({ retryCount: s.retryCount + 1 }));
-                            get().connect(sessionId);
-                        }, 3000);
-                    }
-                };
-
-                ws.onerror = () => {
-                    console.error("[WS-GLOBAL] Error on", wsUrl);
-                    set({ status: "error" });
-                };
-
-                ws.onmessage = (event) => {
-                    set({ lastPing: new Date().toISOString() });
-                    try {
-                        const data = JSON.parse(event.data);
-                        const type = data.type;
-                        
-                        // Handle welcome message - set sessionId and show welcome dialog
-                        if (type === "welcome" && data.sessionId) {
-                            set({ sessionId: data.sessionId });
-                            useWelcomeStore.getState().show(data as WelcomeData);
-                        }
-                        
-                        const handlers = get().handlers.get(type);
-                        if (handlers) {
-                            handlers.forEach(handler => handler(data));
-                        }
-                    } catch (e) {
-                        // Ignorar mensajes mal formateados
-                    }
-                };
-            } catch (e) {
-                console.error("[WS-GLOBAL] Failed to create WebSocket:", e);
-                set({ status: "error" });
-            }
-        },
-
-        disconnect: () => {
-            const { ws } = get();
-            if (reconnectTimeout) {
-                clearTimeout(reconnectTimeout);
-            }
-            ws?.close();
-            set({ ws: null, status: "disconnected" });
-        },
-
-        send: (message: any) => {
-            const { ws, status } = get();
-            if (ws && status === "connected") {
-                ws.send(JSON.stringify(message));
-            }
-        },
-
-        subscribe: (type: string, handler: MessageHandler) => {
-            const { handlers } = get();
-            if (!handlers.has(type)) {
-                handlers.set(type, new Set());
-            }
-            handlers.get(type)!.add(handler);
-
-            return () => {
-                const h = handlers.get(type);
-                if (h) {
-                    h.delete(handler);
-                    if (h.size === 0) {
-                        handlers.delete(type);
-                    }
-                }
-            };
-        }
-    };
-});

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

@@ -1,37 +0,0 @@
-import { create } from "zustand";
-
-export interface WelcomeData {
-  sessionId: string;
-  user: {
-    id: string;
-    name: string;
-    language: string;
-  } | null;
-  agent: {
-    id: string;
-    name: string;
-    provider: string;
-    model: string;
-  } | null;
-  channels: string[];
-  voice: {
-    enabled: boolean;
-    sttProvider: string | null;
-    ttsProvider: string | null;
-  };
-  codeBridge: string[];
-}
-
-interface WelcomeStore {
-  isOpen: boolean;
-  data: WelcomeData | null;
-  show: (data: WelcomeData) => void;
-  close: () => void;
-}
-
-export const useWelcomeStore = create<WelcomeStore>((set) => ({
-  isOpen: false,
-  data: null,
-  show: (data) => set({ isOpen: true, data }),
-  close: () => set({ isOpen: false, data: null }),
-}));

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

@@ -1,23 +0,0 @@
-import { create } from "zustand";
-import type { UserConfig } from "@/types";
-
-interface UserConfigState {
-  configs: UserConfig[];
-  activeConfigId: string | null;
-  setConfigs: (configs: UserConfig[]) => void;
-  setActiveConfig: (id: string | null) => void;
-  updateConfig: (id: string, updates: Partial<UserConfig>) => void;
-  addConfig: (config: UserConfig) => void;
-  removeConfig: (id: string) => void;
-}
-
-export const useUserConfigStore = create<UserConfigState>((set) => ({
-  configs: [],
-  activeConfigId: null,
-  setConfigs: (configs) => set({ configs }),
-  setActiveConfig: (id) => set({ activeConfigId: id }),
-  updateConfig: (id, updates) =>
-    set((s) => ({ configs: s.configs.map((c) => (c.id === id ? { ...c, ...updates } : c)) })),
-  addConfig: (config) => set((s) => ({ configs: [...s.configs, config] })),
-  removeConfig: (id) => set((s) => ({ configs: s.configs.filter((c) => c.id !== id) })),
-}));

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

@@ -1,82 +0,0 @@
-import { create } from "zustand";
-import { apiClient } from "@/lib/api";
-
-const API_BASE_URL = import.meta.env.VITE_API_URL || "";
-
-interface User {
-    id: string;
-    name: string;
-    language?: string;
-    timezone?: string;
-    occupation?: string;
-    notes?: string;
-    created_at?: number;
-}
-
-interface UserState {
-    isLoading: boolean;
-    currentUser: User | null;
-    error: string | null;
-    setLoading: (loading: boolean) => void;
-    setError: (error: string | null) => void;
-    fetchUser: () => Promise<User | null>;
-    saveUser: (updates: Partial<User>) => Promise<string>;
-}
-
-export const useUserStore = create<UserState>((set, get) => ({
-    isLoading: false,
-    currentUser: null,
-    error: null,
-
-    setLoading: (loading) => set({ isLoading: loading }),
-    setError: (error) => set({ error }),
-
-    fetchUser: async () => {
-        set({ isLoading: true, error: null });
-        try {
-            const data = await apiClient<{ users: User[] }>("/api/users");
-            const users = data.users || [];
-
-            // Use existing user or null
-            const user = users[0] || null;
-            set({ currentUser: user, isLoading: false });
-            return user;
-        } catch (error) {
-            set({
-                isLoading: false,
-                error: error instanceof Error ? error.message : "Failed to fetch user profile"
-            });
-            return null;
-        }
-    },
-
-    saveUser: async (updates: Partial<User>): Promise<string> => {
-        const currentUser = get().currentUser;
-        if (!currentUser) throw new Error("No user to update");
-
-        set({ isLoading: true, error: null });
-        try {
-            const data = await apiClient<{ message?: string; error?: string }>("/api/users", {
-                method: "POST",
-                body: {
-                    ...currentUser,
-                    ...updates,
-                    id: currentUser.id, // Ensure ID is preserved
-                },
-            });
-
-            // Refresh local state
-            set({
-                currentUser: { ...currentUser, ...updates },
-                isLoading: false
-            });
-            return data.message || "Perfil guardado correctamente";
-        } catch (error) {
-            set({
-                isLoading: false,
-                error: error instanceof Error ? error.message : "Failed to save user profile"
-            });
-            throw error;
-        }
-    },
-}));

package/packages/hive-ui/src/test/setup.ts

@@ -1,15 +0,0 @@
-import "@testing-library/jest-dom";
-
-Object.defineProperty(window, "matchMedia", {
-  writable: true,
-  value: (query: string) => ({
-    matches: false,
-    media: query,
-    onchange: null,
-    addListener: () => {},
-    removeListener: () => {},
-    addEventListener: () => {},
-    removeEventListener: () => {},
-    dispatchEvent: () => {},
-  }),
-});

package/packages/hive-ui/src/types/agent-config.ts

@@ -1,33 +0,0 @@
-import type { EthicsConfig } from "./ethics";
-import type { UserConfig } from "./user";
-import type { Skill } from "./skill";
-import type { Tool } from "./tool";
-import type { MCPServer } from "./mcp";
-
-export interface AgentFullConfig {
-  agentId: string;
-  ethics: EthicsConfig;
-  user: UserConfig;
-  skills: Skill[];
-  tools: Tool[];
-  mcpServers: MCPServer[];
-}
-
-export type ConfigSection = "ethics" | "user" | "skills" | "tools" | "mcp";
-
-export interface ConfigValidationError {
-  section: ConfigSection;
-  field: string;
-  message: string;
-  severity: "error" | "warning" | "info";
-}
-
-export interface ConfigSnapshot {
-  id: string;
-  agentId: string;
-  config: AgentFullConfig;
-  label: string;
-  createdAt: string;
-}
-
-export type SaveStatus = "saved" | "pending" | "saving" | "error";

package/packages/hive-ui/src/types/agent.ts

@@ -1,65 +0,0 @@
-export type AgentStatus = "active" | "idle" | "hibernated" | "error" | "thinking";
-
-export interface AgentConfig {
-  model: string;
-  temperature: number;
-  maxTokens: number;
-  tools: string[];
-  headers?: Record<string, string>;
-}
-
-export interface Agent {
-  // Basic fields
-  id: string;
-  userId?: string;
-  name: string;
-  description?: string;
-  systemPrompt?: string;
-  tone?: string;
-
-  // Role & status
-  role: 'coordinator' | 'worker';
-  status: AgentStatus;
-  enabled: boolean;
-
-  // Provider & model
-  provider_id?: string; // snake_case from DB
-  providerId?: string; // camelCase from API
-  model_id?: string; // snake_case from DB
-  modelId?: string; // camelCase from API
-
-  // Tools & skills
-  toolsJson?: string;
-  skillsJson?: string;
-
-  // Hierarchy
-  parentId?: string;
-  maxIterations?: number;
-
-  // Workspace
-  workspace?: string;
-
-  // Headers (encrypted)
-  headers_encrypted?: string;
-  headers_iv?: string;
-  hasHeaders?: boolean;
-
-  // Timestamps
-  created_at?: number;
-  createdAt?: string | number;
-  updatedAt?: string | number;
-
-  // Virtual/Extra fields for UI
-  taskCount?: number;
-  successRate?: number;
-  user_preferences?: string;
-}
-
-export interface AgentActivity {
-  id: string;
-  agentId: string;
-  action: string;
-  timestamp: string;
-  details: string;
-  status: "success" | "error" | "pending";
-}

package/packages/hive-ui/src/types/bridge.ts

@@ -1,27 +0,0 @@
-export type BridgeProcessStatus = "running" | "stopped" | "error" | "completed" | "finished";
-
-export interface BridgeProcess {
-  id: string;
-  name: string;
-  command: string;
-  status: BridgeProcessStatus;
-  pid: number;
-  startedAt: string;
-  output: string[];
-}
-
-export interface BridgeLog {
-  id: string;
-  processId: string;
-  level: "info" | "warn" | "error" | "debug";
-  message: string;
-  timestamp: string;
-}
-
-export interface CLIAdapter {
-  id: string;
-  name: string;
-  version: string;
-  connected: boolean;
-  lastPing: string;
-}

package/packages/hive-ui/src/types/canvas.ts

@@ -1,76 +0,0 @@
-export type CanvasComponentType = 
-  | "alert"
-  | "alert-dialog"
-  | "accordion"
-  | "avatar"
-  | "badge"
-  | "breadcrumb"
-  | "button"
-  | "calendar"
-  | "card"
-  | "carousel"
-  | "chart"
-  | "checkbox"
-  | "collapsible"
-  | "command"
-  | "context-menu"
-  | "dialog"
-  | "drawer"
-  | "dropdown-menu"
-  | "form"
-  | "input"
-  | "input-otp"
-  | "label"
-  | "markdown"
-  | "menubar"
-  | "navigation-menu"
-  | "pagination"
-  | "popover"
-  | "progress"
-  | "radio-group"
-  | "resizable"
-  | "scroll-area"
-  | "select"
-  | "separator"
-  | "sheet"
-  | "sidebar"
-  | "skeleton"
-  | "slider"
-  | "sonner"
-  | "switch"
-  | "table"
-  | "tabs"
-  | "textarea"
-  | "toast"
-  | "toaster"
-  | "toggle"
-  | "toggle-group"
-  | "tooltip"
-  | "aspect-ratio"
-  | "hover-card"
-  | "custom";
-
-export interface CanvasComponent {
-  id: string;
-  type: CanvasComponentType;
-  props: Record<string, unknown>;
-  position: { x: number; y: number };
-  size: { width: number; height: number };
-  agentId: string;
-}
-
-export interface CanvasEvent {
-  id: string;
-  sessionId: string;
-  type: "add" | "remove" | "update" | "interact";
-  componentId: string;
-  timestamp: string;
-  payload: Record<string, unknown>;
-}
-
-export interface InteractionEvent {
-  componentId: string;
-  action: string;
-  data: Record<string, unknown>;
-  timestamp: string;
-}