claude-flow-novice 2.3.4 → 2.3.6

package/dist/scripts/dev/stop-portal.sh

@@ -1,311 +0,0 @@
-#!/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/dist/scripts/dev/validate-examples.ts

@@ -1,288 +0,0 @@
-#!/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();
-}