machinaos 0.0.1 → 0.0.6

package/client/src/hooks/useAndroidOperations.ts

@@ -1,164 +1,118 @@
-/**
- * useAndroidOperations Hook - WebSocket-based Android device operations
- *
- * Provides Android device management and service execution via WebSocket.
- * This replaces REST-based Android API calls for real-time operations.
- */
-
-import { useCallback, useState } from 'react';
-import { useWebSocket } from '../contexts/WebSocketContext';
-
-export interface AndroidDevice {
-  id: string;
-  model?: string;
-  state?: string;
-}
-
-export interface AndroidActionResult {
-  success: boolean;
-  result?: any;
-  error?: string;
-}
-
-export interface UseAndroidOperationsResult {
-  // Get list of connected devices
-  getDevices: () => Promise<AndroidDevice[]>;
-
-  // Setup Android device connection
-  setupDevice: (
-    connectionType: 'local' | 'remote',
-    deviceId?: string,
-    websocketUrl?: string,
-    port?: number
-  ) => Promise<AndroidActionResult>;
-
-  // Execute Android service action
-  executeAction: (
-    serviceId: string,
-    action: string,
-    parameters: Record<string, any>,
-    deviceId?: string
-  ) => Promise<AndroidActionResult>;
-
-  // State
-  isExecuting: boolean;
-  lastError: string | null;
-  isConnected: boolean;
-
-  // Android status from WebSocket
-  androidStatus: {
-    connected: boolean;
-    device_id: string | null;
-    connected_devices: string[];
-    connection_type: string | null;
-  };
-}
-
-export const useAndroidOperations = (): UseAndroidOperationsResult => {
-  const {
-    getAndroidDevices: wsGetDevices,
-    setupAndroidDevice: wsSetupDevice,
-    executeAndroidAction: wsExecuteAction,
-    androidStatus,
-    isConnected
-  } = useWebSocket();
-
-  const [isExecuting, setIsExecuting] = useState(false);
-  const [lastError, setLastError] = useState<string | null>(null);
-
-  /**
-   * Get list of connected Android devices
-   */
-  const getDevices = useCallback(async (): Promise<AndroidDevice[]> => {
-    try {
-      const devices = await wsGetDevices();
-      return devices.map((id: string) => ({ id }));
-    } catch (error: any) {
-      console.warn('Failed to get Android devices:', error);
-      setLastError(error.message);
-      return [];
-    }
-  }, [wsGetDevices]);
-
-  /**
-   * Setup Android device connection
-   */
-  const setupDevice = useCallback(async (
-    connectionType: 'local' | 'remote',
-    deviceId?: string,
-    websocketUrl?: string,
-    _port: number = 8888  // Port passed to backend via wsSetupDevice
-  ): Promise<AndroidActionResult> => {
-    setIsExecuting(true);
-    setLastError(null);
-
-    try {
-      const result = await wsSetupDevice(connectionType, deviceId, websocketUrl);
-
-      if (!result.success) {
-        setLastError(result.error || 'Setup failed');
-      }
-
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.error
-      };
-    } catch (error: any) {
-      const errorMsg = error.message || 'Device setup failed';
-      setLastError(errorMsg);
-      return {
-        success: false,
-        error: errorMsg
-      };
-    } finally {
-      setIsExecuting(false);
-    }
-  }, [wsSetupDevice]);
-
-  /**
-   * Execute Android service action
-   */
-  const executeAction = useCallback(async (
-    serviceId: string,
-    action: string,
-    parameters: Record<string, any>,
-    deviceId?: string
-  ): Promise<AndroidActionResult> => {
-    setIsExecuting(true);
-    setLastError(null);
-
-    try {
-      const result = await wsExecuteAction(serviceId, action, parameters, deviceId);
-
-      if (!result.success) {
-        setLastError(result.error || 'Action failed');
-      }
-
-      return {
-        success: result.success,
-        result: result.result,
-        error: result.error
-      };
-    } catch (error: any) {
-      const errorMsg = error.message || 'Action execution failed';
-      setLastError(errorMsg);
-      return {
-        success: false,
-        error: errorMsg
-      };
-    } finally {
-      setIsExecuting(false);
-    }
-  }, [wsExecuteAction]);
-
-  return {
-    getDevices,
-    setupDevice,
-    executeAction,
-    isExecuting,
-    lastError,
-    isConnected,
-    androidStatus
-  };
-};
+/**
+ * useAndroidOperations Hook - WebSocket-based Android device operations
+ *
+ * Provides Android device management and service execution via WebSocket.
+ * This replaces REST-based Android API calls for real-time operations.
+ */
+
+import { useCallback, useState } from 'react';
+import { useWebSocket } from '../contexts/WebSocketContext';
+
+export interface AndroidDevice {
+  id: string;
+  model?: string;
+  state?: string;
+}
+
+export interface AndroidActionResult {
+  success: boolean;
+  result?: any;
+  error?: string;
+}
+
+export interface UseAndroidOperationsResult {
+  // Get list of connected devices
+  getDevices: () => Promise<AndroidDevice[]>;
+
+  // Execute Android service action
+  executeAction: (
+    serviceId: string,
+    action: string,
+    parameters: Record<string, any>,
+    deviceId?: string
+  ) => Promise<AndroidActionResult>;
+
+  // State
+  isExecuting: boolean;
+  lastError: string | null;
+  isConnected: boolean;
+
+  // Android status from WebSocket
+  androidStatus: {
+    connected: boolean;
+    device_id: string | null;
+    connected_devices: string[];
+    connection_type: string | null;
+  };
+}
+
+export const useAndroidOperations = (): UseAndroidOperationsResult => {
+  const {
+    getAndroidDevices: wsGetDevices,
+    executeAndroidAction: wsExecuteAction,
+    androidStatus,
+    isConnected
+  } = useWebSocket();
+
+  const [isExecuting, setIsExecuting] = useState(false);
+  const [lastError, setLastError] = useState<string | null>(null);
+
+  /**
+   * Get list of connected Android devices
+   */
+  const getDevices = useCallback(async (): Promise<AndroidDevice[]> => {
+    try {
+      const devices = await wsGetDevices();
+      return devices.map((id: string) => ({ id }));
+    } catch (error: any) {
+      console.warn('Failed to get Android devices:', error);
+      setLastError(error.message);
+      return [];
+    }
+  }, [wsGetDevices]);
+
+  /**
+   * Execute Android service action
+   */
+  const executeAction = useCallback(async (
+    serviceId: string,
+    action: string,
+    parameters: Record<string, any>,
+    deviceId?: string
+  ): Promise<AndroidActionResult> => {
+    setIsExecuting(true);
+    setLastError(null);
+
+    try {
+      const result = await wsExecuteAction(serviceId, action, parameters, deviceId);
+
+      if (!result.success) {
+        setLastError(result.error || 'Action failed');
+      }
+
+      return {
+        success: result.success,
+        result: result.result,
+        error: result.error
+      };
+    } catch (error: any) {
+      const errorMsg = error.message || 'Action execution failed';
+      setLastError(errorMsg);
+      return {
+        success: false,
+        error: errorMsg
+      };
+    } finally {
+      setIsExecuting(false);
+    }
+  }, [wsExecuteAction]);
+
+  return {
+    getDevices,
+    executeAction,
+    isExecuting,
+    lastError,
+    isConnected,
+    androidStatus
+  };
+};

package/client/src/hooks/useApiKeyValidation.ts

@@ -1,107 +1,107 @@
-import { useState, useEffect, useCallback } from 'react';
-import { notification } from 'antd';
-import { useApiKeys } from './useApiKeys';
-
-export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
-
-interface UseApiKeyValidationProps {
-  provider?: string;
-  onSuccess?: (models: string[]) => void;
-}
-
-export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidationProps) => {
-  const [status, setStatus] = useState<ValidationStatus>('idle');
-  const [hasStoredKeyState, setHasStoredKeyState] = useState(false);
-
-  // Use WebSocket-based API key management
-  const {
-    validateApiKey: wsValidateApiKey,
-    getStoredApiKey: wsGetStoredApiKey,
-    hasStoredKey: wsHasStoredKey,
-    removeApiKey: wsRemoveApiKey,
-    getStoredModels: wsGetStoredModels
-  } = useApiKeys();
-
-  // Check for existing key on mount
-  useEffect(() => {
-    if (!provider) return;
-
-    const checkStoredKey = async () => {
-      try {
-        const hasKey = await wsHasStoredKey(provider);
-        if (hasKey) {
-          setHasStoredKeyState(true);
-          setStatus('valid');
-
-          // Try to get models if there's a stored key
-          const models = await wsGetStoredModels(provider);
-          if (models?.length && onSuccess) {
-            onSuccess(models);
-          }
-        }
-      } catch (error) {
-        console.warn('Error checking stored key:', error);
-      }
-    };
-
-    checkStoredKey();
-  }, [provider, onSuccess, wsHasStoredKey, wsGetStoredModels]);
-
-  const validate = useCallback(async (apiKey: string) => {
-    if (!provider || !apiKey.trim()) {
-      notification.error({ message: 'Please enter an API key' });
-      return;
-    }
-
-    setStatus('validating');
-
-    try {
-      const result = await wsValidateApiKey(provider, apiKey.trim());
-
-      if (result.isValid) {
-        setStatus('valid');
-        setHasStoredKeyState(true);
-        notification.success({ message: 'API key validated successfully!' });
-
-        if (result.models?.length && onSuccess) {
-          onSuccess(result.models);
-        }
-      } else {
-        setStatus('invalid');
-        notification.error({ message: result.error || 'Invalid API key' });
-      }
-    } catch (error: any) {
-      setStatus('invalid');
-      notification.error({ message: error.message || 'Validation failed' });
-    }
-  }, [provider, onSuccess, wsValidateApiKey]);
-
-  const clear = useCallback(async () => {
-    if (!provider) return;
-
-    try {
-      await wsRemoveApiKey(provider);
-      setHasStoredKeyState(false);
-      setStatus('idle');
-      notification.success({ message: 'API key cleared' });
-    } catch (error) {
-      notification.error({ message: 'Failed to clear API key' });
-    }
-  }, [provider, wsRemoveApiKey]);
-
-  const getStoredKey = useCallback(async () => {
-    if (!provider) return null;
-    return await wsGetStoredApiKey(provider);
-  }, [provider, wsGetStoredApiKey]);
-
-  return {
-    status,
-    hasStoredKey: hasStoredKeyState,
-    validate,
-    clear,
-    getStoredKey,
-    isValidating: status === 'validating',
-    isValid: status === 'valid',
-    isInvalid: status === 'invalid'
-  };
+import { useState, useEffect, useCallback } from 'react';
+import { notification } from 'antd';
+import { useApiKeys } from './useApiKeys';
+
+export type ValidationStatus = 'idle' | 'validating' | 'valid' | 'invalid';
+
+interface UseApiKeyValidationProps {
+  provider?: string;
+  onSuccess?: (models: string[]) => void;
+}
+
+export const useApiKeyValidation = ({ provider, onSuccess }: UseApiKeyValidationProps) => {
+  const [status, setStatus] = useState<ValidationStatus>('idle');
+  const [hasStoredKeyState, setHasStoredKeyState] = useState(false);
+
+  // Use WebSocket-based API key management
+  const {
+    validateApiKey: wsValidateApiKey,
+    getStoredApiKey: wsGetStoredApiKey,
+    hasStoredKey: wsHasStoredKey,
+    removeApiKey: wsRemoveApiKey,
+    getStoredModels: wsGetStoredModels
+  } = useApiKeys();
+
+  // Check for existing key on mount
+  useEffect(() => {
+    if (!provider) return;
+
+    const checkStoredKey = async () => {
+      try {
+        const hasKey = await wsHasStoredKey(provider);
+        if (hasKey) {
+          setHasStoredKeyState(true);
+          setStatus('valid');
+
+          // Try to get models if there's a stored key
+          const models = await wsGetStoredModels(provider);
+          if (models?.length && onSuccess) {
+            onSuccess(models);
+          }
+        }
+      } catch (error) {
+        console.warn('Error checking stored key:', error);
+      }
+    };
+
+    checkStoredKey();
+  }, [provider, onSuccess, wsHasStoredKey, wsGetStoredModels]);
+
+  const validate = useCallback(async (apiKey: string) => {
+    if (!provider || !apiKey.trim()) {
+      notification.error({ message: 'Please enter an API key' });
+      return;
+    }
+
+    setStatus('validating');
+
+    try {
+      const result = await wsValidateApiKey(provider, apiKey.trim());
+
+      if (result.isValid) {
+        setStatus('valid');
+        setHasStoredKeyState(true);
+        notification.success({ message: 'API key validated successfully!' });
+
+        if (result.models?.length && onSuccess) {
+          onSuccess(result.models);
+        }
+      } else {
+        setStatus('invalid');
+        notification.error({ message: result.error || 'Invalid API key' });
+      }
+    } catch (error: any) {
+      setStatus('invalid');
+      notification.error({ message: error.message || 'Validation failed' });
+    }
+  }, [provider, onSuccess, wsValidateApiKey]);
+
+  const clear = useCallback(async () => {
+    if (!provider) return;
+
+    try {
+      await wsRemoveApiKey(provider);
+      setHasStoredKeyState(false);
+      setStatus('idle');
+      notification.success({ message: 'API key cleared' });
+    } catch (error) {
+      notification.error({ message: 'Failed to clear API key' });
+    }
+  }, [provider, wsRemoveApiKey]);
+
+  const getStoredKey = useCallback(async () => {
+    if (!provider) return null;
+    return await wsGetStoredApiKey(provider);
+  }, [provider, wsGetStoredApiKey]);
+
+  return {
+    status,
+    hasStoredKey: hasStoredKeyState,
+    validate,
+    clear,
+    getStoredKey,
+    isValidating: status === 'validating',
+    isValid: status === 'valid',
+    isInvalid: status === 'invalid'
+  };
 };