machinaos 0.0.1

package/client/src/utils/googleMapsLoader.ts

@@ -0,0 +1,140 @@
+// Google Maps API Loader - Singleton pattern to prevent multiple script loads
+// Ensures Google Maps JavaScript API is loaded only once per page
+
+interface GoogleMapsLoaderOptions {
+  apiKey: string;
+  libraries?: string[];
+  version?: string;
+}
+
+class GoogleMapsLoader {
+  private static instance: GoogleMapsLoader;
+  private loadPromise: Promise<void> | null = null;
+  private isLoaded = false;
+  private isLoading = false;
+
+  private constructor() {}
+
+  public static getInstance(): GoogleMapsLoader {
+    if (!GoogleMapsLoader.instance) {
+      GoogleMapsLoader.instance = new GoogleMapsLoader();
+    }
+    return GoogleMapsLoader.instance;
+  }
+
+  public async loadGoogleMaps(options: GoogleMapsLoaderOptions): Promise<void> {
+    // If already loaded, resolve immediately
+    if (this.isLoaded) {
+      return Promise.resolve();
+    }
+
+    // If currently loading, return the existing promise
+    if (this.isLoading && this.loadPromise) {
+      return this.loadPromise;
+    }
+
+    // Check if Google Maps is already available (loaded externally)
+    if (typeof window !== 'undefined' && window.google?.maps) {
+      this.isLoaded = true;
+      return Promise.resolve();
+    }
+
+    // Start loading
+    this.isLoading = true;
+    this.loadPromise = this.createLoadPromise(options);
+
+    try {
+      await this.loadPromise;
+      this.isLoaded = true;
+      this.isLoading = false;
+    } catch (error) {
+      this.isLoading = false;
+      this.loadPromise = null;
+      throw error;
+    }
+  }
+
+  private createLoadPromise(options: GoogleMapsLoaderOptions): Promise<void> {
+    return new Promise((resolve, reject) => {
+      // Check if script already exists
+      const existingScript = document.querySelector('script[src*="maps.googleapis.com"]');
+      if (existingScript) {
+        // Script exists, wait for it to load
+        if (window.google?.maps) {
+          resolve();
+        } else {
+          existingScript.addEventListener('load', () => resolve());
+          existingScript.addEventListener('error', (error) => reject(error));
+        }
+        return;
+      }
+
+      // Create new script element
+      const script = document.createElement('script');
+      script.type = 'text/javascript';
+      script.async = true;
+      script.defer = true;
+
+      // Build URL with parameters
+      const { apiKey, libraries = ['geometry'], version = 'weekly' } = options;
+      const params = new URLSearchParams({
+        key: apiKey,
+        libraries: libraries.join(','),
+        v: version,
+        callback: '__googleMapsCallback__'
+      });
+
+      script.src = `https://maps.googleapis.com/maps/api/js?${params.toString()}`;
+
+      // Set up callback
+      (window as any).__googleMapsCallback__ = () => {
+        delete (window as any).__googleMapsCallback__;
+        resolve();
+      };
+
+      // Handle errors
+      script.onerror = (error) => {
+        delete (window as any).__googleMapsCallback__;
+        reject(new Error(`Failed to load Google Maps API: ${error}`));
+      };
+
+      // Add script to document
+      document.head.appendChild(script);
+    });
+  }
+
+  public isGoogleMapsLoaded(): boolean {
+    return this.isLoaded || (typeof window !== 'undefined' && !!window.google?.maps);
+  }
+
+  public getGoogleMaps(): typeof google.maps | null {
+    if (typeof window !== 'undefined' && window.google?.maps) {
+      return window.google.maps;
+    }
+    return null;
+  }
+}
+
+// Export singleton instance and convenience functions
+export const googleMapsLoader = GoogleMapsLoader.getInstance();
+
+export const loadGoogleMaps = (options: GoogleMapsLoaderOptions): Promise<void> => {
+  return googleMapsLoader.loadGoogleMaps(options);
+};
+
+export const isGoogleMapsLoaded = (): boolean => {
+  return googleMapsLoader.isGoogleMapsLoaded();
+};
+
+export const getGoogleMaps = (): typeof google.maps | null => {
+  return googleMapsLoader.getGoogleMaps();
+};
+
+// Type declarations for Google Maps
+declare global {
+  interface Window {
+    google?: {
+      maps: typeof google.maps;
+    };
+  }
+}

package/client/src/utils/locationUtils.ts

@@ -0,0 +1,85 @@
+import { INodeTypeDescription, INodeProperties } from '../types/INodeProperties';
+
+// Location parameter utilities
+export interface LocationParams {
+  latParam: INodeProperties | null;
+  lngParam: INodeProperties | null;
+}
+
+// Find coordinate parameters in node definition
+export const getCoordinateParams = (nodeDefinition: INodeTypeDescription | null): LocationParams => {
+  if (!nodeDefinition) return { latParam: null, lngParam: null };
+
+  const latParam = nodeDefinition.properties?.find((p: any) => {
+    const name = p.name.toLowerCase();
+    return name.includes('lat') || name === 'latitude';
+  });
+
+  const lngParam = nodeDefinition.properties?.find((p: any) => {
+    const name = p.name.toLowerCase();
+    return name.includes('lng') || name.includes('lon') || name === 'longitude';
+  });
+
+  return { latParam: latParam || null, lngParam: lngParam || null };
+};
+
+// Get current coordinates from parameters
+export const getCurrentCoordinates = (
+  parameters: Record<string, any>,
+  locationParams: LocationParams
+) => {
+  const { latParam, lngParam } = locationParams;
+
+  const lat = (latParam && parameters[latParam.name]) || latParam?.default || 40.7128;
+  const lng = (lngParam && parameters[lngParam.name]) || lngParam?.default || -74.0060;
+
+  return { lat, lng };
+};
+
+// Get map display parameters
+export const getMapDisplayParams = (parameters: Record<string, any>) => {
+  const zoom = parameters.zoom || 13;
+  const mapTypeId = parameters.mapTypeId || 'ROADMAP';
+
+  return { zoom, mapTypeId };
+};
+
+// Get Google Maps API key with fallbacks
+export const getGoogleMapsApiKey = (): string | undefined => {
+  // Note: For stored API keys, use ApiKeyManagerService.getStoredApiKeyAsync('google_maps')
+  // This function now only returns the environment variable fallback
+  return (import.meta as any).env?.VITE_GOOGLE_MAPS_API_KEY || undefined;
+};
+
+// Create location update handler
+export const createLocationUpdateHandler = (
+  locationParams: LocationParams,
+  onParameterChange: (paramName: string, value: any) => void
+) => {
+  return (lat: number, lng: number) => {
+    const { latParam, lngParam } = locationParams;
+
+    if (latParam) {
+      onParameterChange(latParam.name, lat);
+    }
+    if (lngParam) {
+      onParameterChange(lngParam.name, lng);
+    }
+  };
+};
+
+// Check if a node is location-related
+export const isLocationNode = (nodeDefinition: INodeTypeDescription | null): boolean => {
+  if (!nodeDefinition) return false;
+
+  const isCreateMap = nodeDefinition.name === 'createMap';
+  const hasLocationGroup = nodeDefinition.group?.includes('location') ?? false;
+  const hasCoordinates = getCoordinateParams(nodeDefinition).latParam !== null;
+
+  return isCreateMap || hasLocationGroup || hasCoordinates;
+};
+
+// Check if node should show maps preview
+export const shouldShowMapsPreview = (nodeDefinition: INodeTypeDescription | null): boolean => {
+  return nodeDefinition?.name === 'createMap';
+};

package/client/src/utils/nodeUtils.ts

@@ -0,0 +1,31 @@
+// Utility functions for node operations
+
+// Generate short node name from nodeType for parameter references
+export const getShortNodeName = (nodeType: string): string => {
+  const typeMap: { [key: string]: string } = {
+    // AI Chat Models
+    'openaiChatModel': 'openai',
+    'anthropicChatModel': 'claude',
+    'geminiChatModel': 'gemini',
+    // AI Agents
+    'aiAgent': 'ai',
+    // Location Services
+    'createMap': 'map',
+    'addLocations': 'location',
+    'showNearbyPlaces': 'places'
+  };
+  
+  // If we have a specific mapping, use it
+  if (typeMap[nodeType]) {
+    return typeMap[nodeType];
+  }
+  
+  // Otherwise, create a simplified version by removing capitals and common suffixes
+  let simplified = nodeType
+    .replace(/[A-Z]/g, '') // Remove capital letters
+    .replace(/(Get|Set|Stop|Play|Record|Control)$/i, '') // Remove common suffixes
+    .toLowerCase();
+    
+  // Return simplified name or fallback to 'node'
+  return simplified || 'node';
+};

package/client/src/utils/workflow.ts

@@ -0,0 +1,30 @@
+import { Node, Edge } from 'reactflow';
+
+export const generateWorkflowId = (): string => 
+  `workflow-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+export const sanitizeNodesForComparison = (nodes: Node[]): Node[] =>
+  nodes.map(n => ({ ...n, selected: undefined, dragging: undefined }));
+
+export const sanitizeEdgesForComparison = (edges: Edge[]): Edge[] =>
+  edges.map(e => ({ ...e, selected: undefined }));
+
+export const serializeDateFields = <T extends { createdAt: Date; lastModified: Date }>(obj: T) => ({
+  ...obj,
+  createdAt: obj.createdAt.toISOString(),
+  lastModified: obj.lastModified.toISOString(),
+});
+
+export const deserializeDateFields = <T extends { createdAt: string; lastModified: string }>(obj: T) => ({
+  ...obj,
+  createdAt: new Date(obj.createdAt),
+  lastModified: new Date(obj.lastModified),
+});
+
+export const snapToGrid = (position: { x: number; y: number }, gridSize = 20) => ({
+  x: Math.round(position.x / gridSize) * gridSize,
+  y: Math.round(position.y / gridSize) * gridSize,
+});
+
+export const getDefaultNodePosition = (nodeCount: number): { x: number; y: number } => 
+  nodeCount === 0 ? { x: 100, y: 200 } : { x: 0, y: 0 };

package/client/src/utils/workflowExport.ts

@@ -0,0 +1,120 @@
+/**
+ * Workflow Export/Import Utilities
+ * Handles exporting workflows to JSON files and importing from JSON
+ */
+
+import { WorkflowData } from '../store/useAppStore';
+import { validateWorkflow, serializeWorkflow, deserializeWorkflow } from '../schemas/workflowSchema';
+
+/**
+ * Export workflow to JSON file
+ */
+export function exportWorkflowToFile(workflow: WorkflowData): void {
+  const validation = validateWorkflow(workflow);
+
+  if (!validation.valid) {
+    console.error('Workflow validation errors:', validation.errors);
+    throw new Error(`Cannot export invalid workflow: ${validation.errors.join(', ')}`);
+  }
+
+  const workflowJSON = {
+    ...workflow,
+    createdAt: workflow.createdAt.toISOString(),
+    lastModified: workflow.lastModified.toISOString(),
+    version: '1.0.0'
+  };
+
+  const jsonString = serializeWorkflow(workflowJSON);
+  const blob = new Blob([jsonString], { type: 'application/json' });
+  const url = URL.createObjectURL(blob);
+
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = `${workflow.name || 'workflow'}_${workflow.id}.json`;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+
+/**
+ * Import workflow from JSON file
+ */
+export function importWorkflowFromFile(file: File): Promise<WorkflowData> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+
+    reader.onload = (event) => {
+      try {
+        const jsonString = event.target?.result as string;
+        const workflow = deserializeWorkflow(jsonString);
+
+        const validation = validateWorkflow(workflow);
+        if (!validation.valid) {
+          reject(new Error(`Invalid workflow JSON: ${validation.errors.join(', ')}`));
+          return;
+        }
+
+        resolve(workflow);
+      } catch (error) {
+        reject(error);
+      }
+    };
+
+    reader.onerror = () => {
+      reject(new Error('Failed to read file'));
+    };
+
+    reader.readAsText(file);
+  });
+}
+
+/**
+ * Export workflow to JSON string
+ */
+export function exportWorkflowToJSON(workflow: WorkflowData): string {
+  const validation = validateWorkflow(workflow);
+
+  if (!validation.valid) {
+    throw new Error(`Cannot export invalid workflow: ${validation.errors.join(', ')}`);
+  }
+
+  const workflowJSON = {
+    ...workflow,
+    createdAt: workflow.createdAt.toISOString(),
+    lastModified: workflow.lastModified.toISOString(),
+    version: '1.0.0'
+  };
+
+  return serializeWorkflow(workflowJSON);
+}
+
+/**
+ * Import workflow from JSON string
+ */
+export function importWorkflowFromJSON(jsonString: string): WorkflowData {
+  const workflow = deserializeWorkflow(jsonString);
+
+  const validation = validateWorkflow(workflow);
+  if (!validation.valid) {
+    throw new Error(`Invalid workflow JSON: ${validation.errors.join(', ')}`);
+  }
+
+  return workflow;
+}
+
+/**
+ * Copy workflow to clipboard as JSON
+ */
+export async function copyWorkflowToClipboard(workflow: WorkflowData): Promise<void> {
+  const jsonString = exportWorkflowToJSON(workflow);
+  await navigator.clipboard.writeText(jsonString);
+}
+
+/**
+ * Paste workflow from clipboard
+ */
+export async function pasteWorkflowFromClipboard(): Promise<WorkflowData> {
+  const jsonString = await navigator.clipboard.readText();
+  return importWorkflowFromJSON(jsonString);
+}

package/client/src/vite-env.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_ANDROID_RELAY_URL: string;
+  readonly VITE_AUTH_ENABLED: string;
+  readonly VITE_CLIENT_PORT: string;
+  readonly VITE_PYTHON_BACKEND_URL: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}

package/client/tailwind.config.js

@@ -0,0 +1,60 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  darkMode: ["class"],
+  content: [
+    "./index.html",
+    "./src/**/*.{js,ts,jsx,tsx}",
+  ],
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+    },
+  },
+  plugins: [],
+}

package/client/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/client/tsconfig.node.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "strict": true
+  },
+  "include": ["vite.config.js"]
+}

package/client/vite.config.js

@@ -0,0 +1,35 @@
+import { defineConfig, loadEnv } from 'vite'
+import react from '@vitejs/plugin-react'
+import { resolve } from 'path'
+
+// https://vite.dev/config/
+export default defineConfig(({ mode }) => {
+  // Load env from parent directory (root .env) for local development
+  const fileEnv = loadEnv(mode, resolve(process.cwd(), '..'), '')
+
+  // In Docker, env vars are set via ENV in Dockerfile, accessible via process.env
+  // Priority: process.env (Docker) > fileEnv (local .env) > defaults
+  const getEnv = (key, defaultValue = '') => {
+    return process.env[key] || fileEnv[key] || defaultValue
+  }
+
+  return {
+    plugins: [react()],
+    // Expose VITE_ prefixed env vars to client code via import.meta.env
+    define: {
+      'import.meta.env.VITE_AUTH_ENABLED': JSON.stringify(getEnv('VITE_AUTH_ENABLED', 'true')),
+      'import.meta.env.VITE_PYTHON_SERVICE_URL': JSON.stringify(getEnv('VITE_PYTHON_SERVICE_URL', '')),
+      'import.meta.env.VITE_WHATSAPP_SERVICE_URL': JSON.stringify(getEnv('VITE_WHATSAPP_SERVICE_URL', '')),
+      'import.meta.env.VITE_ANDROID_RELAY_URL': JSON.stringify(getEnv('VITE_ANDROID_RELAY_URL', '')),
+    },
+    server: {
+      port: parseInt(getEnv('VITE_CLIENT_PORT', '3000')),
+      strictPort: false,
+      host: true
+    },
+    build: {
+      // antd + reactflow are large libraries - this is expected
+      chunkSizeWarningLimit: 1500,
+    },
+  }
+})

package/docker-compose.prod.yml

@@ -0,0 +1,107 @@
+services:
+  # Redis Cache (production performance)
+  redis:
+    image: redis:7-alpine
+    container_name: machina-redis
+    volumes:
+      - redis-data:/data
+    networks:
+      - app-network
+    restart: always
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+    command: redis-server --appendonly yes
+
+  # Python FastAPI Backend
+  backend:
+    build:
+      context: ./server
+      dockerfile: Dockerfile
+    container_name: machina-backend
+    ports:
+      - "${PYTHON_BACKEND_PORT:-3010}:${PYTHON_BACKEND_PORT:-3010}"
+    volumes:
+      - backend-data:/app/data
+    networks:
+      - app-network
+    restart: always
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:${PYTHON_BACKEND_PORT:-3010}/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+    env_file:
+      - path: ./.env
+        required: false
+    environment:
+      # Production overrides
+      - PORT=${PYTHON_BACKEND_PORT:-3010}
+      - ENV=production
+      - REDIS_ENABLED=true
+      - REDIS_URL=redis://redis:6379
+      - WHATSAPP_RPC_URL=ws://whatsapp:${WHATSAPP_RPC_PORT:-9400}/ws/rpc
+      - TZ=UTC
+    depends_on:
+      redis:
+        condition: service_healthy
+      whatsapp:
+        condition: service_healthy
+
+  # React Frontend (Production - Nginx)
+  frontend:
+    build:
+      context: ./client
+      dockerfile: Dockerfile
+      target: production
+      args:
+        # Pass env vars to frontend build (baked into static JS at build time)
+        VITE_AUTH_ENABLED: ${VITE_AUTH_ENABLED:-true}
+        VITE_PYTHON_SERVICE_URL: ${VITE_PYTHON_SERVICE_URL:-}
+        VITE_WHATSAPP_SERVICE_URL: ${VITE_WHATSAPP_SERVICE_URL:-}
+        VITE_ANDROID_RELAY_URL: ${VITE_ANDROID_RELAY_URL:-}
+    container_name: machina-frontend
+    ports:
+      - "${VITE_CLIENT_PORT:-3000}:80"
+    networks:
+      - app-network
+    restart: always
+    depends_on:
+      - backend
+
+  # WhatsApp RPC Service (Go API only)
+  whatsapp:
+    build:
+      context: ./server/whatsapp-rpc
+      dockerfile: Dockerfile
+    container_name: machina-whatsapp
+    volumes:
+      - whatsapp-data:/app/data
+    networks:
+      - app-network
+    restart: always
+    # Privileged mode for proper SQLite WAL mmap support
+    privileged: true
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:9400/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 15s
+    environment:
+      - TZ=UTC
+
+networks:
+  app-network:
+    driver: bridge
+
+volumes:
+  redis-data:
+    driver: local
+  backend-data:
+    driver: local
+  whatsapp-data:
+    driver: local