machinaos 0.0.1

package/client/src/hooks/useToolSchema.ts

@@ -0,0 +1,209 @@
+/**
+ * useToolSchema Hook - WebSocket-based tool schema management
+ *
+ * Provides tool schema operations for Android Toolkit and other tool nodes.
+ * The database-stored schema is the source of truth for LLM tool configurations.
+ */
+
+import { useCallback, useState } from 'react';
+import { useWebSocket } from '../contexts/WebSocketContext';
+
+/**
+ * Schema field configuration for tool arguments
+ */
+export interface SchemaFieldConfig {
+  type: 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array';
+  description: string;
+  required?: boolean;
+  default?: any;
+  enum?: string[];
+}
+
+/**
+ * Full schema configuration stored in database
+ */
+export interface ToolSchemaConfig {
+  description: string;
+  fields: Record<string, SchemaFieldConfig>;
+}
+
+/**
+ * Tool schema as stored in database
+ */
+export interface ToolSchema {
+  node_id: string;
+  tool_name: string;
+  tool_description: string;
+  schema_config: ToolSchemaConfig;
+  connected_services?: Record<string, any>[];
+  created_at?: string;
+  updated_at?: string;
+}
+
+export interface UseToolSchemaResult {
+  // Get tool schema for a node
+  getToolSchema: (nodeId: string) => Promise<ToolSchema | null>;
+
+  // Save tool schema for a node
+  saveToolSchema: (
+    nodeId: string,
+    toolName: string,
+    toolDescription: string,
+    schemaConfig: ToolSchemaConfig,
+    connectedServices?: Record<string, any>[]
+  ) => Promise<boolean>;
+
+  // Delete tool schema for a node
+  deleteToolSchema: (nodeId: string) => Promise<boolean>;
+
+  // Get all tool schemas
+  getAllToolSchemas: () => Promise<ToolSchema[]>;
+
+  // State
+  isLoading: boolean;
+  error: string | null;
+  isConnected: boolean;
+}
+
+export const useToolSchema = (): UseToolSchemaResult => {
+  const { sendRequest, isConnected } = useWebSocket();
+
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  /**
+   * Get tool schema for a node from database
+   */
+  const getToolSchema = useCallback(async (nodeId: string): Promise<ToolSchema | null> => {
+    if (!isConnected) {
+      console.warn('[useToolSchema] WebSocket not connected');
+      return null;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const response = await sendRequest<{ success: boolean; schema: ToolSchema | null }>('get_tool_schema', {
+        node_id: nodeId
+      });
+
+      if (response.success) {
+        return response.schema;
+      }
+      return null;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Failed to get tool schema';
+      setError(errorMsg);
+      console.error('[useToolSchema] Error getting schema:', errorMsg);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isConnected, sendRequest]);
+
+  /**
+   * Save tool schema for a node to database
+   */
+  const saveToolSchema = useCallback(async (
+    nodeId: string,
+    toolName: string,
+    toolDescription: string,
+    schemaConfig: ToolSchemaConfig,
+    connectedServices?: Record<string, any>[]
+  ): Promise<boolean> => {
+    if (!isConnected) {
+      console.warn('[useToolSchema] WebSocket not connected');
+      return false;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const response = await sendRequest<{ success: boolean; saved: boolean }>('save_tool_schema', {
+        node_id: nodeId,
+        tool_name: toolName,
+        tool_description: toolDescription,
+        schema_config: schemaConfig,
+        connected_services: connectedServices
+      });
+
+      return response.success && response.saved;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Failed to save tool schema';
+      setError(errorMsg);
+      console.error('[useToolSchema] Error saving schema:', errorMsg);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isConnected, sendRequest]);
+
+  /**
+   * Delete tool schema for a node from database
+   */
+  const deleteToolSchema = useCallback(async (nodeId: string): Promise<boolean> => {
+    if (!isConnected) {
+      console.warn('[useToolSchema] WebSocket not connected');
+      return false;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const response = await sendRequest<{ success: boolean }>('delete_tool_schema', {
+        node_id: nodeId
+      });
+
+      return response.success;
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Failed to delete tool schema';
+      setError(errorMsg);
+      console.error('[useToolSchema] Error deleting schema:', errorMsg);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isConnected, sendRequest]);
+
+  /**
+   * Get all tool schemas from database
+   */
+  const getAllToolSchemas = useCallback(async (): Promise<ToolSchema[]> => {
+    if (!isConnected) {
+      console.warn('[useToolSchema] WebSocket not connected');
+      return [];
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const response = await sendRequest<{ success: boolean; schemas: ToolSchema[] }>('get_all_tool_schemas', {});
+
+      if (response.success) {
+        return response.schemas || [];
+      }
+      return [];
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : 'Failed to get tool schemas';
+      setError(errorMsg);
+      console.error('[useToolSchema] Error getting schemas:', errorMsg);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [isConnected, sendRequest]);
+
+  return {
+    getToolSchema,
+    saveToolSchema,
+    deleteToolSchema,
+    getAllToolSchemas,
+    isLoading,
+    error,
+    isConnected
+  };
+};

package/client/src/hooks/useWhatsApp.ts

@@ -0,0 +1,196 @@
+/**
+ * useWhatsApp Hook - WebSocket-based WhatsApp operations
+ *
+ * Provides WhatsApp messaging and connection management via WebSocket.
+ * This replaces REST-based WhatsApp API calls for real-time operations.
+ */
+
+import { useCallback, useState } from 'react';
+import { useWebSocket } from '../contexts/WebSocketContext';
+
+export interface WhatsAppStatus {
+  connected: boolean;
+  deviceId?: string;
+  data?: any;
+}
+
+export interface WhatsAppQRResult {
+  connected: boolean;
+  qr?: string;
+  message?: string;
+}
+
+export interface WhatsAppSendResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+export interface UseWhatsAppResult {
+  // Get WhatsApp connection status
+  getStatus: () => Promise<WhatsAppStatus>;
+
+  // Get QR code for authentication
+  getQRCode: () => Promise<WhatsAppQRResult>;
+
+  // Send a WhatsApp message
+  sendMessage: (phone: string, message: string) => Promise<WhatsAppSendResult>;
+
+  // Start WhatsApp connection
+  startConnection: () => Promise<{ success: boolean; message?: string }>;
+
+  // Restart WhatsApp connection (stops and starts the service)
+  restartConnection: () => Promise<{ success: boolean; message?: string }>;
+
+  // State
+  isLoading: boolean;
+  lastError: string | null;
+  connectionStatus: WhatsAppStatus | null;
+  isConnected: boolean;
+}
+
+export const useWhatsApp = (): UseWhatsAppResult => {
+  const {
+    getWhatsAppStatus: wsGetStatus,
+    getWhatsAppQR: wsGetQR,
+    sendWhatsAppMessage: wsSendMessage,
+    startWhatsAppConnection: wsStartConnection,
+    restartWhatsAppConnection: wsRestartConnection,
+    isConnected
+  } = useWebSocket();
+
+  const [isLoading, setIsLoading] = useState(false);
+  const [lastError, setLastError] = useState<string | null>(null);
+  const [connectionStatus, setConnectionStatus] = useState<WhatsAppStatus | null>(null);
+
+  /**
+   * Get WhatsApp connection status
+   */
+  const getStatus = useCallback(async (): Promise<WhatsAppStatus> => {
+    setIsLoading(true);
+    setLastError(null);
+
+    try {
+      const result = await wsGetStatus();
+      setConnectionStatus(result);
+      return result;
+    } catch (error: any) {
+      const errorMsg = error.message || 'Failed to get status';
+      setLastError(errorMsg);
+      return { connected: false };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [wsGetStatus]);
+
+  /**
+   * Get QR code for WhatsApp authentication
+   */
+  const getQRCode = useCallback(async (): Promise<WhatsAppQRResult> => {
+    setIsLoading(true);
+    setLastError(null);
+
+    try {
+      const result = await wsGetQR();
+
+      if (result.connected) {
+        setConnectionStatus({ connected: true });
+      }
+
+      return result;
+    } catch (error: any) {
+      const errorMsg = error.message || 'Failed to get QR code';
+      setLastError(errorMsg);
+      return { connected: false, message: errorMsg };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [wsGetQR]);
+
+  /**
+   * Send a WhatsApp message
+   */
+  const sendMessage = useCallback(async (
+    phone: string,
+    message: string
+  ): Promise<WhatsAppSendResult> => {
+    setIsLoading(true);
+    setLastError(null);
+
+    try {
+      const result = await wsSendMessage(phone, message);
+
+      if (!result.success && result.error) {
+        setLastError(result.error);
+      }
+
+      return result;
+    } catch (error: any) {
+      const errorMsg = error.message || 'Failed to send message';
+      setLastError(errorMsg);
+      return { success: false, error: errorMsg };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [wsSendMessage]);
+
+  /**
+   * Start WhatsApp connection
+   */
+  const startConnection = useCallback(async (): Promise<{ success: boolean; message?: string }> => {
+    setIsLoading(true);
+    setLastError(null);
+
+    try {
+      const result = await wsStartConnection();
+
+      if (!result.success && result.message) {
+        setLastError(result.message);
+      }
+
+      return result;
+    } catch (error: any) {
+      const errorMsg = error.message || 'Failed to start connection';
+      setLastError(errorMsg);
+      return { success: false, message: errorMsg };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [wsStartConnection]);
+
+  /**
+   * Restart WhatsApp connection (stops and starts the service)
+   */
+  const restartConnection = useCallback(async (): Promise<{ success: boolean; message?: string }> => {
+    setIsLoading(true);
+    setLastError(null);
+
+    try {
+      const result = await wsRestartConnection();
+
+      if (!result.success && result.message) {
+        setLastError(result.message);
+      }
+
+      return result;
+    } catch (error: any) {
+      const errorMsg = error.message || 'Failed to restart connection';
+      setLastError(errorMsg);
+      return { success: false, message: errorMsg };
+    } finally {
+      setIsLoading(false);
+    }
+  }, [wsRestartConnection]);
+
+  return {
+    getStatus,
+    getQRCode,
+    sendMessage,
+    startConnection,
+    restartConnection,
+    isLoading,
+    lastError,
+    connectionStatus,
+    isConnected
+  };
+};

package/client/src/hooks/useWorkflowManagement.ts

@@ -0,0 +1,46 @@
+import { useCallback } from 'react';
+import { useAppStore } from '../store/useAppStore';
+
+export const useWorkflowManagement = () => {
+  const {
+    currentWorkflow,
+    hasUnsavedChanges,
+    savedWorkflows,
+    updateWorkflow,
+    saveWorkflow,
+    loadWorkflow,
+    createNewWorkflow,
+  } = useAppStore();
+
+  const handleWorkflowNameChange = useCallback((name: string) => {
+    updateWorkflow({ name });
+  }, [updateWorkflow]);
+
+  const handleSave = useCallback(() => {
+    saveWorkflow();
+  }, [saveWorkflow]);
+
+  const handleNew = useCallback(() => {
+    createNewWorkflow();
+  }, [createNewWorkflow]);
+
+  const handleOpen = useCallback(() => {
+    // Workflow selection is handled by sidebar
+  }, []);
+
+  const handleSelectWorkflow = useCallback((workflow: any) => {
+    loadWorkflow(workflow.id);
+  }, [loadWorkflow]);
+
+
+  return {
+    currentWorkflow,
+    hasUnsavedChanges,
+    savedWorkflows,
+    handleWorkflowNameChange,
+    handleSave,
+    handleNew,
+    handleOpen,
+    handleSelectWorkflow,
+  };
+};