@10et/cli 1.0.0

package/scripts/vm-swarm/monitor-fleet.sh

@@ -0,0 +1,346 @@
+#!/bin/bash
+#
+# monitor-fleet.sh — Monitor status of running agent fleet
+#
+# Shows status, current task, and scores for each VM in the fleet.
+# Can run in continuous mode for live monitoring.
+#
+# Usage:
+#   ./monitor-fleet.sh              # One-time status check
+#   ./monitor-fleet.sh --watch      # Continuous monitoring (2s refresh)
+#   ./monitor-fleet.sh --watch 5    # Custom refresh interval
+#   ./monitor-fleet.sh --verbose    # Show more details per VM
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+LOG_DIR="$PROJECT_ROOT/.jfl/vm-fleet"
+
+# Options
+WATCH_MODE=false
+REFRESH_INTERVAL=2
+VERBOSE=false
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+DIM='\033[2m'
+NC='\033[0m'
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case "$1" in
+        --watch|-w)
+            WATCH_MODE=true
+            if [[ "${2:-}" =~ ^[0-9]+$ ]]; then
+                REFRESH_INTERVAL="$2"
+                shift
+            fi
+            shift
+            ;;
+        --verbose|-v)
+            VERBOSE=true
+            shift
+            ;;
+        --help|-h)
+            echo "Usage: $0 [options]"
+            echo ""
+            echo "Options:"
+            echo "  --watch, -w [seconds]  Continuous monitoring (default: 2s)"
+            echo "  --verbose, -v          Show more details per VM"
+            echo ""
+            exit 0
+            ;;
+        *)
+            echo "Unknown option: $1"
+            exit 1
+            ;;
+    esac
+done
+
+# Get all agent VMs (running and stopped)
+get_all_vms() {
+    prlctl list --all -o name,status 2>/dev/null | grep 'jfl-agent-' | sort -V
+}
+
+# Get VM status
+get_vm_status() {
+    local vm_name=$1
+    prlctl status "$vm_name" 2>/dev/null | grep -oE 'running|stopped|suspended|paused' || echo "unknown"
+}
+
+# Get task info from running tasks file
+get_task_info() {
+    local vm_name=$1
+
+    if [[ -f "$LOG_DIR/running-tasks" ]]; then
+        grep "^$vm_name:" "$LOG_DIR/running-tasks" 2>/dev/null | cut -d: -f2- | head -1
+    else
+        echo "-"
+    fi
+}
+
+# Get latest score/progress from VM
+get_vm_score() {
+    local vm_name=$1
+    local status=$2
+
+    if [[ "$status" != "running" ]]; then
+        echo "-"
+        return
+    fi
+
+    # Try to get score from training buffer or eval results
+    local score
+    score=$(prlctl exec "$vm_name" /bin/bash -c '
+        if [[ -f /workspace/jfl-cli/.jfl/training-buffer.jsonl ]]; then
+            tail -1 /workspace/jfl-cli/.jfl/training-buffer.jsonl 2>/dev/null | \
+                grep -oE "composite_delta\":[0-9.-]+" | cut -d: -f2 | head -1
+        fi
+    ' 2>/dev/null || echo "")
+
+    if [[ -n "$score" ]]; then
+        echo "$score"
+    else
+        echo "-"
+    fi
+}
+
+# Get tuple count from VM
+get_tuple_count() {
+    local vm_name=$1
+    local status=$2
+
+    if [[ "$status" != "running" ]]; then
+        echo "-"
+        return
+    fi
+
+    local count
+    count=$(prlctl exec "$vm_name" /bin/bash -c '
+        if [[ -f /workspace/jfl-cli/.jfl/training-buffer.jsonl ]]; then
+            wc -l < /workspace/jfl-cli/.jfl/training-buffer.jsonl 2>/dev/null | tr -d " "
+        else
+            echo "0"
+        fi
+    ' 2>/dev/null || echo "0")
+
+    echo "$count"
+}
+
+# Get process status in VM
+get_process_status() {
+    local vm_name=$1
+
+    prlctl exec "$vm_name" /bin/bash -c '
+        # Check for running jfl/node processes
+        procs=$(ps aux | grep -E "jfl|node|npm" | grep -v grep | wc -l | tr -d " ")
+        echo "$procs processes"
+    ' 2>/dev/null || echo "?"
+}
+
+# Format status with color
+format_status() {
+    local status=$1
+
+    case "$status" in
+        running)
+            echo -e "${GREEN}●${NC} running"
+            ;;
+        stopped)
+            echo -e "${RED}○${NC} stopped"
+            ;;
+        suspended)
+            echo -e "${YELLOW}◐${NC} suspended"
+            ;;
+        paused)
+            echo -e "${YELLOW}◑${NC} paused"
+            ;;
+        *)
+            echo -e "${DIM}?${NC} $status"
+            ;;
+    esac
+}
+
+# Format score with color
+format_score() {
+    local score=$1
+
+    if [[ "$score" == "-" ]]; then
+        echo -e "${DIM}${score}${NC}"
+        return
+    fi
+
+    # Color based on positive/negative
+    if [[ "$score" =~ ^- ]]; then
+        echo -e "${RED}${score}${NC}"
+    else
+        echo -e "${GREEN}+${score}${NC}"
+    fi
+}
+
+# Print header
+print_header() {
+    clear
+    echo ""
+    echo -e "${BOLD}═══════════════════════════════════════════════════════════${NC}"
+    echo -e "${BOLD}  JFL Agent Fleet Monitor${NC}"
+    echo -e "${BOLD}═══════════════════════════════════════════════════════════${NC}"
+    echo ""
+
+    # Show fleet start time if available
+    if [[ -f "$LOG_DIR/fleet-started" ]]; then
+        local started
+        started=$(cat "$LOG_DIR/fleet-started")
+        echo -e "  ${DIM}Fleet started: $started${NC}"
+        echo ""
+    fi
+}
+
+# Print fleet summary
+print_summary() {
+    local vms=$1
+
+    local total=0
+    local running=0
+    local stopped=0
+
+    while IFS= read -r line; do
+        [[ -n "$line" ]] || continue
+        total=$((total + 1))
+
+        if echo "$line" | grep -q 'running'; then
+            running=$((running + 1))
+        else
+            stopped=$((stopped + 1))
+        fi
+    done <<< "$vms"
+
+    echo -e "  ${CYAN}Total VMs:${NC} $total  ${GREEN}Running:${NC} $running  ${RED}Stopped:${NC} $stopped"
+    echo ""
+}
+
+# Print VM table
+print_vm_table() {
+    local vms=$1
+
+    # Table header
+    printf "  ${BOLD}%-16s %-14s %-20s %-10s %-8s${NC}\n" \
+        "VM" "STATUS" "TASK" "SCORE" "TUPLES"
+    echo -e "  ${DIM}$(printf '─%.0s' {1..70})${NC}"
+
+    while IFS= read -r line; do
+        [[ -n "$line" ]] || continue
+
+        local vm_name
+        vm_name=$(echo "$line" | awk '{print $1}')
+        local status
+        status=$(echo "$line" | awk '{print $NF}')
+
+        local task_info
+        task_info=$(get_task_info "$vm_name")
+        local score
+        score=$(get_vm_score "$vm_name" "$status")
+        local tuples
+        tuples=$(get_tuple_count "$vm_name" "$status")
+
+        # Truncate task info if too long
+        if [[ ${#task_info} -gt 18 ]]; then
+            task_info="${task_info:0:15}..."
+        fi
+
+        printf "  %-16s " "$vm_name"
+        printf "%-14b " "$(format_status "$status")"
+        printf "%-20s " "$task_info"
+        printf "%-10b " "$(format_score "$score")"
+        printf "%-8s\n" "$tuples"
+
+        # Verbose mode: show more details
+        if [[ "$VERBOSE" == true ]] && [[ "$status" == "running" ]]; then
+            local procs
+            procs=$(get_process_status "$vm_name")
+            echo -e "    ${DIM}├─ Processes: $procs${NC}"
+
+            if [[ -f "$LOG_DIR/vm-${vm_name##*-}.log" ]]; then
+                local last_log
+                last_log=$(tail -1 "$LOG_DIR/vm-${vm_name##*-}.log" 2>/dev/null | cut -c1-60)
+                if [[ -n "$last_log" ]]; then
+                    echo -e "    ${DIM}└─ Last log: ${last_log}...${NC}"
+                fi
+            fi
+        fi
+
+    done <<< "$vms"
+}
+
+# Print actions
+print_actions() {
+    echo ""
+    echo -e "  ${DIM}Actions:${NC}"
+    echo -e "    ${CYAN}c${NC} - Collect tuples    ${CYAN}k${NC} - Kill fleet"
+    echo -e "    ${CYAN}l${NC} - View logs         ${CYAN}q${NC} - Quit"
+    echo ""
+}
+
+# Print footer in watch mode
+print_footer() {
+    echo ""
+    echo -e "  ${DIM}Refreshing every ${REFRESH_INTERVAL}s. Press Ctrl+C to exit.${NC}"
+}
+
+# Main display function
+display() {
+    local vms
+    vms=$(get_all_vms)
+
+    print_header
+
+    if [[ -z "$vms" ]]; then
+        echo -e "  ${YELLOW}No jfl-agent VMs found${NC}"
+        echo ""
+        echo "  Start a fleet:"
+        echo "    ./spawn-fleet.sh 5 jfl-agent-base autoresearch"
+        echo ""
+        return
+    fi
+
+    print_summary "$vms"
+    print_vm_table "$vms"
+
+    if [[ "$WATCH_MODE" != true ]]; then
+        print_actions
+    else
+        print_footer
+    fi
+}
+
+# Watch mode loop
+watch_loop() {
+    trap 'echo ""; echo "Exiting..."; exit 0' INT
+
+    while true; do
+        display
+        sleep "$REFRESH_INTERVAL"
+    done
+}
+
+main() {
+    if ! command -v prlctl &> /dev/null; then
+        echo "prlctl not found. Install Parallels Desktop Pro."
+        exit 1
+    fi
+
+    if [[ "$WATCH_MODE" == true ]]; then
+        watch_loop
+    else
+        display
+    fi
+}
+
+main

package/scripts/vm-swarm/spawn-fleet.sh

@@ -0,0 +1,304 @@
+#!/bin/bash
+#
+# spawn-fleet.sh — Spawn a fleet of agent VMs from base template
+#
+# Clones the base template N times and runs specified task type in each.
+#
+# Usage:
+#   ./spawn-fleet.sh [count] [template] [task-type]
+#   ./spawn-fleet.sh 5 jfl-agent-base autoresearch
+#   ./spawn-fleet.sh 3 jfl-agent-base fuzz
+#   ./spawn-fleet.sh 2 jfl-agent-base eval
+#
+# Task types:
+#   autoresearch - Each VM gets a different repo/service to research
+#   fuzz         - Each VM runs a different fuzz test suite
+#   eval         - Each VM runs evaluation with different parameters
+#
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+LOG_DIR="$PROJECT_ROOT/.jfl/vm-fleet"
+
+# Defaults
+DEFAULT_COUNT=5
+DEFAULT_TEMPLATE="jfl-agent-base"
+DEFAULT_TASK="autoresearch"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+CYAN='\033[0;36m'
+NC='\033[0m'
+
+log() { echo -e "${BLUE}[$(date '+%H:%M:%S')]${NC} $1"; }
+success() { echo -e "${GREEN}[$(date '+%H:%M:%S')] ✓${NC} $1"; }
+warn() { echo -e "${YELLOW}[$(date '+%H:%M:%S')] ⚠${NC} $1"; }
+error() { echo -e "${RED}[$(date '+%H:%M:%S')] ✗${NC} $1"; exit 1; }
+
+# Parse arguments
+COUNT="${1:-$DEFAULT_COUNT}"
+TEMPLATE="${2:-$DEFAULT_TEMPLATE}"
+TASK_TYPE="${3:-$DEFAULT_TASK}"
+
+# Autoresearch targets (different repos/services for each VM)
+AUTORESEARCH_TARGETS=(
+    "jfl-cli:src/commands"
+    "jfl-cli:src/lib"
+    "jfl-platform:packages/memory"
+    "jfl-platform:packages/eval"
+    "jfl-template:knowledge"
+)
+
+# Fuzz test suites (different tests for each VM)
+FUZZ_SUITES=(
+    "fuzz-scope"
+    "fuzz-events"
+    "fuzz-training"
+    "fuzz-hub-api"
+)
+
+# Eval configurations
+EVAL_CONFIGS=(
+    "default"
+    "quality-first"
+    "cost-optimized"
+)
+
+check_prerequisites() {
+    if ! command -v prlctl &> /dev/null; then
+        error "prlctl not found. Install Parallels Desktop Pro."
+    fi
+
+    if ! prlctl list --all | grep -q "$TEMPLATE"; then
+        error "Template '$TEMPLATE' not found. Run create-base-template.sh first."
+    fi
+}
+
+create_log_dir() {
+    mkdir -p "$LOG_DIR"
+    # Create timestamp file for this fleet run
+    echo "$(date -u +"%Y-%m-%dT%H:%M:%SZ")" > "$LOG_DIR/fleet-started"
+}
+
+clone_vm() {
+    local index=$1
+    local vm_name="jfl-agent-${index}"
+
+    log "Creating VM: $vm_name"
+
+    # Check if VM already exists
+    if prlctl list --all | grep -q "$vm_name"; then
+        warn "VM $vm_name exists, stopping and deleting..."
+        prlctl stop "$vm_name" --kill 2>/dev/null || true
+        sleep 2
+        prlctl delete "$vm_name" 2>/dev/null || true
+    fi
+
+    # Clone from template (linked clone for speed)
+    prlctl clone "$TEMPLATE" --name "$vm_name" --linked
+
+    success "Created $vm_name"
+}
+
+start_vm() {
+    local vm_name=$1
+
+    log "Starting VM: $vm_name"
+    prlctl start "$vm_name"
+
+    # Wait for VM to be ready
+    local max_wait=60
+    local waited=0
+    while [[ $waited -lt $max_wait ]]; do
+        if prlctl exec "$vm_name" echo "ready" &> /dev/null; then
+            success "VM $vm_name is ready"
+            return 0
+        fi
+        sleep 2
+        waited=$((waited + 2))
+    done
+
+    warn "VM $vm_name may not be fully ready"
+}
+
+run_task_in_vm() {
+    local vm_name=$1
+    local index=$2
+    local log_file="$LOG_DIR/vm-${index}.log"
+
+    log "Starting task '$TASK_TYPE' in $vm_name"
+
+    case "$TASK_TYPE" in
+        autoresearch)
+            run_autoresearch "$vm_name" "$index" "$log_file"
+            ;;
+        fuzz)
+            run_fuzz "$vm_name" "$index" "$log_file"
+            ;;
+        eval)
+            run_eval "$vm_name" "$index" "$log_file"
+            ;;
+        *)
+            error "Unknown task type: $TASK_TYPE"
+            ;;
+    esac
+}
+
+run_autoresearch() {
+    local vm_name=$1
+    local index=$2
+    local log_file=$3
+
+    # Get target for this VM (cycle through targets)
+    local target_index=$((index % ${#AUTORESEARCH_TARGETS[@]}))
+    local target="${AUTORESEARCH_TARGETS[$target_index]}"
+    local repo="${target%%:*}"
+    local focus="${target##*:}"
+
+    log "VM $index: autoresearch on $repo ($focus)"
+
+    # Run autoresearch in background inside VM
+    prlctl exec "$vm_name" /bin/bash -c "
+        export PATH=\"\$PATH:/opt/homebrew/bin\"
+        cd /workspace/$repo
+
+        # Run autoresearch with the focus area
+        nohup jfl autoresearch --focus '$focus' \
+            > /workspace/autoresearch-$index.log 2>&1 &
+        echo \$! > /workspace/autoresearch-$index.pid
+
+        echo 'Autoresearch started for $repo ($focus)'
+    " > "$log_file" 2>&1 &
+
+    echo "$vm_name:$target:$!" >> "$LOG_DIR/running-tasks"
+}
+
+run_fuzz() {
+    local vm_name=$1
+    local index=$2
+    local log_file=$3
+
+    # Get fuzz suite for this VM
+    local suite_index=$((index % ${#FUZZ_SUITES[@]}))
+    local suite="${FUZZ_SUITES[$suite_index]}"
+
+    log "VM $index: running fuzz suite '$suite'"
+
+    prlctl exec "$vm_name" /bin/bash -c "
+        export PATH=\"\$PATH:/opt/homebrew/bin\"
+        cd /workspace/jfl-cli
+
+        # Run specific fuzz test suite
+        nohup npx jest --testPathPattern='$suite' --silent \
+            > /workspace/fuzz-$index.log 2>&1 &
+        echo \$! > /workspace/fuzz-$index.pid
+
+        echo 'Fuzz suite $suite started'
+    " > "$log_file" 2>&1 &
+
+    echo "$vm_name:fuzz:$suite:$!" >> "$LOG_DIR/running-tasks"
+}
+
+run_eval() {
+    local vm_name=$1
+    local index=$2
+    local log_file=$3
+
+    # Get eval config for this VM
+    local config_index=$((index % ${#EVAL_CONFIGS[@]}))
+    local config="${EVAL_CONFIGS[$config_index]}"
+
+    log "VM $index: running eval with config '$config'"
+
+    prlctl exec "$vm_name" /bin/bash -c "
+        export PATH=\"\$PATH:/opt/homebrew/bin\"
+        cd /workspace/jfl-cli
+
+        # Run evaluation
+        nohup jfl eval run --profile '$config' \
+            > /workspace/eval-$index.log 2>&1 &
+        echo \$! > /workspace/eval-$index.pid
+
+        echo 'Eval started with profile $config'
+    " > "$log_file" 2>&1 &
+
+    echo "$vm_name:eval:$config:$!" >> "$LOG_DIR/running-tasks"
+}
+
+print_summary() {
+    echo ""
+    echo "═══════════════════════════════════════════════════════════"
+    success "Fleet spawned successfully!"
+    echo "═══════════════════════════════════════════════════════════"
+    echo ""
+    echo "VMs started: $COUNT"
+    echo "Template:    $TEMPLATE"
+    echo "Task type:   $TASK_TYPE"
+    echo "Log dir:     $LOG_DIR"
+    echo ""
+    echo "Running VMs:"
+
+    for i in $(seq 1 "$COUNT"); do
+        local vm_name="jfl-agent-${i}"
+        local status
+        status=$(prlctl status "$vm_name" 2>/dev/null | grep -o 'running\|stopped' || echo "unknown")
+        echo "  • $vm_name: $status"
+    done
+
+    echo ""
+    echo "Commands:"
+    echo "  Monitor:  ./monitor-fleet.sh"
+    echo "  Collect:  ./collect-tuples.sh"
+    echo "  Kill:     ./kill-fleet.sh"
+    echo ""
+    echo "View logs:"
+    echo "  tail -f $LOG_DIR/vm-1.log"
+    echo ""
+}
+
+main() {
+    echo ""
+    echo "═══════════════════════════════════════════════════════════"
+    echo "  JFL Agent Fleet Spawner"
+    echo "═══════════════════════════════════════════════════════════"
+    echo ""
+    echo "Count:    $COUNT"
+    echo "Template: $TEMPLATE"
+    echo "Task:     $TASK_TYPE"
+    echo ""
+
+    check_prerequisites
+    create_log_dir
+
+    # Clear previous running tasks
+    rm -f "$LOG_DIR/running-tasks"
+    touch "$LOG_DIR/running-tasks"
+
+    # Clone and start each VM
+    for i in $(seq 1 "$COUNT"); do
+        clone_vm "$i"
+    done
+
+    echo ""
+
+    # Start VMs (can be parallelized)
+    for i in $(seq 1 "$COUNT"); do
+        start_vm "jfl-agent-${i}"
+    done
+
+    echo ""
+
+    # Run tasks in each VM
+    for i in $(seq 1 "$COUNT"); do
+        run_task_in_vm "jfl-agent-${i}" "$i"
+    done
+
+    print_summary
+}
+
+main