machinaos 0.0.1

package/client/src/types/EdgeCondition.ts

@@ -0,0 +1,231 @@
+/**
+ * Edge Condition Types for Runtime Conditional Branching
+ *
+ * Based on Prefect-style dynamic workflow branching.
+ * Conditions are evaluated against node output at runtime to determine
+ * which workflow paths to follow.
+ */
+
+/**
+ * Supported comparison operators for edge conditions.
+ * Matches backend operators in server/services/execution/conditions.py
+ */
+export type ConditionOperator =
+  // Equality operators
+  | 'eq'           // Equal (==)
+  | 'neq'          // Not equal (!=)
+  // Comparison operators (numeric)
+  | 'gt'           // Greater than (>)
+  | 'lt'           // Less than (<)
+  | 'gte'          // Greater than or equal (>=)
+  | 'lte'          // Less than or equal (<=)
+  // String/list contains
+  | 'contains'     // String/list contains value
+  | 'not_contains' // String/list does not contain value
+  // Existence checks
+  | 'exists'       // Field exists and is not None
+  | 'not_exists'   // Field does not exist or is None
+  // Empty checks
+  | 'is_empty'     // Field is empty (None, "", [], {})
+  | 'is_not_empty' // Field is not empty
+  // Regex match
+  | 'matches'      // Regex pattern match
+  // List membership
+  | 'in'           // Value is in list
+  | 'not_in'       // Value is not in list
+  // String prefix/suffix
+  | 'starts_with'  // String starts with value
+  | 'ends_with'    // String ends with value
+  // Boolean checks
+  | 'is_true'      // Value is truthy
+  | 'is_false'     // Value is falsy
+  // Type checks
+  | 'is_string'    // Value is a string
+  | 'is_number'    // Value is a number
+  | 'is_boolean'   // Value is a boolean
+  | 'is_array'     // Value is an array
+  | 'is_object';   // Value is an object
+
+/**
+ * Metadata for each operator - used by UI to render appropriate controls.
+ */
+export interface OperatorMetadata {
+  label: string;
+  description: string;
+  requiresValue: boolean;
+  valueType?: 'string' | 'number' | 'boolean' | 'array' | 'any';
+}
+
+/**
+ * Registry of all operators with their metadata.
+ * Matches OPERATORS dict in server/services/execution/conditions.py
+ */
+export const OPERATORS: Record<ConditionOperator, OperatorMetadata> = {
+  // Equality
+  eq: { label: 'Equals', description: 'Value equals target', requiresValue: true, valueType: 'any' },
+  neq: { label: 'Not Equals', description: 'Value does not equal target', requiresValue: true, valueType: 'any' },
+  // Comparison
+  gt: { label: 'Greater Than', description: 'Value is greater than target', requiresValue: true, valueType: 'number' },
+  lt: { label: 'Less Than', description: 'Value is less than target', requiresValue: true, valueType: 'number' },
+  gte: { label: 'Greater or Equal', description: 'Value is greater than or equal to target', requiresValue: true, valueType: 'number' },
+  lte: { label: 'Less or Equal', description: 'Value is less than or equal to target', requiresValue: true, valueType: 'number' },
+  // Contains
+  contains: { label: 'Contains', description: 'String/list contains value', requiresValue: true, valueType: 'string' },
+  not_contains: { label: 'Does Not Contain', description: 'String/list does not contain value', requiresValue: true, valueType: 'string' },
+  // Existence
+  exists: { label: 'Exists', description: 'Field exists and is not null', requiresValue: false },
+  not_exists: { label: 'Does Not Exist', description: 'Field does not exist or is null', requiresValue: false },
+  // Empty
+  is_empty: { label: 'Is Empty', description: 'Value is empty (null, "", [], {})', requiresValue: false },
+  is_not_empty: { label: 'Is Not Empty', description: 'Value is not empty', requiresValue: false },
+  // Regex
+  matches: { label: 'Matches Regex', description: 'Value matches regex pattern', requiresValue: true, valueType: 'string' },
+  // List membership
+  in: { label: 'In List', description: 'Value is in list', requiresValue: true, valueType: 'array' },
+  not_in: { label: 'Not In List', description: 'Value is not in list', requiresValue: true, valueType: 'array' },
+  // String prefix/suffix
+  starts_with: { label: 'Starts With', description: 'String starts with value', requiresValue: true, valueType: 'string' },
+  ends_with: { label: 'Ends With', description: 'String ends with value', requiresValue: true, valueType: 'string' },
+  // Boolean
+  is_true: { label: 'Is True', description: 'Value is truthy', requiresValue: false },
+  is_false: { label: 'Is False', description: 'Value is falsy', requiresValue: false },
+  // Type checks
+  is_string: { label: 'Is String', description: 'Value is a string', requiresValue: false },
+  is_number: { label: 'Is Number', description: 'Value is a number', requiresValue: false },
+  is_boolean: { label: 'Is Boolean', description: 'Value is a boolean', requiresValue: false },
+  is_array: { label: 'Is Array', description: 'Value is an array', requiresValue: false },
+  is_object: { label: 'Is Object', description: 'Value is an object', requiresValue: false },
+};
+
+/**
+ * Single edge condition - evaluated against source node output.
+ */
+export interface EdgeCondition {
+  /** Output field to check (supports dot notation: "result.status", "items.0.name") */
+  field: string;
+  /** Comparison operator */
+  operator: ConditionOperator;
+  /** Value to compare against (required for operators with requiresValue: true) */
+  value?: string | number | boolean | any[];
+}
+
+/**
+ * Extended edge data with condition support.
+ * Used in edge.data field for conditional branching.
+ */
+export interface ConditionalEdgeData {
+  /** Optional condition for this edge */
+  condition?: EdgeCondition;
+  /** Display label for the edge (shown on canvas) */
+  label?: string;
+  /** Logic for multiple conditions (future enhancement) */
+  conditionLogic?: 'and' | 'or';
+  /** Additional conditions (future enhancement) */
+  additionalConditions?: EdgeCondition[];
+}
+
+/**
+ * React Flow edge with conditional data.
+ * Extends the base Edge type with typed data property.
+ */
+export interface ConditionalEdge {
+  id: string;
+  source: string;
+  target: string;
+  sourceHandle?: string | null;
+  targetHandle?: string | null;
+  type?: string;
+  animated?: boolean;
+  style?: React.CSSProperties;
+  className?: string;
+  data?: ConditionalEdgeData;
+}
+
+/**
+ * Props for the EdgeConditionEditor component.
+ */
+export interface EdgeConditionEditorProps {
+  /** The edge being edited */
+  edge: ConditionalEdge;
+  /** Callback when condition is updated */
+  onConditionChange: (condition: EdgeCondition | undefined) => void;
+  /** Callback when label is updated */
+  onLabelChange: (label: string | undefined) => void;
+  /** Available fields from source node output (for autocomplete) */
+  availableFields?: string[];
+  /** Callback to close the editor */
+  onClose: () => void;
+}
+
+/**
+ * Get operators that don't require a value input.
+ */
+export function getNoValueOperators(): ConditionOperator[] {
+  return (Object.keys(OPERATORS) as ConditionOperator[]).filter(
+    op => !OPERATORS[op].requiresValue
+  );
+}
+
+/**
+ * Get operators that require a value input.
+ */
+export function getValueOperators(): ConditionOperator[] {
+  return (Object.keys(OPERATORS) as ConditionOperator[]).filter(
+    op => OPERATORS[op].requiresValue
+  );
+}
+
+/**
+ * Get operators grouped by category.
+ */
+export function getOperatorsByCategory(): Record<string, ConditionOperator[]> {
+  return {
+    'Equality': ['eq', 'neq'],
+    'Comparison': ['gt', 'lt', 'gte', 'lte'],
+    'Contains': ['contains', 'not_contains'],
+    'Existence': ['exists', 'not_exists'],
+    'Empty': ['is_empty', 'is_not_empty'],
+    'Pattern': ['matches', 'starts_with', 'ends_with'],
+    'List': ['in', 'not_in'],
+    'Boolean': ['is_true', 'is_false'],
+    'Type': ['is_string', 'is_number', 'is_boolean', 'is_array', 'is_object'],
+  };
+}
+
+/**
+ * Format condition for display (edge label).
+ */
+export function formatConditionLabel(condition: EdgeCondition): string {
+  const op = OPERATORS[condition.operator];
+  if (!op) return '';
+
+  if (!op.requiresValue) {
+    return `${condition.field} ${op.label.toLowerCase()}`;
+  }
+
+  const valueStr = Array.isArray(condition.value)
+    ? `[${condition.value.join(', ')}]`
+    : String(condition.value);
+
+  return `${condition.field} ${op.label.toLowerCase()} ${valueStr}`;
+}
+
+/**
+ * Validate a condition object.
+ */
+export function validateCondition(condition: EdgeCondition): { valid: boolean; error?: string } {
+  if (!condition.field || condition.field.trim() === '') {
+    return { valid: false, error: 'Field is required' };
+  }
+
+  if (!condition.operator || !OPERATORS[condition.operator]) {
+    return { valid: false, error: 'Invalid operator' };
+  }
+
+  const op = OPERATORS[condition.operator];
+  if (op.requiresValue && (condition.value === undefined || condition.value === '')) {
+    return { valid: false, error: 'Value is required for this operator' };
+  }
+
+  return { valid: true };
+}

package/client/src/types/INodeProperties.ts

@@ -0,0 +1,288 @@
+// Modern n8n-inspired node property system
+// Clean implementation with n8n-compatible data flow
+
+// ============================================================================
+// DATA FLOW INTERFACES - n8n-compatible data passing between nodes
+// ============================================================================
+
+// Binary data interface for files, images, documents, etc.
+export interface IBinaryData {
+  mimeType: string;
+  fileName?: string;
+  directory?: string;
+  fileExtension?: string;
+  fileSize?: number;
+  data: string; // Base64 encoded data
+  id?: string;
+}
+
+// Core data structure that flows between nodes (n8n-compatible)
+export interface INodeExecutionData {
+  json: Record<string, any>; // Main JSON data
+  binary?: Record<string, IBinaryData>; // Binary attachments (files, images, etc.)
+  pairedItem?: {
+    item: number;
+    input?: number;
+  };
+  error?: Error;
+}
+
+// Input/Output connection types
+export type NodeConnectionType = 
+  | 'main'      // Standard data connection
+  | 'trigger'   // Trigger/start connection
+  | 'ai'        // AI service responses
+  | 'file'      // File data
+  | 'binary'    // Binary data specific
+  | 'webhook';  // Webhook data
+
+// Enhanced output definition with data structure info
+export interface INodeOutputDefinition {
+  name: string;
+  displayName: string;
+  type: NodeConnectionType;
+  description: string;
+  maxConnections?: number; // How many nodes can connect to this output
+  dataStructure?: {
+    // Expected JSON structure this output provides
+    properties: Record<string, {
+      type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+      description?: string;
+      required?: boolean;
+    }>;
+    binaryData?: boolean; // Whether this output includes binary data
+  };
+}
+
+// Enhanced input definition  
+export interface INodeInputDefinition {
+  name: string;
+  displayName: string;
+  type: NodeConnectionType;
+  description: string;
+  required?: boolean;
+  maxConnections?: number; // How many connections this input accepts
+  acceptedDataTypes?: string[]; // What kind of data this input can handle
+}
+
+// ============================================================================
+// PROPERTY DEFINITION INTERFACES
+// ============================================================================
+
+export interface INodePropertyOption {
+  name: string;
+  value: string | number | boolean;
+  label?: string;
+  description?: string;
+  action?: string;
+}
+
+export interface INodePropertyCollection {
+  displayName: string;
+  name: string;
+  values: INodeProperties[];
+}
+
+export interface INodePropertyTypeOptions {
+  loadOptionsMethod?: string;
+  loadOptionsDependsOn?: string[];
+  multipleValues?: boolean;
+  multipleValueButtonText?: string;
+  maxValue?: number;
+  minValue?: number;
+  numberStepSize?: number;
+  password?: boolean;
+  rows?: number;
+  editor?: 'code' | 'json' | 'html' | 'sql';
+  editorLanguage?: string;
+  // Dynamic parameter options
+  dynamicOptions?: boolean;
+  dependsOn?: string[];
+  // File input options
+  accept?: string; // MIME types or file extensions (e.g., 'image/*', '.pdf,.doc')
+}
+
+export interface INodePropertyDisplayOptions {
+  show?: Record<string, any[]>;
+  hide?: Record<string, any[]>;
+}
+
+export interface INodePropertyValidation {
+  type?: 'regex' | 'email' | 'url' | 'json' | 'apiKey';
+  pattern?: string;
+  message?: string;
+  // API Key validation specific properties
+  provider?: string;
+  showValidateButton?: boolean;
+}
+
+// Core property interface - modern n8n-inspired design
+export interface INodeProperties {
+  displayName: string;
+  name: string;
+  type:
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'options'
+    | 'multiOptions'
+    | 'collection'
+    | 'fixedCollection'
+    | 'color'
+    | 'dateTime'
+    | 'json'
+    | 'notice'
+    | 'hidden'
+    | 'resourceLocator'
+    | 'code'
+    | 'file';
+  
+  default?: any;
+  description?: string;
+  placeholder?: string;
+  required?: boolean;
+  noDataExpression?: boolean;
+  
+  options?: INodePropertyOption[] | INodePropertyCollection[];
+  typeOptions?: INodePropertyTypeOptions;
+  displayOptions?: INodePropertyDisplayOptions;
+  validation?: INodePropertyValidation[];
+}
+
+export interface INodeCredentialDescription {
+  name: string;
+  required?: boolean;
+  displayName?: string;
+}
+
+// Resource definition for Resource-Operation pattern
+export interface INodeResourceDefinition {
+  name: string;
+  displayName: string;
+  icon?: string;
+  description?: string;
+  operations: INodeOperationDefinition[];
+}
+
+export interface INodeOperationDefinition {
+  name: string;
+  displayName: string;
+  description?: string;
+  action?: string;
+  properties: INodeProperties[];
+}
+
+
+// Main node type description interface
+export interface INodeTypeDescription {
+  displayName: string;
+  name: string;
+  icon: string;
+  group: string[];
+  version: number;
+  subtitle?: string;
+  description: string;
+  keywords?: string[];
+  defaults: {
+    name: string;
+    color?: string;
+  };
+  inputs: string[] | INodeInputDefinition[];
+  outputs: string[] | INodeOutputDefinition[];
+  properties: INodeProperties[];
+  credentials?: INodeCredentialDescription[];
+  resources?: INodeResourceDefinition[];
+  methods?: {
+    loadOptions?: Record<string, (this: any) => Promise<INodePropertyOption[]>>;
+  };
+}
+
+// Node type interface that nodes must implement
+export interface INodeType {
+  description: INodeTypeDescription;
+  methods?: {
+    loadOptions?: Record<string, () => Promise<INodePropertyOption[]>>;
+  };
+  execute?(inputData: INodeExecutionData[][]): Promise<INodeExecutionData[][]>;
+}
+
+// Execution context for nodes
+export interface IExecuteContext {
+  nodeId: string;
+  nodeType?: string; // Add nodeType to context
+  parameters: Record<string, any>;
+  inputData: INodeExecutionData[][];
+  workflow: {
+    id: string;
+    name: string;
+  };
+  connectionType?: NodeConnectionType;
+}
+
+// ============================================================================  
+// HELPER FUNCTIONS FOR DATA FLOW
+// ============================================================================
+
+// Helper to create execution data in n8n format
+export function createNodeExecutionData(json: Record<string, any>, binary?: Record<string, IBinaryData>): INodeExecutionData {
+  return {
+    json,
+    binary,
+    pairedItem: { item: 0 }
+  };
+}
+
+// Helper to create simple text output
+export function createTextOutput(text: string, additionalData?: Record<string, any>): INodeExecutionData[] {
+  return [{
+    json: {
+      text,
+      ...additionalData
+    }
+  }];
+}
+
+// Helper to create file output
+export function createFileOutput(filePath: string, fileName: string, mimeType: string, additionalData?: Record<string, any>): INodeExecutionData[] {
+  return [{
+    json: {
+      fileName,
+      filePath,
+      mimeType,
+      ...additionalData
+    },
+    binary: {
+      file: {
+        data: '', // Would be populated with actual file data
+        fileName,
+        mimeType,
+        fileSize: 0
+      }
+    }
+  }];
+}
+
+// Helper to create AI response output
+export function createAIOutput(response: string, model: string, usage?: any, additionalData?: Record<string, any>): INodeExecutionData[] {
+  return [{
+    json: {
+      response,
+      model,
+      usage,
+      timestamp: new Date().toISOString(),
+      ...additionalData
+    }
+  }];
+}
+
+// Helper to create location output
+export function createLocationOutput(latitude: number, longitude: number, additionalData?: Record<string, any>): INodeExecutionData[] {
+  return [{
+    json: {
+      latitude,
+      longitude,
+      timestamp: new Date().toISOString(),
+      ...additionalData
+    }
+  }];
+}

package/client/src/types/NodeTypes.ts

@@ -0,0 +1,28 @@
+export interface NodeParameter {
+  name: string;
+  displayName: string;
+  type: 'string' | 'number' | 'boolean' | 'select' | 'slider' | 'percentage' | 'file' | 'text' | 'array' | 'options' | 'multiOptions' | 'collection' | 'fixedCollection' | 'color' | 'dateTime' | 'notice' | 'hidden' | 'resourceLocator' | 'code' | 'json';
+  default?: any;
+  placeholder?: string;
+  description?: string;
+  options?: Array<{ value: any; label?: string; name?: string }>;
+  min?: number;
+  max?: number;
+  step?: number;
+  required?: boolean;
+}
+
+export interface NodeOutput {
+  name: string;
+  displayName: string;
+  type: 'string' | 'number' | 'boolean' | 'file' | 'array' | 'object' | string;
+  description: string;
+}
+
+
+export interface NodeData {
+  label?: string;
+  disabled?: boolean; // Skip execution when true (n8n-style disable)
+  customIcon?: string; // Custom icon: emoji, text, or image URL (http://, https://, data:, or /)
+  [key: string]: any;
+}

package/client/src/utils/formatters.ts

@@ -0,0 +1,33 @@
+// Common utility functions for formatting and clipboard operations
+import { message } from 'antd';
+
+/**
+ * Copy text to clipboard with error handling
+ */
+export const copyToClipboard = async (data: any, successMessage?: string): Promise<boolean> => {
+  try {
+    const text = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+    await navigator.clipboard.writeText(text);
+    if (successMessage) {
+      message.success(successMessage);
+    }
+    return true;
+  } catch (error) {
+    console.error('Failed to copy to clipboard:', error);
+    return false;
+  }
+};
+
+/**
+ * Format object as JSON string
+ */
+export const formatJson = (obj: any, compact: boolean = false): string => {
+  return JSON.stringify(obj, null, compact ? 0 : 2);
+};
+
+/**
+ * Format timestamp to locale string
+ */
+export const formatTimestamp = (timestamp: string | number | Date): string => {
+  return new Date(timestamp).toLocaleString();
+};