claude-flow-novice 2.2.3 → 2.2.5

package/scripts/dev/stop-portal.sh

@@ -0,0 +1,311 @@
+#!/bin/bash
+
+# Claude Flow Personal Web Portal Stop Script
+# Graceful shutdown script for the web portal system
+
+set -euo pipefail
+
+# Configuration
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+PID_FILE="$PROJECT_ROOT/.portal.pid"
+FRONTEND_PID_FILE="$PROJECT_ROOT/.frontend.pid"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Logging
+log() {
+    echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
+}
+
+warn() {
+    echo -e "${YELLOW}[$(date +'%Y-%m-%d %H:%M:%S')] WARNING:${NC} $1"
+}
+
+error() {
+    echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] ERROR:${NC} $1"
+}
+
+info() {
+    echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')] INFO:${NC} $1"
+}
+
+# Function to check if a command exists
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+# Function to stop portal processes
+stop_portal() {
+    log "🛑 Stopping Claude Flow Personal Web Portal..."
+
+    local processes_stopped=false
+
+    # Stop PM2 processes first
+    if command_exists pm2; then
+        if pm2 list 2>/dev/null | grep -q "claude-flow-portal"; then
+            info "Stopping PM2 process: claude-flow-portal"
+            pm2 stop claude-flow-portal 2>/dev/null || warn "Failed to stop PM2 process"
+            pm2 delete claude-flow-portal 2>/dev/null || warn "Failed to delete PM2 process"
+            processes_stopped=true
+        fi
+    fi
+
+    # Stop main portal server process
+    if [[ -f "$PID_FILE" ]]; then
+        local portal_pid
+        portal_pid=$(cat "$PID_FILE")
+
+        if kill -0 "$portal_pid" 2>/dev/null; then
+            info "Stopping portal server process (PID: $portal_pid)..."
+            kill -TERM "$portal_pid" 2>/dev/null || kill -KILL "$portal_pid" 2>/dev/null || true
+
+            # Wait for graceful shutdown
+            for i in {1..10}; do
+                if ! kill -0 "$portal_pid" 2>/dev/null; then
+                    break
+                fi
+                sleep 1
+            done
+
+            # Force kill if still running
+            if kill -0 "$portal_pid" 2>/dev/null; then
+                warn "Force killing portal server process..."
+                kill -KILL "$portal_pid" 2>/dev/null || true
+            fi
+
+            processes_stopped=true
+        fi
+
+        rm -f "$PID_FILE"
+    fi
+
+    # Stop frontend development server
+    if [[ -f "$FRONTEND_PID_FILE" ]]; then
+        local frontend_pid
+        frontend_pid=$(cat "$FRONTEND_PID_FILE")
+
+        if kill -0 "$frontend_pid" 2>/dev/null; then
+            info "Stopping frontend development server (PID: $frontend_pid)..."
+            kill -TERM "$frontend_pid" 2>/dev/null || kill -KILL "$frontend_pid" 2>/dev/null || true
+            processes_stopped=true
+        fi
+
+        rm -f "$FRONTEND_PID_FILE"
+    fi
+
+    # Kill any remaining processes by name
+    local portal_processes
+    portal_processes=$(pgrep -f "portal-server" 2>/dev/null || true)
+    if [[ -n "$portal_processes" ]]; then
+        info "Stopping remaining portal server processes..."
+        echo "$portal_processes" | xargs -r kill -TERM 2>/dev/null || true
+        sleep 2
+        echo "$portal_processes" | xargs -r kill -KILL 2>/dev/null || true
+        processes_stopped=true
+    fi
+
+    # Kill any remaining React development servers
+    local react_processes
+    react_processes=$(pgrep -f "react-scripts" 2>/dev/null || true)
+    if [[ -n "$react_processes" ]]; then
+        info "Stopping React development servers..."
+        echo "$react_processes" | xargs -r kill -TERM 2>/dev/null || true
+        sleep 2
+        echo "$react_processes" | xargs -r kill -KILL 2>/dev/null || true
+        processes_stopped=true
+    fi
+
+    if [[ "$processes_stopped" == true ]]; then
+        log "✅ Portal processes stopped successfully"
+    else
+        warn "No running portal processes found"
+    fi
+}
+
+# Function to execute coordination hooks
+execute_shutdown_hooks() {
+    log "🪝 Executing shutdown coordination hooks..."
+
+    # Session-end hook for portal shutdown
+    if command_exists npx && npx claude-flow@alpha --version >/dev/null 2>&1; then
+        info "Executing Claude Flow session-end hook..."
+        npx claude-flow@alpha hooks session-end \
+            --export-metrics true \
+            --save-state true \
+            --reason "manual-shutdown" || warn "Session-end hook failed"
+    else
+        warn "Claude Flow not available, skipping coordination hooks"
+    fi
+
+    log "✅ Shutdown hooks complete"
+}
+
+# Function to cleanup temporary files
+cleanup_files() {
+    log "🧹 Cleaning up temporary files..."
+
+    # Remove PID files
+    rm -f "$PID_FILE" "$FRONTEND_PID_FILE"
+
+    # Clean up temporary directories if they exist and are empty
+    local temp_dirs=("$PROJECT_ROOT/.tmp" "$PROJECT_ROOT/tmp")
+    for dir in "${temp_dirs[@]}"; do
+        if [[ -d "$dir" ]] && [[ -z "$(ls -A "$dir" 2>/dev/null)" ]]; then
+            rmdir "$dir" 2>/dev/null || true
+        fi
+    done
+
+    log "✅ Cleanup complete"
+}
+
+# Function to show status
+show_status() {
+    log "📊 Portal Status Check"
+    echo ""
+
+    # Check for running processes
+    local portal_running=false
+    local frontend_running=false
+
+    if [[ -f "$PID_FILE" ]]; then
+        local portal_pid
+        portal_pid=$(cat "$PID_FILE")
+        if kill -0 "$portal_pid" 2>/dev/null; then
+            info "✅ Portal server running (PID: $portal_pid)"
+            portal_running=true
+        else
+            warn "❌ Portal server not running (stale PID file)"
+            rm -f "$PID_FILE"
+        fi
+    fi
+
+    if [[ -f "$FRONTEND_PID_FILE" ]]; then
+        local frontend_pid
+        frontend_pid=$(cat "$FRONTEND_PID_FILE")
+        if kill -0 "$frontend_pid" 2>/dev/null; then
+            info "✅ Frontend dev server running (PID: $frontend_pid)"
+            frontend_running=true
+        else
+            warn "❌ Frontend dev server not running (stale PID file)"
+            rm -f "$FRONTEND_PID_FILE"
+        fi
+    fi
+
+    # Check PM2 processes
+    if command_exists pm2; then
+        if pm2 list 2>/dev/null | grep -q "claude-flow-portal"; then
+            info "✅ PM2 process running"
+            portal_running=true
+        fi
+    fi
+
+    # Check by process name
+    if pgrep -f "portal-server" >/dev/null 2>&1; then
+        info "✅ Portal server process found"
+        portal_running=true
+    fi
+
+    if pgrep -f "react-scripts" >/dev/null 2>&1; then
+        info "✅ React dev server process found"
+        frontend_running=true
+    fi
+
+    echo ""
+    if [[ "$portal_running" == false ]] && [[ "$frontend_running" == false ]]; then
+        log "🔴 No portal processes running"
+    else
+        log "🟢 Portal processes are running"
+    fi
+}
+
+# Function to show help
+show_help() {
+    cat << EOF
+Claude Flow Personal Web Portal Stop Script
+
+Usage: $0 [OPTIONS]
+
+Options:
+    -h, --help      Show this help message
+    -s, --status    Show portal status without stopping
+    -f, --force     Force kill all processes
+    --skip-hooks    Skip coordination hooks
+    --verbose       Enable verbose logging
+
+Examples:
+    $0              # Stop portal gracefully
+    $0 --status     # Check portal status
+    $0 --force      # Force stop all processes
+
+For more information, visit:
+    https://github.com/ruvnet/claude-flow
+EOF
+}
+
+# Parse command line arguments
+FORCE_STOP=false
+SKIP_HOOKS=false
+VERBOSE=false
+STATUS_ONLY=false
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        -s|--status)
+            STATUS_ONLY=true
+            shift
+            ;;
+        -f|--force)
+            FORCE_STOP=true
+            shift
+            ;;
+        --skip-hooks)
+            SKIP_HOOKS=true
+            shift
+            ;;
+        --verbose)
+            VERBOSE=true
+            set -x
+            shift
+            ;;
+        *)
+            error "Unknown option: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+# Main execution
+main() {
+    if [[ "$STATUS_ONLY" == true ]]; then
+        show_status
+        exit 0
+    fi
+
+    log "🛑 Claude Flow Personal Web Portal Shutdown"
+    echo ""
+
+    if [[ "$SKIP_HOOKS" != true ]]; then
+        execute_shutdown_hooks
+    else
+        warn "Skipping coordination hooks as requested"
+    fi
+
+    stop_portal
+    cleanup_files
+
+    log "✅ Claude Flow Personal Web Portal stopped successfully"
+}
+
+# Run main function
+main "$@"

package/scripts/dev/validate-examples.ts

@@ -0,0 +1,288 @@
+#!/usr/bin/env deno run --allow-read
+
+/**
+ * Example Configuration Validator
+ * Validates all example configuration files for correctness
+ */
+
+import { walk } from "https://deno.land/std@0.220.0/fs/mod.ts";
+
+interface ValidationResult {
+  file: string;
+  valid: boolean;
+  errors: string[];
+}
+
+interface ConfigSchema {
+  [key: string]: {
+    type: string;
+    required?: boolean;
+    properties?: ConfigSchema;
+  };
+}
+
+const CLAUDE_FLOW_CONFIG_SCHEMA: ConfigSchema = {
+  orchestrator: {
+    type: 'object',
+    required: true,
+    properties: {
+      maxConcurrentAgents: { type: 'number' },
+      taskQueueSize: { type: 'number' },
+      healthCheckInterval: { type: 'number' },
+      shutdownTimeout: { type: 'number' },
+    },
+  },
+  terminal: {
+    type: 'object',
+    properties: {
+      type: { type: 'string' },
+      poolSize: { type: 'number' },
+      recycleAfter: { type: 'number' },
+      healthCheckInterval: { type: 'number' },
+      commandTimeout: { type: 'number' },
+    },
+  },
+  memory: {
+    type: 'object',
+    properties: {
+      backend: { type: 'string' },
+      cacheSizeMB: { type: 'number' },
+      syncInterval: { type: 'number' },
+      conflictResolution: { type: 'string' },
+      retentionDays: { type: 'number' },
+    },
+  },
+  coordination: {
+    type: 'object',
+    properties: {
+      maxRetries: { type: 'number' },
+      retryDelay: { type: 'number' },
+      deadlockDetection: { type: 'boolean' },
+      resourceTimeout: { type: 'number' },
+      messageTimeout: { type: 'number' },
+    },
+  },
+  mcp: {
+    type: 'object',
+    properties: {
+      transport: { type: 'string' },
+      port: { type: 'number' },
+      tlsEnabled: { type: 'boolean' },
+    },
+  },
+  logging: {
+    type: 'object',
+    properties: {
+      level: { type: 'string' },
+      format: { type: 'string' },
+      destination: { type: 'string' },
+    },
+  },
+};
+
+const WORKFLOW_SCHEMA: ConfigSchema = {
+  name: { type: 'string', required: true },
+  description: { type: 'string' },
+  tasks: {
+    type: 'array',
+    required: true,
+    properties: {
+      id: { type: 'string', required: true },
+      type: { type: 'string', required: true },
+      description: { type: 'string', required: true },
+      dependencies: { type: 'array' },
+      assignTo: { type: 'string' },
+      priority: { type: 'string' },
+      timeout: { type: 'number' },
+    },
+  },
+};
+
+function validateType(value: any, expectedType: string): boolean {
+  switch (expectedType) {
+    case 'string':
+      return typeof value === 'string';
+    case 'number':
+      return typeof value === 'number';
+    case 'boolean':
+      return typeof value === 'boolean';
+    case 'array':
+      return Array.isArray(value);
+    case 'object':
+      return typeof value === 'object' && value !== null && !Array.isArray(value);
+    default:
+      return false;
+  }
+}
+
+function validateObject(obj: any, schema: ConfigSchema, path = ''): string[] {
+  const errors: string[] = [];
+  
+  // Check required fields
+  for (const [key, spec] of Object.entries(schema)) {
+    if (spec.required && !(key in obj)) {
+      errors.push(`${path}${key} is required but missing`);
+      continue;
+    }
+    
+    if (key in obj) {
+      const value = obj[key];
+      const currentPath = path ? `${path}${key}.` : `${key}.`;
+      
+      if (!validateType(value, spec.type)) {
+        errors.push(`${path}${key} should be of type ${spec.type}, got ${typeof value}`);
+        continue;
+      }
+      
+      // Validate nested objects
+      if (spec.type === 'object' && spec.properties) {
+        errors.push(...validateObject(value, spec.properties, currentPath));
+      }
+      
+      // Validate array items
+      if (spec.type === 'array' && spec.properties && Array.isArray(value)) {
+        value.forEach((item, index) => {
+          if (typeof item === 'object') {
+            errors.push(...validateObject(item, spec.properties!, `${currentPath}[${index}].`));
+          }
+        });
+      }
+    }
+  }
+  
+  return errors;
+}
+
+function validateClaudeFlowConfig(config: any): string[] {
+  return validateObject(config, CLAUDE_FLOW_CONFIG_SCHEMA);
+}
+
+function validateWorkflow(workflow: any): string[] {
+  const errors = validateObject(workflow, WORKFLOW_SCHEMA);
+  
+  // Additional workflow-specific validations
+  if (workflow.tasks && Array.isArray(workflow.tasks)) {
+    const taskIds = new Set<string>();
+    
+    for (const [index, task] of workflow.tasks.entries()) {
+      // Check for duplicate task IDs
+      if (taskIds.has(task.id)) {
+        errors.push(`Duplicate task ID "${task.id}" found at index ${index}`);
+      } else {
+        taskIds.add(task.id);
+      }
+      
+      // Validate dependencies reference existing tasks
+      if (task.dependencies && Array.isArray(task.dependencies)) {
+        for (const dep of task.dependencies) {
+          if (!taskIds.has(dep) && !workflow.tasks.slice(0, index).some((t: any) => t.id === dep)) {
+            errors.push(`Task "${task.id}" depends on non-existent task "${dep}"`);
+          }
+        }
+      }
+      
+      // Validate priority values
+      if (task.priority && !['low', 'medium', 'high', 'critical'].includes(task.priority)) {
+        errors.push(`Task "${task.id}" has invalid priority "${task.priority}"`);
+      }
+      
+      // Validate timeout is positive
+      if (task.timeout && task.timeout <= 0) {
+        errors.push(`Task "${task.id}" has invalid timeout ${task.timeout}`);
+      }
+    }
+  }
+  
+  return errors;
+}
+
+async function validateFile(filePath: string): Promise<ValidationResult> {
+  const result: ValidationResult = {
+    file: filePath,
+    valid: false,
+    errors: [],
+  };
+  
+  try {
+    const content = await Deno.readTextFile(filePath);
+    const config = JSON.parse(content);
+    
+    // Determine validation type based on file name/content
+    if (filePath.includes('workflow') || config.tasks) {
+      result.errors = validateWorkflow(config);
+    } else if (filePath.includes('config') || config.orchestrator) {
+      result.errors = validateClaudeFlowConfig(config);
+    } else {
+      result.errors.push('Unknown configuration file type');
+    }
+    
+    result.valid = result.errors.length === 0;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      result.errors.push(`Invalid JSON: ${error.message}`);
+    } else {
+      result.errors.push(`Failed to read file: ${error.message}`);
+    }
+  }
+  
+  return result;
+}
+
+async function main(): Promise<void> {
+  console.log('Validating example configurations...\n');
+  
+  const results: ValidationResult[] = [];
+  
+  // Find all JSON files in examples directory
+  for await (const entry of walk('./examples', { exts: ['.json'] })) {
+    if (entry.isFile) {
+      const result = await validateFile(entry.path);
+      results.push(result);
+    }
+  }
+  
+  // Also check any config files in the root
+  const rootConfigFiles = ['claude-flow.config.json', 'config.json'];
+  for (const filename of rootConfigFiles) {
+    try {
+      await Deno.stat(filename);
+      const result = await validateFile(filename);
+      results.push(result);
+    } catch {
+      // File doesn't exist, skip
+    }
+  }
+  
+  if (results.length === 0) {
+    console.log('No configuration files found to validate.');
+    return;
+  }
+  
+  // Report results
+  let hasErrors = false;
+  
+  for (const result of results) {
+    if (result.valid) {
+      console.log(`✅ ${result.file}: Valid`);
+    } else {
+      console.log(`❌ ${result.file}: Invalid`);
+      for (const error of result.errors) {
+        console.log(`   - ${error}`);
+      }
+      hasErrors = true;
+    }
+  }
+  
+  console.log(`\nValidated ${results.length} configuration files.`);
+  
+  if (hasErrors) {
+    console.error('❌ Some configuration files have errors!');
+    Deno.exit(1);
+  } else {
+    console.log('✅ All configuration files are valid!');
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}