🤖 Kilocode + Gmail Creator - Dual Automation System

Unified Gmail account creation using both LLM intelligence and RPA automation

This project implements two parallel approaches for automated Gmail account creation:

• 🤖 Kilocode LLM: Intelligent form filling using Large Language Models (OpenAI/Claude)
• 🔧 RPA BitBrowser: Traditional browser automation with antidetect profiles

🎯 Key Features

Dual Automation Approaches

• LLM-Powered: AI-driven form filling with intelligent responses to dynamic challenges
• RPA-Based: Traditional browser automation with BitBrowser antidetect profiles
• Hybrid Controller: Intelligent routing between approaches based on success rates and requirements

Advanced Capabilities

• Intelligent Routing: Automatically selects optimal approach based on success rates and complexity
• Failover Support: Falls back to alternative approach if primary method fails
• Real-time Dashboard: Web-based monitoring and control interface
• Comprehensive Testing: Full integration test suite for both systems
• Performance Monitoring: Detailed statistics and cost tracking

🚀 Quick Start

Prerequisites

• Node.js 14+
• BitBrowser application (for RPA automation)
• OpenAI or Claude API key (for LLM automation)

Installation

# Clone repository
git clone <repository-url>
cd "gmail kilocode creator bybitbot"

# Install dependencies
npm install

# Configure API keys (optional)
npm run kilocode:config -- --openai-key "your-api-key"

Basic Usage

1. Check System Status

npm run kilocode:status

2. Run LLM Automation

# Basic LLM automation
npm run kilocode:llm

# With options
npm run kilocode:llm -- --country DE --age "young adult" --provider openai

3. Run RPA Automation

# Basic RPA automation
npm run kilocode:rpa

# Multiple profiles
npm run kilocode:rpa -- --profiles 3 --country US

4. Run Hybrid Automation (Recommended)

# Intelligent routing
npm run kilocode:hybrid

# Force specific strategy
npm run kilocode:hybrid -- --strategy llm --count 5 --failover

5. Start Web Dashboard

npm run kilocode:dashboard
# Access at http://localhost:3000

📊 System Architecture

Components Overview

┌─────────────────────────────────────────────────────────────┐
│                    Unified Dashboard                        │
│              Web Interface + Real-time WS                  │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────────────┐
│                Hybrid Controller                           │
│           Intelligent Routing + Fallback                   │
└─────────────┬───────────────────────────────┬───────────────┘
              │                               │
    ┌─────────▼─────────┐           ┌─────────▼─────────┐
    │  Kilocode LLM     │           │   RPA Engine      │
    │  - OpenAI/Claude  │           │  - BitBrowser     │
    │  - Smart Forms    │           │  - Playwright     │
    │  - Dynamic AI     │           │  - Antidetect     │
    └───────────────────┘           └───────────────────┘

Decision Matrix

Requirement	LLM Approach	RPA Approach
Speed	⚡ Fast (API calls)	🐌 Slower (browser)
Cost	💰 API costs	💰 Low operational
Complexity	🧠 Handles dynamic	🔧 Structured only
Reliability	📊 Depends on API	🎯 Browser-dependent
Scalability	⬆️ High	⬆️ Limited by profiles

🔧 Configuration

Environment Variables

# LLM Configuration
OPENAI_API_KEY=your_openai_key
CLAUDE_API_KEY=your_claude_key

# BitBrowser Configuration
BITBROWSER_PORT=35100
BITBROWSER_API=http://127.0.0.1:35100

# Dashboard Configuration
DASHBOARD_PORT=3000
DASHBOARD_WS_PORT=3001

Configuration File (.kilocode-config.json)

{
  "openaiApiKey": "your-api-key",
  "claudeApiKey": "your-claude-key",
  "bitbrowserPort": 35100,
  "defaultStrategy": "intelligent",
  "failoverEnabled": true,
  "rateLimiting": {
    "requestsPerMinute": 60,
    "tokensPerMinute": 90000
  }
}

📋 Available Commands

Main Commands

# Unified CLI
npm run kilocode                    # Show help
npm run kilocode:status            # Check system health
npm run kilocode:config            # Configure settings

# Automation Commands
npm run kilocode:llm               # LLM automation
npm run kilocode:rpa               # RPA automation
npm run kilocode:hybrid            # Hybrid automation
npm run kilocode:dashboard         # Start dashboard

# Testing Commands
npm run kilocode:test              # Run all tests
npm run test:llm                   # Test LLM only
npm run test:rpa                   # Test RPA only
npm run test:hybrid                # Test hybrid only

Legacy Commands (Still Available)

# BitBrowser Management
npm run create-profiles            # Create BitBrowser profiles
npm run list-profiles              # List existing profiles
npm run check-bitbrowser           # Check BitBrowser status

# Automa Workflows
npm run automa:simple              # Simple Automa workflow
npm run automa:full                # Full Automa workflow

🎯 Usage Examples

Example 1: Intelligent Account Creation

# Let the system choose the best approach
npm run kilocode:hybrid -- \
  --strategy intelligent \
  --country "DE" \
  --count 3 \
  --failover

Example 2: LLM with Custom Requirements

# Use LLM for complex requirements
npm run kilocode:llm -- \
  --country "France" \
  --age "middle aged" \
  --gender "female" \
  --provider claude \
  --debug

Example 3: RPA Batch Processing

# Use RPA for bulk creation
npm run kilocode:rpa -- \
  --profiles 10 \
  --country "US" \
  --headless

Example 4: Dashboard with Real-time Monitoring

# Start dashboard and create accounts via web interface
npm run kilocode:dashboard
# Navigate to http://localhost:3000

📊 Monitoring & Analytics

Dashboard Features

• Real-time Statistics: Success rates, costs, execution times
• Strategy Comparison: Performance metrics for LLM vs RPA
• Live Account Creation: Create accounts via web interface
• Health Monitoring: System status and component health
• Activity Logs: Detailed execution logs and error tracking

Performance Metrics

# Example output from npm run kilocode:status
🔍 Checking System Status...

🤖 LLM System:
   API Key: ✅ Configured
   Success Rate: 87.5%
   Avg Cost: $0.034/account

🔧 RPA System:
   BitBrowser: ✅ Running
   Port: 35100
   Success Rate: 92.1%
   Avg Cost: $0.018/account

📊 Hybrid Controller:
   Total Sessions: 156
   LLM Preferred: 89 (57%)
   RPA Preferred: 67 (43%)
   Fallbacks: 12 (7.7%)

🧪 Testing

Comprehensive Test Suite

# Run all tests
npm run test:integration

# Run specific test suites
npm run test:llm                   # LLM components only
npm run test:rpa                   # RPA components only
npm run test:hybrid                # Hybrid controller only

# Run with debug output
npm run kilocode:test -- --debug

Test Reports

Tests generate detailed HTML and JSON reports in ./test-results/:

• integration-test-report.html - Human-readable report
• integration-test-report.json - Machine-readable data
• Individual session logs and error reports

🔍 Troubleshooting

Common Issues

LLM API Errors

# Check API key configuration
npm run kilocode:status

# Test with debug mode
npm run kilocode:llm -- --debug

# Configure API key
npm run kilocode:config -- --openai-key "your-key"

BitBrowser Connection Issues

# Check BitBrowser status
npm run check-bitbrowser

# Test BitBrowser integration
npm run bitbrowser:test

# Restart BitBrowser and try again

Performance Issues

# Check system health
npm run kilocode:status

# Run performance tests
npm run kilocode:test -- --performance

# Monitor via dashboard
npm run kilocode:dashboard

Debug Mode

Enable debug mode for detailed logging:

# Any command with debug
npm run kilocode:hybrid -- --debug
npm run kilocode:test -- --debug

📈 Performance Optimization

LLM Optimization

• Rate Limiting: Configured to stay within API limits
• Cost Management: Token counting and cost tracking
• Intelligent Caching: Reuse responses where appropriate
• Fallback Data: Backup generation when API fails

RPA Optimization

• Resource Blocking: Block images/CSS for faster execution
• Profile Reuse: Efficiently manage BitBrowser profiles
• Parallel Execution: Multiple profiles simultaneously
• Error Recovery: Automatic retry and recovery mechanisms

Hybrid Intelligence

• Success Rate Learning: Adapts strategy based on performance
• Complexity Analysis: Routes complex tasks to LLM
• Cost Optimization: Balances quality vs cost
• Failover Logic: Smart fallback between approaches

🔐 Security & Best Practices

API Security

• Environment variable configuration
• Rate limiting and quota management
• Error handling without exposing sensitive data
• Secure credential storage

Browser Security

• Antidetect profile management
• Proxy rotation support
• Session isolation
• Fingerprint randomization

Operational Security

• Comprehensive logging without sensitive data
• Error tracking and monitoring
• Health checks and alerting
• Graceful degradation

📦 Project Structure

gmail kilocode creator bybitbot/
├── 🤖 LLM Components
│   ├── kilocode-llm-api.js           # LLM API integration
│   └── kilocode-form-engine.js       # Intelligent form filling
├── 🔧 RPA Components
│   ├── real-browser-automation.js    # Enhanced browser automation
│   ├── bitbrowser-profile-manager.js # Profile management
│   └── automa-*.json                 # Workflow definitions
├── 🎯 Hybrid System
│   ├── hybrid-automation-controller.js # Main controller
│   └── unified-dashboard.js          # Web dashboard
├── 🧪 Testing
│   └── comprehensive-integration-tests.js # Test suite
├── 🚀 Main Interface
│   ├── kilocode-main.js              # CLI interface
│   └── package.json                  # Scripts and dependencies
└── 📊 Reports & Logs
    ├── test-results/                 # Test reports
    ├── logs/                         # Execution logs
    └── reports/                      # Session reports

🤝 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

Development Setup

# Install development dependencies
npm install

# Run tests
npm run test:integration

# Start dashboard in development mode
npm run kilocode:dashboard -- --debug

# Check code health
npm run kilocode:status

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

⚠️ Disclaimer

This software is for educational and research purposes only. Users are responsible for complying with all applicable terms of service and local laws. The authors assume no responsibility for misuse of this software.

🙏 Acknowledgments

• OpenAI & Anthropic for LLM APIs
• BitBrowser for antidetect browser technology
• Playwright for browser automation capabilities
• Automa for workflow inspiration
• Node.js community for excellent tooling

---

Made with ❤️ by KiloCode Creator

Bridging AI intelligence with traditional automation