Add CCLI (CLI agent integration) complete implementation
- Complete Gemini CLI agent adapter with SSH execution - CLI agent factory with connection pooling - SSH executor with AsyncSSH for remote CLI execution - Backend integration with CLI agent manager - MCP server updates with CLI agent tools - Frontend UI updates for mixed agent types - Database migrations for CLI agent support - Docker deployment with CLI source integration - Comprehensive documentation and testing 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
anthonyrawlins
225
scripts/test-backend-integration.py
Executable file
225
scripts/test-backend-integration.py
Executable file
@@ -0,0 +1,225 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Test script for Hive backend CLI agent integration
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import sys
|
||||
import os
|
||||
import logging
|
||||
|
||||
# Add backend to path
|
||||
backend_path = os.path.join(os.path.dirname(__file__), '../../backend')
|
||||
sys.path.insert(0, backend_path)
|
||||
|
||||
from app.core.hive_coordinator import HiveCoordinator, Agent, AgentType
|
||||
from app.cli_agents.cli_agent_manager import get_cli_agent_manager
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def test_cli_agent_manager():
|
||||
"""Test CLI agent manager functionality"""
|
||||
print("🧪 Testing CLI Agent Manager...")
|
||||
|
||||
try:
|
||||
# Initialize CLI agent manager
|
||||
cli_manager = get_cli_agent_manager()
|
||||
await cli_manager.initialize()
|
||||
|
||||
# Check predefined agents
|
||||
agent_ids = cli_manager.get_active_agent_ids()
|
||||
print(f"✅ Active CLI agents: {agent_ids}")
|
||||
|
||||
# Test health checks
|
||||
health_results = await cli_manager.health_check_all_agents()
|
||||
for agent_id, health in health_results.items():
|
||||
status = "✅" if health.get("cli_healthy", False) else "❌"
|
||||
print(f" {agent_id}: {status} {health.get('response_time', 'N/A')}s")
|
||||
|
||||
# Test statistics
|
||||
stats = cli_manager.get_agent_statistics()
|
||||
print(f"✅ CLI agent statistics collected for {len(stats)} agents")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ CLI Agent Manager test failed: {e}")
|
||||
return False
|
||||
|
||||
|
||||
async def test_hive_coordinator_integration():
|
||||
"""Test Hive coordinator with CLI agents"""
|
||||
print("\n🤖 Testing Hive Coordinator Integration...")
|
||||
|
||||
try:
|
||||
# Initialize coordinator
|
||||
coordinator = HiveCoordinator()
|
||||
await coordinator.initialize()
|
||||
|
||||
# Test CLI agent registration
|
||||
cli_agent = Agent(
|
||||
id="test-cli-agent",
|
||||
endpoint="cli://walnut",
|
||||
model="gemini-2.5-pro",
|
||||
specialty=AgentType.GENERAL_AI,
|
||||
max_concurrent=1,
|
||||
current_tasks=0,
|
||||
agent_type="cli",
|
||||
cli_config={
|
||||
"host": "walnut",
|
||||
"node_version": "v22.14.0",
|
||||
"model": "gemini-2.5-pro",
|
||||
"specialization": "general_ai",
|
||||
"max_concurrent": 1,
|
||||
"command_timeout": 30,
|
||||
"ssh_timeout": 5,
|
||||
"agent_type": "gemini"
|
||||
}
|
||||
)
|
||||
|
||||
coordinator.add_agent(cli_agent)
|
||||
print("✅ CLI agent registered with coordinator")
|
||||
|
||||
# Test task creation
|
||||
task = coordinator.create_task(
|
||||
AgentType.GENERAL_AI,
|
||||
{
|
||||
"objective": "Test CLI agent integration",
|
||||
"requirements": ["Respond with a simple acknowledgment"]
|
||||
},
|
||||
priority=4
|
||||
)
|
||||
print(f"✅ Task created: {task.id}")
|
||||
|
||||
# Test task execution (if we have available agents)
|
||||
available_agent = coordinator.get_available_agent(AgentType.GENERAL_AI)
|
||||
if available_agent and available_agent.agent_type == "cli":
|
||||
print(f"✅ Found available CLI agent: {available_agent.id}")
|
||||
|
||||
try:
|
||||
result = await coordinator.execute_task(task, available_agent)
|
||||
if "error" not in result:
|
||||
print("✅ CLI task execution successful")
|
||||
print(f" Response: {result.get('response', 'No response')[:100]}...")
|
||||
else:
|
||||
print(f"⚠️ CLI task execution returned error: {result['error']}")
|
||||
except Exception as e:
|
||||
print(f"⚠️ CLI task execution failed: {e}")
|
||||
else:
|
||||
print("⚠️ No available CLI agents for task execution test")
|
||||
|
||||
# Cleanup
|
||||
await coordinator.shutdown()
|
||||
print("✅ Coordinator shutdown complete")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Hive Coordinator integration test failed: {e}")
|
||||
return False
|
||||
|
||||
|
||||
async def test_mixed_agent_types():
|
||||
"""Test mixed agent type handling"""
|
||||
print("\n⚡ Testing Mixed Agent Types...")
|
||||
|
||||
try:
|
||||
coordinator = HiveCoordinator()
|
||||
await coordinator.initialize()
|
||||
|
||||
# Add both Ollama and CLI agents (simulated)
|
||||
ollama_agent = Agent(
|
||||
id="test-ollama-agent",
|
||||
endpoint="http://localhost:11434",
|
||||
model="codellama:latest",
|
||||
specialty=AgentType.DOCS_WRITER,
|
||||
max_concurrent=2,
|
||||
current_tasks=0,
|
||||
agent_type="ollama"
|
||||
)
|
||||
|
||||
cli_agent = Agent(
|
||||
id="test-cli-agent-2",
|
||||
endpoint="cli://ironwood",
|
||||
model="gemini-2.5-pro",
|
||||
specialty=AgentType.REASONING,
|
||||
max_concurrent=1,
|
||||
current_tasks=0,
|
||||
agent_type="cli",
|
||||
cli_config={
|
||||
"host": "ironwood",
|
||||
"node_version": "v22.17.0",
|
||||
"model": "gemini-2.5-pro",
|
||||
"specialization": "reasoning"
|
||||
}
|
||||
)
|
||||
|
||||
coordinator.add_agent(ollama_agent)
|
||||
coordinator.add_agent(cli_agent)
|
||||
print("✅ Mixed agent types registered")
|
||||
|
||||
# Test agent selection for different task types
|
||||
docs_agent = coordinator.get_available_agent(AgentType.DOCS_WRITER)
|
||||
reasoning_agent = coordinator.get_available_agent(AgentType.REASONING)
|
||||
|
||||
if docs_agent:
|
||||
print(f"✅ Found {docs_agent.agent_type} agent for docs: {docs_agent.id}")
|
||||
if reasoning_agent:
|
||||
print(f"✅ Found {reasoning_agent.agent_type} agent for reasoning: {reasoning_agent.id}")
|
||||
|
||||
await coordinator.shutdown()
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Mixed agent types test failed: {e}")
|
||||
return False
|
||||
|
||||
|
||||
async def main():
|
||||
"""Run all backend integration tests"""
|
||||
print("🚀 CCLI Backend Integration Test Suite")
|
||||
print("=" * 50)
|
||||
|
||||
tests = [
|
||||
("CLI Agent Manager", test_cli_agent_manager),
|
||||
("Hive Coordinator Integration", test_hive_coordinator_integration),
|
||||
("Mixed Agent Types", test_mixed_agent_types)
|
||||
]
|
||||
|
||||
results = []
|
||||
|
||||
for test_name, test_func in tests:
|
||||
try:
|
||||
success = await test_func()
|
||||
results.append((test_name, success))
|
||||
except Exception as e:
|
||||
print(f"❌ {test_name} failed with exception: {e}")
|
||||
results.append((test_name, False))
|
||||
|
||||
# Summary
|
||||
print("\n" + "=" * 50)
|
||||
print("🎯 Backend Integration Test Results:")
|
||||
|
||||
passed = 0
|
||||
for test_name, success in results:
|
||||
status = "✅ PASS" if success else "❌ FAIL"
|
||||
print(f" {test_name}: {status}")
|
||||
if success:
|
||||
passed += 1
|
||||
|
||||
print(f"\n📊 Overall: {passed}/{len(results)} tests passed")
|
||||
|
||||
if passed == len(results):
|
||||
print("🎉 All backend integration tests passed! Ready for API testing.")
|
||||
return 0
|
||||
else:
|
||||
print("⚠️ Some tests failed. Review integration issues.")
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
exit_code = asyncio.run(main())
|
||||
sys.exit(exit_code)
|
||||
270
scripts/test-connectivity.sh
Executable file
270
scripts/test-connectivity.sh
Executable file
@@ -0,0 +1,270 @@
|
||||
#!/bin/bash
|
||||
|
||||
# CCLI Connectivity Test Suite
|
||||
# Tests SSH connectivity and Gemini CLI functionality on target machines
|
||||
|
||||
set -e
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Test configuration
|
||||
WALNUT_NODE_VERSION="v22.14.0"
|
||||
IRONWOOD_NODE_VERSION="v22.17.0"
|
||||
TEST_PROMPT="What is 2+2? Answer briefly."
|
||||
|
||||
function log() {
|
||||
echo -e "${BLUE}[$(date +'%H:%M:%S')]${NC} $1"
|
||||
}
|
||||
|
||||
function success() {
|
||||
echo -e "${GREEN}✅ $1${NC}"
|
||||
}
|
||||
|
||||
function warning() {
|
||||
echo -e "${YELLOW}⚠️ $1${NC}"
|
||||
}
|
||||
|
||||
function error() {
|
||||
echo -e "${RED}❌ $1${NC}"
|
||||
}
|
||||
|
||||
function test_ssh_connection() {
|
||||
local host=$1
|
||||
log "Testing SSH connection to $host..."
|
||||
|
||||
if ssh -o ConnectTimeout=5 -o BatchMode=yes $host "echo 'SSH connection successful'" > /dev/null 2>&1; then
|
||||
success "SSH connection to $host working"
|
||||
return 0
|
||||
else
|
||||
error "SSH connection to $host failed"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function test_node_environment() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
log "Testing Node.js environment on $host (version $node_version)..."
|
||||
|
||||
local cmd="source ~/.nvm/nvm.sh && nvm use $node_version && node --version"
|
||||
local result=$(ssh $host "$cmd" 2>/dev/null)
|
||||
|
||||
if [[ $result == *$node_version ]]; then
|
||||
success "Node.js $node_version working on $host"
|
||||
return 0
|
||||
else
|
||||
error "Node.js $node_version not working on $host (got: $result)"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function test_gemini_cli() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
log "Testing Gemini CLI on $host..."
|
||||
|
||||
local cmd="source ~/.nvm/nvm.sh && nvm use $node_version && echo '$TEST_PROMPT' | timeout 30s gemini --model gemini-2.5-pro"
|
||||
local result=$(ssh $host "$cmd" 2>/dev/null)
|
||||
|
||||
if [[ -n "$result" ]] && [[ ${#result} -gt 10 ]]; then
|
||||
success "Gemini CLI working on $host"
|
||||
log "Response preview: ${result:0:100}..."
|
||||
return 0
|
||||
else
|
||||
error "Gemini CLI not responding on $host"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function benchmark_response_time() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
log "Benchmarking response time on $host..."
|
||||
|
||||
local cmd="source ~/.nvm/nvm.sh && nvm use $node_version && echo '$TEST_PROMPT' | gemini --model gemini-2.5-pro"
|
||||
local start_time=$(date +%s.%N)
|
||||
local result=$(ssh $host "$cmd" 2>/dev/null)
|
||||
local end_time=$(date +%s.%N)
|
||||
local duration=$(echo "$end_time - $start_time" | bc -l)
|
||||
|
||||
if [[ -n "$result" ]]; then
|
||||
success "Response time on $host: ${duration:0:5}s"
|
||||
echo "$duration" > "/tmp/ccli_benchmark_${host}.txt"
|
||||
return 0
|
||||
else
|
||||
error "Benchmark failed on $host"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function test_concurrent_execution() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
local max_concurrent=${3:-2}
|
||||
log "Testing concurrent execution on $host (max: $max_concurrent)..."
|
||||
|
||||
local pids=()
|
||||
local results_dir="/tmp/ccli_concurrent_${host}"
|
||||
mkdir -p "$results_dir"
|
||||
|
||||
# Start concurrent tasks
|
||||
for i in $(seq 1 $max_concurrent); do
|
||||
{
|
||||
local cmd="source ~/.nvm/nvm.sh && nvm use $node_version && echo 'Task $i: What is $i + $i?' | gemini --model gemini-2.5-pro"
|
||||
ssh $host "$cmd" > "$results_dir/task_$i.out" 2>&1
|
||||
echo $? > "$results_dir/task_$i.exit"
|
||||
} &
|
||||
pids+=($!)
|
||||
done
|
||||
|
||||
# Wait for all tasks and check results
|
||||
wait
|
||||
local successful=0
|
||||
for i in $(seq 1 $max_concurrent); do
|
||||
if [[ -f "$results_dir/task_$i.exit" ]] && [[ $(cat "$results_dir/task_$i.exit") -eq 0 ]]; then
|
||||
((successful++))
|
||||
fi
|
||||
done
|
||||
|
||||
if [[ $successful -eq $max_concurrent ]]; then
|
||||
success "Concurrent execution successful on $host ($successful/$max_concurrent tasks)"
|
||||
return 0
|
||||
else
|
||||
warning "Partial success on $host ($successful/$max_concurrent tasks)"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function test_error_handling() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
log "Testing error handling on $host..."
|
||||
|
||||
# Test invalid model
|
||||
local cmd="source ~/.nvm/nvm.sh && nvm use $node_version && echo 'test' | gemini --model invalid-model"
|
||||
if ssh $host "$cmd" > /dev/null 2>&1; then
|
||||
warning "Expected error not returned for invalid model on $host"
|
||||
else
|
||||
success "Error handling working on $host"
|
||||
fi
|
||||
}
|
||||
|
||||
function run_full_test_suite() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
|
||||
echo ""
|
||||
echo "🧪 Testing $host with Node.js $node_version"
|
||||
echo "================================================"
|
||||
|
||||
local tests_passed=0
|
||||
local tests_total=6
|
||||
|
||||
# Run all tests
|
||||
test_ssh_connection "$host" && ((tests_passed++))
|
||||
test_node_environment "$host" "$node_version" && ((tests_passed++))
|
||||
test_gemini_cli "$host" "$node_version" && ((tests_passed++))
|
||||
benchmark_response_time "$host" "$node_version" && ((tests_passed++))
|
||||
test_concurrent_execution "$host" "$node_version" 2 && ((tests_passed++))
|
||||
test_error_handling "$host" "$node_version" && ((tests_passed++))
|
||||
|
||||
echo ""
|
||||
if [[ $tests_passed -eq $tests_total ]]; then
|
||||
success "$host: All tests passed ($tests_passed/$tests_total)"
|
||||
return 0
|
||||
else
|
||||
warning "$host: Some tests failed ($tests_passed/$tests_total)"
|
||||
return 1
|
||||
fi
|
||||
}
|
||||
|
||||
function generate_test_report() {
|
||||
log "Generating test report..."
|
||||
|
||||
local report_file="/tmp/ccli_connectivity_report_$(date +%s).md"
|
||||
cat > "$report_file" << EOF
|
||||
# CCLI Connectivity Test Report
|
||||
|
||||
**Generated**: $(date)
|
||||
**Test Suite**: Phase 1 Connectivity & Environment Testing
|
||||
|
||||
## Test Results
|
||||
|
||||
### WALNUT (Node.js $WALNUT_NODE_VERSION)
|
||||
$(if [[ -f "/tmp/ccli_benchmark_walnut.txt" ]]; then
|
||||
echo "- ✅ All connectivity tests passed"
|
||||
echo "- Response time: $(cat /tmp/ccli_benchmark_walnut.txt | cut -c1-5)s"
|
||||
else
|
||||
echo "- ❌ Some tests failed"
|
||||
fi)
|
||||
|
||||
### IRONWOOD (Node.js $IRONWOOD_NODE_VERSION)
|
||||
$(if [[ -f "/tmp/ccli_benchmark_ironwood.txt" ]]; then
|
||||
echo "- ✅ All connectivity tests passed"
|
||||
echo "- Response time: $(cat /tmp/ccli_benchmark_ironwood.txt | cut -c1-5)s"
|
||||
else
|
||||
echo "- ❌ Some tests failed"
|
||||
fi)
|
||||
|
||||
## Performance Comparison
|
||||
$(if [[ -f "/tmp/ccli_benchmark_walnut.txt" ]] && [[ -f "/tmp/ccli_benchmark_ironwood.txt" ]]; then
|
||||
walnut_time=$(cat /tmp/ccli_benchmark_walnut.txt)
|
||||
ironwood_time=$(cat /tmp/ccli_benchmark_ironwood.txt)
|
||||
echo "- WALNUT: ${walnut_time:0:5}s"
|
||||
echo "- IRONWOOD: ${ironwood_time:0:5}s"
|
||||
faster_host=$(echo "$walnut_time < $ironwood_time" | bc -l)
|
||||
if [[ $faster_host -eq 1 ]]; then
|
||||
echo "- WALNUT is faster"
|
||||
else
|
||||
echo "- IRONWOOD is faster"
|
||||
fi
|
||||
else
|
||||
echo "- Benchmark data incomplete"
|
||||
fi)
|
||||
|
||||
## Next Steps
|
||||
- [ ] Proceed to Phase 2: CLI Agent Adapter Implementation
|
||||
- [ ] Address any failed tests
|
||||
- [ ] Document environment requirements
|
||||
EOF
|
||||
|
||||
success "Test report generated: $report_file"
|
||||
echo "Report location: $report_file"
|
||||
cat "$report_file"
|
||||
}
|
||||
|
||||
# Main execution
|
||||
echo "🚀 CCLI Connectivity Test Suite"
|
||||
echo "Testing Gemini CLI on WALNUT and IRONWOOD"
|
||||
echo ""
|
||||
|
||||
# Check dependencies
|
||||
if ! command -v bc &> /dev/null; then
|
||||
error "bc (basic calculator) not found. Please install: sudo apt-get install bc"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Run tests
|
||||
walnut_result=0
|
||||
ironwood_result=0
|
||||
|
||||
run_full_test_suite "walnut" "$WALNUT_NODE_VERSION" || walnut_result=1
|
||||
run_full_test_suite "ironwood" "$IRONWOOD_NODE_VERSION" || ironwood_result=1
|
||||
|
||||
# Generate report
|
||||
generate_test_report
|
||||
|
||||
# Final status
|
||||
echo ""
|
||||
if [[ $walnut_result -eq 0 ]] && [[ $ironwood_result -eq 0 ]]; then
|
||||
success "🎉 All connectivity tests passed! Ready for Phase 2"
|
||||
exit 0
|
||||
else
|
||||
error "❌ Some tests failed. Please review and fix issues before proceeding"
|
||||
exit 1
|
||||
fi
|
||||
289
scripts/test-implementation.py
Executable file
289
scripts/test-implementation.py
Executable file
@@ -0,0 +1,289 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
CCLI Implementation Test Runner
|
||||
Tests the CLI agent implementation with real SSH connections.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import sys
|
||||
import os
|
||||
import logging
|
||||
import time
|
||||
|
||||
# Add src to path
|
||||
sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)), 'src'))
|
||||
|
||||
from agents.gemini_cli_agent import GeminiCliAgent, GeminiCliConfig, TaskRequest
|
||||
from agents.cli_agent_factory import CliAgentFactory, get_default_factory
|
||||
from executors.ssh_executor import SSHExecutor, SSHConfig
|
||||
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||||
)
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def test_ssh_executor():
|
||||
"""Test SSH executor functionality"""
|
||||
print("🔗 Testing SSH Executor...")
|
||||
|
||||
executor = SSHExecutor()
|
||||
config = SSHConfig(host="walnut", command_timeout=10)
|
||||
|
||||
try:
|
||||
# Test basic command
|
||||
result = await executor.execute(config, "echo 'Hello from SSH'")
|
||||
assert result.returncode == 0
|
||||
assert "Hello from SSH" in result.stdout
|
||||
print(f"✅ Basic SSH command: {result.stdout.strip()}")
|
||||
|
||||
# Test connection stats
|
||||
stats = await executor.get_connection_stats()
|
||||
print(f"✅ Connection stats: {stats['total_connections']} connections")
|
||||
|
||||
# Cleanup
|
||||
await executor.cleanup()
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ SSH executor test failed: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
async def test_gemini_cli_agent():
|
||||
"""Test GeminiCliAgent functionality"""
|
||||
print("\n🤖 Testing GeminiCliAgent...")
|
||||
|
||||
config = GeminiCliConfig(
|
||||
host="walnut",
|
||||
node_version="v22.14.0",
|
||||
model="gemini-2.5-pro",
|
||||
command_timeout=30
|
||||
)
|
||||
|
||||
agent = GeminiCliAgent(config, "test")
|
||||
|
||||
try:
|
||||
# Test health check
|
||||
health = await agent.health_check()
|
||||
print(f"✅ Health check: SSH={health['ssh_healthy']}, CLI={health['cli_healthy']}")
|
||||
|
||||
if not health['cli_healthy']:
|
||||
print("❌ Gemini CLI not healthy, skipping execution test")
|
||||
return False
|
||||
|
||||
# Test simple task execution
|
||||
task = TaskRequest(
|
||||
prompt="What is 2+2? Answer with just the number.",
|
||||
task_id="test-math"
|
||||
)
|
||||
|
||||
start_time = time.time()
|
||||
result = await agent.execute_task(task)
|
||||
execution_time = time.time() - start_time
|
||||
|
||||
print(f"✅ Task execution:")
|
||||
print(f" Status: {result.status.value}")
|
||||
print(f" Response: {result.response[:100]}...")
|
||||
print(f" Execution time: {execution_time:.2f}s")
|
||||
print(f" Agent time: {result.execution_time:.2f}s")
|
||||
|
||||
# Test statistics
|
||||
stats = agent.get_statistics()
|
||||
print(f"✅ Agent stats: {stats['stats']['total_tasks']} tasks total")
|
||||
|
||||
# Cleanup
|
||||
await agent.cleanup()
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ GeminiCliAgent test failed: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
async def test_cli_agent_factory():
|
||||
"""Test CLI agent factory"""
|
||||
print("\n🏭 Testing CliAgentFactory...")
|
||||
|
||||
factory = CliAgentFactory()
|
||||
|
||||
try:
|
||||
# List predefined agents
|
||||
predefined = factory.get_predefined_agent_ids()
|
||||
print(f"✅ Predefined agents: {predefined}")
|
||||
|
||||
# Get agent info
|
||||
info = factory.get_agent_info("walnut-gemini")
|
||||
print(f"✅ Agent info: {info['description']}")
|
||||
|
||||
# Create an agent
|
||||
agent = factory.create_agent("walnut-gemini")
|
||||
print(f"✅ Created agent: {agent.agent_id}")
|
||||
|
||||
# Test the created agent
|
||||
health = await agent.health_check()
|
||||
print(f"✅ Factory agent health: SSH={health['ssh_healthy']}")
|
||||
|
||||
# Cleanup
|
||||
await factory.cleanup_all()
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ CliAgentFactory test failed: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
async def test_concurrent_execution():
|
||||
"""Test concurrent task execution"""
|
||||
print("\n⚡ Testing Concurrent Execution...")
|
||||
|
||||
factory = get_default_factory()
|
||||
|
||||
try:
|
||||
# Create agent
|
||||
agent = factory.create_agent("ironwood-gemini") # Use faster machine
|
||||
|
||||
# Create multiple tasks
|
||||
tasks = [
|
||||
TaskRequest(prompt=f"Count from 1 to {i}. Just list the numbers.", task_id=f"count-{i}")
|
||||
for i in range(1, 4)
|
||||
]
|
||||
|
||||
# Execute concurrently
|
||||
start_time = time.time()
|
||||
results = await asyncio.gather(*[
|
||||
agent.execute_task(task) for task in tasks
|
||||
], return_exceptions=True)
|
||||
total_time = time.time() - start_time
|
||||
|
||||
# Analyze results
|
||||
successful = sum(1 for r in results if hasattr(r, 'status') and r.status.value == 'completed')
|
||||
print(f"✅ Concurrent execution: {successful}/{len(tasks)} successful in {total_time:.2f}s")
|
||||
|
||||
for i, result in enumerate(results):
|
||||
if hasattr(result, 'status'):
|
||||
print(f" Task {i+1}: {result.status.value} ({result.execution_time:.2f}s)")
|
||||
else:
|
||||
print(f" Task {i+1}: Exception - {result}")
|
||||
|
||||
# Cleanup
|
||||
await factory.cleanup_all()
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Concurrent execution test failed: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
async def run_performance_test():
|
||||
"""Run performance comparison test"""
|
||||
print("\n📊 Performance Comparison Test...")
|
||||
|
||||
factory = get_default_factory()
|
||||
|
||||
try:
|
||||
# Test both machines
|
||||
results = {}
|
||||
|
||||
for agent_id in ["walnut-gemini", "ironwood-gemini"]:
|
||||
print(f"Testing {agent_id}...")
|
||||
|
||||
agent = factory.create_agent(agent_id)
|
||||
|
||||
# Simple prompt for consistency
|
||||
task = TaskRequest(
|
||||
prompt="What is the capital of France? Answer in one word.",
|
||||
task_id=f"perf-{agent_id}"
|
||||
)
|
||||
|
||||
start_time = time.time()
|
||||
result = await agent.execute_task(task)
|
||||
total_time = time.time() - start_time
|
||||
|
||||
results[agent_id] = {
|
||||
"success": result.status.value == "completed",
|
||||
"response_time": total_time,
|
||||
"agent_time": result.execution_time,
|
||||
"response": result.response[:50] if result.response else None
|
||||
}
|
||||
|
||||
print(f" {agent_id}: {total_time:.2f}s ({'✅' if result.status.value == 'completed' else '❌'})")
|
||||
|
||||
# Compare results
|
||||
if results["walnut-gemini"]["success"] and results["ironwood-gemini"]["success"]:
|
||||
walnut_time = results["walnut-gemini"]["response_time"]
|
||||
ironwood_time = results["ironwood-gemini"]["response_time"]
|
||||
|
||||
if walnut_time < ironwood_time:
|
||||
faster = "WALNUT"
|
||||
diff = ((ironwood_time - walnut_time) / walnut_time) * 100
|
||||
else:
|
||||
faster = "IRONWOOD"
|
||||
diff = ((walnut_time - ironwood_time) / ironwood_time) * 100
|
||||
|
||||
print(f"✅ Performance winner: {faster} (by {diff:.1f}%)")
|
||||
|
||||
# Cleanup
|
||||
await factory.cleanup_all()
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Performance test failed: {e}")
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
async def main():
|
||||
"""Run all implementation tests"""
|
||||
print("🚀 CCLI Implementation Test Suite")
|
||||
print("=" * 50)
|
||||
|
||||
tests = [
|
||||
("SSH Executor", test_ssh_executor),
|
||||
("GeminiCliAgent", test_gemini_cli_agent),
|
||||
("CliAgentFactory", test_cli_agent_factory),
|
||||
("Concurrent Execution", test_concurrent_execution),
|
||||
("Performance Comparison", run_performance_test)
|
||||
]
|
||||
|
||||
results = []
|
||||
|
||||
for test_name, test_func in tests:
|
||||
try:
|
||||
success = await test_func()
|
||||
results.append((test_name, success))
|
||||
except Exception as e:
|
||||
print(f"❌ {test_name} failed with exception: {e}")
|
||||
results.append((test_name, False))
|
||||
|
||||
# Summary
|
||||
print("\n" + "=" * 50)
|
||||
print("🎯 Test Results Summary:")
|
||||
|
||||
passed = 0
|
||||
for test_name, success in results:
|
||||
status = "✅ PASS" if success else "❌ FAIL"
|
||||
print(f" {test_name}: {status}")
|
||||
if success:
|
||||
passed += 1
|
||||
|
||||
print(f"\n📊 Overall: {passed}/{len(results)} tests passed")
|
||||
|
||||
if passed == len(results):
|
||||
print("🎉 All tests passed! Implementation ready for Phase 3.")
|
||||
return 0
|
||||
else:
|
||||
print("⚠️ Some tests failed. Please review and fix issues.")
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
exit_code = asyncio.run(main())
|
||||
sys.exit(exit_code)
|
||||
110
scripts/test-mcp-integration.js
Normal file
110
scripts/test-mcp-integration.js
Normal file
@@ -0,0 +1,110 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
/**
|
||||
* Test MCP Server CLI Agent Integration
|
||||
*/
|
||||
|
||||
const { HiveClient } = require('../../mcp-server/dist/hive-client.js');
|
||||
const { HiveTools } = require('../../mcp-server/dist/hive-tools.js');
|
||||
|
||||
async function testMCPIntegration() {
|
||||
console.log('🧪 Testing MCP Server CLI Agent Integration...\n');
|
||||
|
||||
try {
|
||||
// Initialize Hive client
|
||||
const hiveClient = new HiveClient({
|
||||
baseUrl: 'https://hive.home.deepblack.cloud/api',
|
||||
wsUrl: 'wss://hive.home.deepblack.cloud/socket.io',
|
||||
timeout: 15000
|
||||
});
|
||||
|
||||
console.log('✅ HiveClient initialized');
|
||||
|
||||
// Test connection
|
||||
try {
|
||||
await hiveClient.testConnection();
|
||||
console.log('✅ Connection to Hive backend successful');
|
||||
} catch (error) {
|
||||
console.log('⚠️ Connection test failed (backend may be offline):', error.message);
|
||||
console.log(' Continuing with tool definition tests...\n');
|
||||
}
|
||||
|
||||
// Initialize tools
|
||||
const hiveTools = new HiveTools(hiveClient);
|
||||
console.log('✅ HiveTools initialized');
|
||||
|
||||
// Test tool definitions
|
||||
const tools = hiveTools.getAllTools();
|
||||
console.log(`✅ Loaded ${tools.length} MCP tools\n`);
|
||||
|
||||
// Check for CLI agent tools
|
||||
const cliTools = tools.filter(tool =>
|
||||
tool.name.includes('cli') ||
|
||||
tool.name.includes('predefined')
|
||||
);
|
||||
|
||||
console.log('🔍 CLI Agent Tools Available:');
|
||||
cliTools.forEach(tool => {
|
||||
console.log(` • ${tool.name}: ${tool.description}`);
|
||||
});
|
||||
|
||||
// Test tool schema validation
|
||||
const registerCliTool = tools.find(t => t.name === 'hive_register_cli_agent');
|
||||
if (registerCliTool) {
|
||||
console.log('\n✅ hive_register_cli_agent tool found');
|
||||
console.log(' Required fields:', registerCliTool.inputSchema.required);
|
||||
|
||||
const properties = registerCliTool.inputSchema.properties;
|
||||
if (properties.host && properties.node_version && properties.specialization) {
|
||||
console.log('✅ CLI agent tool schema validated');
|
||||
} else {
|
||||
console.log('❌ CLI agent tool schema missing required properties');
|
||||
}
|
||||
} else {
|
||||
console.log('❌ hive_register_cli_agent tool not found');
|
||||
}
|
||||
|
||||
// Test agent enumeration
|
||||
const agentEnums = tools
|
||||
.filter(t => t.inputSchema.properties &&
|
||||
(t.inputSchema.properties.specialization ||
|
||||
t.inputSchema.properties.type))
|
||||
.map(t => {
|
||||
const spec = t.inputSchema.properties.specialization;
|
||||
const type = t.inputSchema.properties.type;
|
||||
return { tool: t.name, enum: spec?.enum || type?.enum };
|
||||
})
|
||||
.filter(t => t.enum);
|
||||
|
||||
console.log('\n🔍 Agent Type Enumerations:');
|
||||
agentEnums.forEach(({ tool, enum: enumValues }) => {
|
||||
const cliTypes = enumValues.filter(e =>
|
||||
e.includes('cli') || e.includes('general') || e.includes('reasoning')
|
||||
);
|
||||
if (cliTypes.length > 0) {
|
||||
console.log(` • ${tool}: includes CLI types [${cliTypes.join(', ')}]`);
|
||||
}
|
||||
});
|
||||
|
||||
console.log('\n🎉 MCP Integration Test Complete!');
|
||||
console.log('✅ CLI agent tools are properly integrated');
|
||||
console.log('✅ Schema validation passed');
|
||||
console.log('✅ Mixed agent type support confirmed');
|
||||
|
||||
return true;
|
||||
|
||||
} catch (error) {
|
||||
console.error('❌ MCP Integration test failed:', error.message);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Run the test
|
||||
testMCPIntegration()
|
||||
.then(success => {
|
||||
process.exit(success ? 0 : 1);
|
||||
})
|
||||
.catch(error => {
|
||||
console.error('❌ Test execution failed:', error);
|
||||
process.exit(1);
|
||||
});
|
||||
207
scripts/test-ssh-pooling.sh
Executable file
207
scripts/test-ssh-pooling.sh
Executable file
@@ -0,0 +1,207 @@
|
||||
#!/bin/bash
|
||||
|
||||
# CCLI SSH Connection Pooling Test
|
||||
# Tests SSH connection reuse, limits, and error handling
|
||||
|
||||
set -e
|
||||
|
||||
# Colors
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m'
|
||||
|
||||
function log() { echo -e "${BLUE}[$(date +'%H:%M:%S')]${NC} $1"; }
|
||||
function success() { echo -e "${GREEN}✅ $1${NC}"; }
|
||||
function warning() { echo -e "${YELLOW}⚠️ $1${NC}"; }
|
||||
function error() { echo -e "${RED}❌ $1${NC}"; }
|
||||
|
||||
function test_connection_reuse() {
|
||||
local host=$1
|
||||
log "Testing SSH connection reuse on $host..."
|
||||
|
||||
# Use SSH ControlMaster for connection sharing
|
||||
local control_path="/tmp/ssh_control_${host}_$$"
|
||||
local ssh_opts="-o ControlMaster=auto -o ControlPath=$control_path -o ControlPersist=30"
|
||||
|
||||
# Start master connection
|
||||
ssh $ssh_opts $host "echo 'Master connection established'" > /dev/null
|
||||
|
||||
# Test rapid connections (should reuse)
|
||||
local start_time=$(date +%s.%N)
|
||||
for i in {1..5}; do
|
||||
ssh $ssh_opts $host "echo 'Reused connection $i'" > /dev/null &
|
||||
done
|
||||
wait
|
||||
local end_time=$(date +%s.%N)
|
||||
local duration=$(echo "$end_time - $start_time" | bc -l)
|
||||
|
||||
# Clean up
|
||||
ssh $ssh_opts -O exit $host 2>/dev/null || true
|
||||
rm -f "$control_path"
|
||||
|
||||
success "Connection reuse test completed in ${duration:0:5}s"
|
||||
echo "$duration" > "/tmp/ssh_reuse_${host}.txt"
|
||||
}
|
||||
|
||||
function test_connection_limits() {
|
||||
local host=$1
|
||||
log "Testing SSH connection limits on $host..."
|
||||
|
||||
local max_connections=10
|
||||
local pids=()
|
||||
local results_dir="/tmp/ssh_limits_${host}"
|
||||
mkdir -p "$results_dir"
|
||||
|
||||
# Start multiple connections
|
||||
for i in $(seq 1 $max_connections); do
|
||||
{
|
||||
ssh $host "sleep 5 && echo 'Connection $i completed'" > "$results_dir/conn_$i.out" 2>&1
|
||||
echo $? > "$results_dir/conn_$i.exit"
|
||||
} &
|
||||
pids+=($!)
|
||||
done
|
||||
|
||||
# Wait and count successful connections
|
||||
wait
|
||||
local successful=0
|
||||
for i in $(seq 1 $max_connections); do
|
||||
if [[ -f "$results_dir/conn_$i.exit" ]] && [[ $(cat "$results_dir/conn_$i.exit") -eq 0 ]]; then
|
||||
((successful++))
|
||||
fi
|
||||
done
|
||||
|
||||
success "SSH connection limit test: $successful/$max_connections successful"
|
||||
|
||||
# Clean up
|
||||
rm -rf "$results_dir"
|
||||
}
|
||||
|
||||
function test_connection_recovery() {
|
||||
local host=$1
|
||||
log "Testing SSH connection recovery on $host..."
|
||||
|
||||
# Normal connection
|
||||
if ssh $host "echo 'Normal connection'" > /dev/null 2>&1; then
|
||||
success "Normal SSH connection working"
|
||||
else
|
||||
error "Normal SSH connection failed"
|
||||
return 1
|
||||
fi
|
||||
|
||||
# Test with short timeout
|
||||
if timeout 5s ssh -o ConnectTimeout=2 $host "echo 'Quick connection'" > /dev/null 2>&1; then
|
||||
success "Quick SSH connection working"
|
||||
else
|
||||
warning "Quick SSH connection timed out (may be normal under load)"
|
||||
fi
|
||||
|
||||
# Test connection to invalid host (should fail gracefully)
|
||||
if ssh -o ConnectTimeout=3 -o BatchMode=yes invalid-host-12345 "echo 'test'" > /dev/null 2>&1; then
|
||||
warning "Connection to invalid host unexpectedly succeeded"
|
||||
else
|
||||
success "Connection to invalid host correctly failed"
|
||||
fi
|
||||
}
|
||||
|
||||
function test_gemini_via_ssh_multiplex() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
log "Testing Gemini CLI via SSH multiplexing on $host..."
|
||||
|
||||
local control_path="/tmp/ssh_gemini_${host}_$$"
|
||||
local ssh_opts="-o ControlMaster=auto -o ControlPath=$control_path -o ControlPersist=60"
|
||||
|
||||
# Establish master connection
|
||||
ssh $ssh_opts $host "echo 'Gemini multiplex ready'" > /dev/null
|
||||
|
||||
# Run multiple Gemini commands concurrently
|
||||
local pids=()
|
||||
local start_time=$(date +%s.%N)
|
||||
|
||||
for i in {1..3}; do
|
||||
{
|
||||
local cmd="source ~/.nvm/nvm.sh && nvm use $node_version && echo 'Task $i: Count to 3' | gemini --model gemini-2.5-pro"
|
||||
ssh $ssh_opts $host "$cmd" > "/tmp/gemini_multiplex_${host}_$i.out" 2>&1
|
||||
} &
|
||||
pids+=($!)
|
||||
done
|
||||
|
||||
wait
|
||||
local end_time=$(date +%s.%N)
|
||||
local duration=$(echo "$end_time - $start_time" | bc -l)
|
||||
|
||||
# Check results
|
||||
local successful=0
|
||||
for i in {1..3}; do
|
||||
if [[ -s "/tmp/gemini_multiplex_${host}_$i.out" ]]; then
|
||||
((successful++))
|
||||
fi
|
||||
done
|
||||
|
||||
# Clean up
|
||||
ssh $ssh_opts -O exit $host 2>/dev/null || true
|
||||
rm -f "$control_path" /tmp/gemini_multiplex_${host}_*.out
|
||||
|
||||
success "SSH multiplexed Gemini: $successful/3 tasks completed in ${duration:0:5}s"
|
||||
}
|
||||
|
||||
function run_ssh_pooling_tests() {
|
||||
local host=$1
|
||||
local node_version=$2
|
||||
|
||||
echo ""
|
||||
echo "🔗 SSH Connection Pooling Tests: $host"
|
||||
echo "======================================="
|
||||
|
||||
test_connection_reuse "$host"
|
||||
test_connection_limits "$host"
|
||||
test_connection_recovery "$host"
|
||||
test_gemini_via_ssh_multiplex "$host" "$node_version"
|
||||
|
||||
success "SSH pooling tests completed for $host"
|
||||
}
|
||||
|
||||
# Main execution
|
||||
echo "🚀 CCLI SSH Connection Pooling Test Suite"
|
||||
echo ""
|
||||
|
||||
# Check dependencies
|
||||
if ! command -v bc &> /dev/null; then
|
||||
error "bc not found. Install with: sudo apt-get install bc"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Test both machines
|
||||
run_ssh_pooling_tests "walnut" "v22.14.0"
|
||||
run_ssh_pooling_tests "ironwood" "v22.17.0"
|
||||
|
||||
# Performance comparison
|
||||
echo ""
|
||||
echo "📊 SSH Performance Analysis"
|
||||
echo "=========================="
|
||||
|
||||
if [[ -f "/tmp/ssh_reuse_walnut.txt" ]] && [[ -f "/tmp/ssh_reuse_ironwood.txt" ]]; then
|
||||
walnut_time=$(cat /tmp/ssh_reuse_walnut.txt)
|
||||
ironwood_time=$(cat /tmp/ssh_reuse_ironwood.txt)
|
||||
|
||||
log "SSH connection reuse performance:"
|
||||
log " WALNUT: ${walnut_time:0:5}s for 5 connections"
|
||||
log " IRONWOOD: ${ironwood_time:0:5}s for 5 connections"
|
||||
|
||||
faster=$(echo "$walnut_time < $ironwood_time" | bc -l)
|
||||
if [[ $faster -eq 1 ]]; then
|
||||
success "WALNUT has faster SSH connection reuse"
|
||||
else
|
||||
success "IRONWOOD has faster SSH connection reuse"
|
||||
fi
|
||||
fi
|
||||
|
||||
success "🎉 SSH pooling tests completed successfully!"
|
||||
echo ""
|
||||
echo "📋 Key Findings:"
|
||||
echo " ✅ SSH connection reuse working"
|
||||
echo " ✅ Multiple concurrent connections supported"
|
||||
echo " ✅ Connection recovery working"
|
||||
echo " ✅ SSH multiplexing with Gemini CLI functional"
|
||||
43
scripts/test-ssh-simple.sh
Executable file
43
scripts/test-ssh-simple.sh
Executable file
@@ -0,0 +1,43 @@
|
||||
#!/bin/bash
|
||||
|
||||
# Simple SSH Connection Test for CCLI
|
||||
set -e
|
||||
|
||||
GREEN='\033[0;32m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m'
|
||||
|
||||
function log() { echo -e "${BLUE}[$(date +'%H:%M:%S')]${NC} $1"; }
|
||||
function success() { echo -e "${GREEN}✅ $1${NC}"; }
|
||||
|
||||
echo "🔗 Simple SSH Connection Tests"
|
||||
|
||||
# Test basic SSH functionality
|
||||
for host in walnut ironwood; do
|
||||
log "Testing SSH to $host..."
|
||||
if ssh -o ConnectTimeout=5 $host "echo 'SSH working'; hostname; uptime | cut -d',' -f1"; then
|
||||
success "SSH connection to $host working"
|
||||
fi
|
||||
done
|
||||
|
||||
# Test SSH with connection sharing
|
||||
log "Testing SSH connection sharing..."
|
||||
control_path="/tmp/ssh_test_$$"
|
||||
ssh_opts="-o ControlMaster=auto -o ControlPath=$control_path -o ControlPersist=10"
|
||||
|
||||
# Establish master connection to walnut
|
||||
ssh $ssh_opts walnut "echo 'Master connection established'" > /dev/null
|
||||
|
||||
# Test reuse (should be very fast)
|
||||
start_time=$(date +%s.%N)
|
||||
ssh $ssh_opts walnut "echo 'Reused connection'"
|
||||
end_time=$(date +%s.%N)
|
||||
duration=$(echo "$end_time - $start_time" | bc -l)
|
||||
|
||||
success "SSH connection reuse took ${duration:0:4}s"
|
||||
|
||||
# Clean up
|
||||
ssh $ssh_opts -O exit walnut 2>/dev/null || true
|
||||
rm -f "$control_path"
|
||||
|
||||
success "SSH pooling tests completed successfully"
|
||||
Reference in New Issue
Block a user