Huawei Cloud Flexus L Deploy Jiuwenswarm

# JiuwenSwarm Configuration

# Server Configuration
server:
  host: 0.0.0.0
  port: 5173

# Logging Configuration
logging:
  level: INFO
  format: "%(asctime)s - %(levelname)s - %(message)s"

# Message Channel Configuration
channels:
  xiaoyi:
    enabled: false
    ak: ""
    sk: ""
    agent_id: ""
  
  feishu:
    enabled: false
    app_id: ""
    app_secret: ""
  
  dingtalk:
    enabled: false
    client_id: ""
    client_secret: ""
    allow_from: "*"

# Model Configuration (read from .env file)
model:
  api_base: ${API_BASE}
  api_key: ${API_KEY}
  model_name: ${MODEL_NAME}
  model_provider: ${MODEL_PROVIDER}

# Database Configuration
database:
  type: sqlite
  path: ./data/jiuwenswarm.db

# Security Configuration
security:
  allowed_origins:
    - "*"
  cors_enabled: true

#!/bin/bash
set -euo pipefail

# Color output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

# Log functions
log_info() {
    echo -e "${BLUE}[INFO]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}

log_success() {
    echo -e "${GREEN}[SUCCESS]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}

log_warning() {
    echo -e "${YELLOW}[WARNING]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}

log_error() {
    echo -e "${RED}[ERROR]${NC} $(date '+%Y-%m-%d %H:%M:%S') - $1"
}

echo "============================================================="
echo "          JiuwenSwarm Deployment Script"
echo "============================================================="

export DEBIAN_FRONTEND=noninteractive

# Create configuration directories
log_info "Creating configuration directories..."
mkdir -p /root/.jiuwenswarm/config
mkdir -p /root/.jiuwenswarm/logs
mkdir -p /root/.jiuwenswarm/data
mkdir -p /root/.jiuwenswarm/cache

# Create configuration files
log_info "Creating configuration files..."
cat > /root/.jiuwenswarm/config/config.yaml << 'CONFIGEOF'
channels:
  xiaoyi:
    enabled: false
    ak: ""
    sk: ""
    api_id: ""
    agent_id: ""
  
  feishu:
    enabled: false
    app_id: ""
    app_secret: ""
  
  dingtalk:
    enabled: false
    client_id: ""
    client_secret: ""
    allow_from: ""

database:
  type: sqlite
  path: /root/.jiuwenswarm/data/jiuwenswarm.db

cache:
  type: memory
  size: 1000

security:
  session_secret: "change-this-to-a-random-string"
  cors_origins: "*"
  rate_limit: 100
CONFIGEOF

cat > /root/.jiuwenswarm/config/.env << 'ENVEOL'
API_BASE=https://api.openai.com/v1
API_KEY=your-api-key-here
MODEL_NAME=gpt-4
MODEL_PROVIDER=openai

JIUWENSWARM_HOST=0.0.0.0
JIUWENSWARM_PORT=5173
JIUWENSWARM_LOG_LEVEL=INFO
ENVEOL

chmod 600 /root/.jiuwenswarm/config/config.yaml
chmod 600 /root/.jiuwenswarm/config/.env


log_info "Installing Python 3.11"
# 1. Install PPA tools
sudo apt update
sudo apt install -y software-properties-common

# 2. Add deadsnakes PPA (provides multiple Python versions)
sudo add-apt-repository ppa:deadsnakes/ppa -y

# 3. Update sources
sudo apt update

# 4. Install Python 3.11 + venv + dev
sudo apt install -y python3.11 python3.11-venv python3.11-dev

# 5. Verify installation
python3.11 --version


log_info "Creating Python virtual environment..."
python3.11 -m venv /opt/jiuwenswarm-env

source /opt/jiuwenswarm-env/bin/activate

log_info "Upgrading pip, setuptools, and wheel..."
pip install --upgrade pip setuptools wheel -q -i https://mirrors.aliyun.com/pypi/simple/

log_info "Installing JiuwenSwarm (using domestic mirror)..."
pip install jiuwenswarm -i https://mirrors.aliyun.com/pypi/simple/ --no-cache-dir

# Initialize JiuwenSwarm
log_info "Starting JiuwenSwarm initialization..."

# Use expect or printf to send all responses sequentially
# First try expect, use printf if unavailable
if command -v expect &> /dev/null; then
    log_info "Using expect to auto-answer interactive prompts..."
    expect << 'EOF'
set timeout 60
spawn jiuwenswarm-init --config /root/.jiuwenswarm/config/config.yaml
expect {
    "Do you want to continue? (yes/no):" {
        send "yes\r"
        exp_continue
    }
    "Please enter option (1, 2, zh, en) or no to cancel:" {
        send "1\r"
        exp_continue
    }
    "Enter option (1, 2, zh, en) or no to cancel:" {
        send "zh\r"
        exp_continue
    }
    eof {
        catch wait result
        exit [lindex $result 3]
    }
    timeout {
        puts "Initialization timeout"
        exit 1
    }
}
EOF
    init_result=$?
else
    log_info "Using printf to auto-answer interactive prompts..."
    # Use printf to send all responses with sufficient delay
    {
        echo "yes"
        sleep 2
        echo "1"
        sleep 2
    } | jiuwenswarm-init --config /root/.jiuwenswarm/config/config.yaml
    init_result=$?
fi

if [[ $init_result -eq 0 ]]; then
    log_success "JiuwenSwarm initialization completed"
else
    log_error "JiuwenSwarm initialization failed (exit code: $init_result)"
    log_info "Attempting alternative initialization method..."
    
    # Alternative: Use --yes and --lang parameters
    if jiuwenswarm-init --help 2>&1 | grep -q "--yes"; then
        log_info "Trying --yes and --lang parameters..."
        jiuwenswarm-init --config /root/.jiuwenswarm/config/config.yaml --yes --lang zh
        if [[ $? -eq 0 ]]; then
            log_success "JiuwenSwarm initialization completed (alternative method)"
            init_result=0
        else
            log_error "Alternative method also failed, please run initialization manually"
        fi
    else
        log_error "Cannot complete initialization automatically, please execute manually: jiuwenswarm-init --config /root/.jiuwenswarm/config/config.yaml"
        exit 1
    fi
fi

log_info "Creating systemd service..."
cat > /etc/systemd/system/jiuwenswarm.service << 'SERVICE_EOF'
[Unit]
Description=JiuwenSwarm Service
Description=Multi-Agent Collaboration Platform
After=network.target
Wants=network.target

[Service]
Type=simple
User=root
Group=root
WorkingDirectory=/opt/jiuwenswarm-env
EnvironmentFile=/root/.jiuwenswarm/config/.env
ExecStart=/opt/jiuwenswarm-env/bin/jiuwenswarm-start
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal
SyslogIdentifier=jiuwenswarm

[Install]
WantedBy=multi-user.target
SERVICE_EOF

log_info "Enabling and starting service..."
systemctl daemon-reload
systemctl enable jiuwenswarm
systemctl start jiuwenswarm

log_info "Waiting for service to start..."
sleep 15

log_info "Checking port listening..."
if netstat -tln | grep -q ':5173'; then
    log_success "Port 5173 is listening"
else
    log_error "Port 5173 is not listening"
    journalctl -u jiuwenswarm --no-pager | tail -20
    exit 1
fi

log_info "Checking service health status..."
if curl -s -o /dev/null -w "%{http_code}" http://localhost:5173/health | grep -q "200"; then
    log_success "Service health check passed"
else
    log_error "Service health check failed"
    journalctl -u jiuwenswarm --no-pager | tail -20
    exit 1
fi

log_success "JiuwenSwarm service started successfully!"
log_info "Web access address: http://$(hostname -I | awk '{print $1}'):5173"

echo "============================================================="
echo "          Deployment Complete"
echo "============================================================="

# JiuwenSwarm Environment Variables

# Model Configuration
API_BASE=https://api.openai.com/v1
API_KEY=your-api-key-here
MODEL_NAME=gpt-4
MODEL_PROVIDER=openai

# Service Configuration
PORT=5173
HOST=0.0.0.0

# Database Configuration
DATABASE_TYPE=sqlite
DATABASE_PATH=./data/jiuwenswarm.db

# Logging Configuration
LOG_LEVEL=INFO

# Security Configuration
SECRET_KEY=your-secret-key-here
ALLOWED_ORIGINS=*

# Huawei Cloud Configuration
HUAWEICLOUD_SDK_AK=your-ak-here
HUAWEICLOUD_SDK_SK=your-sk-here
HUAWEICLOUD_REGION=cn-north-4

[
  {
    "project_id": "",
    "region": "cn-north-4",
    "region_name": "华北-北京四"
  }
]

[Unit]
Description=JiuwenSwarm Service
After=network.target

[Service]
User=root
WorkingDirectory=/opt/jiuwenswarm-env/jiuwenswarm
Environment="PATH=/opt/jiuwenswarm-env/bin"
ExecStart=/opt/jiuwenswarm-env/bin/python -m jiuwenswarm
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
JiuwenSwarm Message Channel Configuration Script
Configures Xiaoyi, Feishu, or DingTalk message channels for JiuwenSwarm deployment.
Uses Huawei Cloud COC (Cloud Operation Center) to execute configuration commands on target instances.
"""

import os
import sys
import json
import argparse
import logging
from pathlib import Path
from datetime import datetime

os.environ['PYTHONIOENCODING'] = 'utf-8'

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
log = logging.getLogger(__name__)

EXECUTION_TIMEOUT = 300

CHANNEL_TYPES = ['xiaoyi', 'feishu', 'dingtalk']

# Import utility modules
sys.path.insert(0, str(Path(__file__).parent))
try:
    from utils import (
        get_huaweicloud_credentials,
        get_coc_client,
        coc_query_execution,
        print_header,
        print_success,
        print_error,
        print_warning,
        print_info
    )
except ImportError as e:
    log.error(f"Failed to import utility modules: {e}")
    log.error("Please ensure utils.py exists")
    sys.exit(1)

def query_instance_by_ip(public_ip, ak, sk, region, security_token=None):
    from huaweicloudsdkcore.auth.credentials import GlobalCredentials, BasicCredentials
    from huaweicloudsdkrms.v1 import RmsClient
    from huaweicloudsdkrms.v1.region.rms_region import RmsRegion

    # RMS requires GlobalCredentials
    if security_token:
        credentials = GlobalCredentials(ak, sk).with_security_token(security_token)
    else:
        credentials = GlobalCredentials(ak, sk)
    
    client = RmsClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(RmsRegion.value_of(region)) \
        .build()

    from huaweicloudsdkrms.v1 import model
    request = model.ListAllResourcesRequest()
    request.region_id = region
    request.type = "hcss.l-instance"
    request.limit = 200

    response = client.list_all_resources(request)
    resources = response.resources if hasattr(response, 'resources') else []

    for r in resources:
        name = getattr(r, 'name', '') or getattr(r, 'resource_name', '')
        instance_id = getattr(r, 'id', '') or getattr(r, 'resource_id', '')
        props = getattr(r, 'properties', None)

        ip = None
        ecs_instance_id = None

        if props:
            resources_list = props.get('resources', [])
            for res in resources_list:
                if isinstance(res, dict):
                    attrs = res.get('resource_attributes', [])
                    for attr in attrs:
                        if isinstance(attr, dict):
                            key = attr.get('key')
                            value = attr.get('value')
                            if key == 'public_ip_address':
                                ip = value
                            if key == 'associate_instance_id':
                                ecs_instance_id = value

        if ip == public_ip:
            return {
                'instance_name': name,
                'instance_id': instance_id,
                'ecs_instance_id': ecs_instance_id,
                'public_ip': ip,
                'region': region,
                'status': props.get('status') if props else 'UNKNOWN'
            }

    return None

def load_instance_info():
    info_file = Path(__file__).parent / "new_instance_info.json"
    if info_file.exists():
        with open(info_file, 'r', encoding='utf-8') as f:
            return json.load(f)
    return None

def create_and_execute_command(client, command, instance_id, instance_name, region):
    from huaweicloudsdkcoc.v1.model.create_script_request import CreateScriptRequest
    from huaweicloudsdkcoc.v1.model.add_script_model import AddScriptModel
    from huaweicloudsdkcoc.v1.model.script_properties_model import ScriptPropertiesModel
    from huaweicloudsdkcoc.v1.model.execute_script_request import ExecuteScriptRequest
    from huaweicloudsdkcoc.v1.model.script_execute_model import ScriptExecuteModel
    from huaweicloudsdkcoc.v1.model.execute_instances_batch_info import ExecuteInstancesBatchInfo
    from huaweicloudsdkcoc.v1.model.execute_resource_instance import ExecuteResourceInstance
    from huaweicloudsdkcoc.v1.model.script_execute_param import ScriptExecuteParam
    from huaweicloudsdkcore.exceptions import exceptions

    script_name = f"jiuwenswarm-channel-{datetime.now().strftime('%Y%m%d%H%M%S')}"
    description = f"JiuwenSwarm channel configuration on {instance_name}"

    log.info("Creating COC script for channel configuration...")
    request = CreateScriptRequest()
    properties = ScriptPropertiesModel(risk_level="LOW", version="1.0.0")
    request.body = AddScriptModel(
        name=script_name,
        type="SHELL",
        content=command,
        description=description,
        properties=properties
    )

    try:
        response = client.create_script(request)
        script_uuid = response.data if hasattr(response, 'data') else str(response)
        log.info(f"[OK] Script created: {script_uuid}")
    except exceptions.ClientRequestException as e:
        log.error(f"Script creation failed: {e.error_code}: {e.error_msg}")
        return None, None

    log.info("Executing command on target instance...")

    execute_request = ExecuteScriptRequest()
    execute_request.script_uuid = script_uuid

    execute_param = ScriptExecuteParam(timeout=EXECUTION_TIMEOUT, success_rate=100, execute_user="root")

    instance = ExecuteResourceInstance(
        resource_id=instance_id,
        region_id=region,
        provider="HCSS",
        type="L-INSTANCE"
    )

    execute_request.body = ScriptExecuteModel(
        execute_batches=[ExecuteInstancesBatchInfo(
            batch_index=1,
            target_instances=[instance],
            rotation_strategy="CONTINUE"
        )],
        execute_param=execute_param
    )

    try:
        execute_response = client.execute_script(execute_request)
        execute_uuid = execute_response.data if hasattr(execute_response, 'data') else str(execute_response)
        log.info(f"[OK] Execution submitted: {execute_uuid}")
        return execute_uuid, script_uuid
    except exceptions.ClientRequestException as e:
        log.error(f"Script execution failed: {e.error_code}: {e.error_msg}")
        return None, None

def wait_for_completion(client, execute_uuid, timeout=300, interval=10):
    """Wait for command execution to complete - using Huawei Cloud COC GetScriptJobInfo API"""
    import time
    
    print_info(f"\nWaiting for command execution...")
    print_info(f"Timeout: {timeout}s, Polling Interval: {interval}s")

    start_time = datetime.now()

    while True:
        elapsed = (datetime.now() - start_time).total_seconds()
        if elapsed > timeout:
            print_error(f"Command execution timeout ({timeout}s)")
            return False

        try:
            # Query status using Huawei Cloud COC GetScriptJobInfo API
            result = coc_query_execution(execute_uuid)
            
            if not result.get("ok"):
                error_info = result.get("error", {})
                print_warning(f"Status query failed: {error_info.get('message', 'Unknown error')}")
                time.sleep(interval)
                continue
            
            job_info = result.get("result", {})
            status = job_info.get('status', 'UNKNOWN')
            
            # Task status mapping
            STATUS_MAP = {
                'READY': 'Preparing',
                'PROCESSING': 'Processing',
                'FINISHED': 'Completed',
                'ABNORMAL': 'Abnormal',
                'CANCELED': 'Canceled'
            }
            status_display = STATUS_MAP.get(status, status)
            
            print(f"  Status: {status} ({status_display}) (Elapsed: {int(elapsed)}s)", end='\r')

            # According to Huawei Cloud COC API, script execution ends when status is ABNORMAL, CANCELED, or FINISHED
            if status == 'FINISHED':
                success_count = job_info.get('success_count', 0)
                fail_count = job_info.get('fail_count', 0)
                print(f"\n[OK] Command execution completed. Success: {success_count}, Failed: {fail_count}")
                return success_count > 0

            elif status in ['ABNORMAL', 'CANCELED']:
                error_msg = job_info.get('error', job_info.get('error_message', 'Unknown error'))
                print(f"\n[ERROR] Command execution failed! Status: {status} ({status_display})")
                if error_msg:
                    print_error(f"Error Message: {error_msg}")
                return False

        except Exception as e:
            print(f"\n[WARN] Error checking status: {e}")

        time.sleep(interval)

    return False

def generate_xiaoyi_script(config):
    """Generate Xiaoyi channel configuration script"""
    ak, sk, agent_id = config
    
    script = f"""#!/bin/bash
set -e

echo "[INFO] Configuring Xiaoyi channel..."

CONFIG_DIR="/root/.jiuwenswarm/config"
CONFIG_FILE="$CONFIG_DIR/config.yaml"

if [ ! -d "$CONFIG_DIR" ]; then
    echo "[ERROR] Config directory not found: $CONFIG_DIR"
    exit 1
fi

if [ ! -f "$CONFIG_FILE" ]; then
    echo "[WARN] Config file not found, creating new one..."
    cat > "$CONFIG_FILE" << 'EOF'
channels:
  xiaoyi:
    enabled: false
  feishu:
    enabled: false
  dingtalk:
    enabled: false
EOF
fi

echo "[INFO] Backup existing config file..."
cp "$CONFIG_FILE" "$CONFIG_FILE.backup.$(date +%Y%m%d%H%M%S)"

echo "[INFO] Updating Xiaoyi configuration..."

python3 << 'PYEOF'
import yaml
import os

config_file = "/root/.jiuwenswarm/config/config.yaml"

# Read existing configuration
with open(config_file, 'r', encoding='utf-8') as f:
    config = yaml.safe_load(f) or {{}}

# Ensure channels section exists
if 'channels' not in config:
    config['channels'] = {{}}

# Ensure xiaoyi configuration section exists
if 'xiaoyi' not in config['channels']:
    config['channels']['xiaoyi'] = {{}}

# Update only specified fields, keep other fields unchanged
xiaoyi_config = config['channels']['xiaoyi']

# Update Xiaoyi configuration
xiaoyi_config['ak'] = '{ak}'
xiaoyi_config['sk'] = '{sk}'
xiaoyi_config['agent_id'] = '{agent_id}'
xiaoyi_config['enabled'] = True

# Write updated configuration
with open(config_file, 'w', encoding='utf-8') as f:
    yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)

print("[OK] Xiaoyi configuration updated - only specific fields modified")
PYEOF

chmod 644 "$CONFIG_FILE"
echo "[OK] Configuration file permissions set"

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Stop JiuwenSwarm Service"
echo "[INFO] ==========================================="

if systemctl is-active --quiet jiuwenswarm; then
    echo "[INFO] Stopping jiuwenswarm service..."
    systemctl stop jiuwenswarm
    echo "[OK] jiuwenswarm service stopped"
else
    echo "[WARN] jiuwenswarm service is not running"
fi

echo ""
echo "[INFO] Waiting 3 seconds..."
sleep 3

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Restart JiuwenSwarm Service"
echo "[INFO] ==========================================="

echo "[INFO] Starting jiuwenswarm service..."
systemctl start jiuwenswarm

echo "[INFO] Waiting for service to start..."
sleep 5

if systemctl is-active --quiet jiuwenswarm; then
    echo "[OK] jiuwenswarm service started successfully"
    systemctl status jiuwenswarm --no-pager
else
    echo "[ERROR] Failed to start jiuwenswarm service"
    systemctl status jiuwenswarm --no-pager
    exit 1
fi

echo ""
echo "[INFO] ==========================================="
echo "[SUCCESS] Xiaoyi channel configuration completed"
echo "[INFO] ==========================================="
"""
    return script

def generate_feishu_script(config):
    """Generate Feishu channel configuration script"""
    app_id, app_secret = config
    
    script = f"""#!/bin/bash
set -e

echo "[INFO] Configuring Feishu channel..."

CONFIG_DIR="/root/.jiuwenswarm/config"
CONFIG_FILE="$CONFIG_DIR/config.yaml"

if [ ! -d "$CONFIG_DIR" ]; then
    echo "[ERROR] Config directory not found: $CONFIG_DIR"
    exit 1
fi

if [ ! -f "$CONFIG_FILE" ]; then
    echo "[WARN] Config file not found, creating new one..."
    cat > "$CONFIG_FILE" << 'EOF'
channels:
  xiaoyi:
    enabled: false
  feishu:
    enabled: false
  dingtalk:
    enabled: false
EOF
fi

echo "[INFO] Backup existing config file..."
cp "$CONFIG_FILE" "$CONFIG_FILE.backup.$(date +%Y%m%d%H%M%S)"

echo "[INFO] Updating Feishu configuration..."

python3 << 'PYEOF'
import yaml
import os

config_file = "/root/.jiuwenswarm/config/config.yaml"

# Read existing configuration
with open(config_file, 'r', encoding='utf-8') as f:
    config = yaml.safe_load(f) or {{}}

# Ensure channels section exists
if 'channels' not in config:
    config['channels'] = {{}}

# Ensure feishu configuration section exists
if 'feishu' not in config['channels']:
    config['channels']['feishu'] = {{}}

# Update only specified fields, keep other fields unchanged
feishu_config = config['channels']['feishu']

# Update Feishu configuration
feishu_config['app_id'] = '{app_id}'
feishu_config['app_secret'] = '{app_secret}'
feishu_config['enabled'] = True

# Write updated configuration
with open(config_file, 'w', encoding='utf-8') as f:
    yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)

print("[OK] Feishu configuration updated - only specific fields modified")
PYEOF

chmod 644 "$CONFIG_FILE"
echo "[OK] Configuration file permissions set"

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Stopping JiuwenSwarm Service"
echo "[INFO] ==========================================="

if systemctl is-active --quiet jiuwenswarm; then
    echo "[INFO] Stopping jiuwenswarm service..."
    systemctl stop jiuwenswarm
    echo "[OK] jiuwenswarm service stopped"
else
    echo "[WARN] jiuwenswarm service is not running"
fi

echo ""
echo "[INFO] Waiting 3 seconds..."
sleep 3

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Restarting JiuwenSwarm Service"
echo "[INFO] ==========================================="

echo "[INFO] Starting jiuwenswarm service..."
systemctl start jiuwenswarm

echo "[INFO] Waiting for service to start..."
sleep 5

if systemctl is-active --quiet jiuwenswarm; then
    echo "[OK] jiuwenswarm service started successfully"
    systemctl status jiuwenswarm --no-pager
else
    echo "[ERROR] Failed to start jiuwenswarm service"
    systemctl status jiuwenswarm --no-pager
    exit 1
fi

echo ""
echo "[INFO] ==========================================="
echo "[SUCCESS] Feishu channel configuration completed"
echo "[INFO] ==========================================="
"""
    return script

def generate_dingtalk_script(config):
    """Generate DingTalk channel configuration script"""
    client_id, client_secret, allow_from = config
    
    script = f"""#!/bin/bash
set -e

echo "[INFO] Configuring DingTalk channel..."

CONFIG_DIR="/root/.jiuwenswarm/config"
CONFIG_FILE="$CONFIG_DIR/config.yaml"

if [ ! -d "$CONFIG_DIR" ]; then
    echo "[ERROR] Config directory not found: $CONFIG_DIR"
    exit 1
fi

if [ ! -f "$CONFIG_FILE" ]; then
    echo "[WARN] Config file not found, creating new one..."
    cat > "$CONFIG_FILE" << 'EOF'
channels:
  xiaoyi:
    enabled: false
  feishu:
    enabled: false
  dingtalk:
    enabled: false
EOF
fi

echo "[INFO] Backup existing config file..."
cp "$CONFIG_FILE" "$CONFIG_FILE.backup.$(date +%Y%m%d%H%M%S)"

echo "[INFO] Updating DingTalk configuration..."

python3 << 'PYEOF'
import yaml
import os

config_file = "/root/.jiuwenswarm/config/config.yaml"

# Read existing configuration
with open(config_file, 'r', encoding='utf-8') as f:
    config = yaml.safe_load(f) or {{}}

# Ensure channels section exists
if 'channels' not in config:
    config['channels'] = {{}}

# Ensure dingtalk configuration section exists
if 'dingtalk' not in config['channels']:
    config['channels']['dingtalk'] = {{}}

# Update only specified fields, keep other fields unchanged
dingtalk_config = config['channels']['dingtalk']

# Update DingTalk configuration
dingtalk_config['client_id'] = '{client_id}'
dingtalk_config['client_secret'] = '{client_secret}'
dingtalk_config['allow_from'] = '{allow_from}'
dingtalk_config['enabled'] = True

# Write updated configuration
with open(config_file, 'w', encoding='utf-8') as f:
    yaml.dump(config, f, default_flow_style=False, allow_unicode=True, sort_keys=False)

print("[OK] DingTalk configuration updated - only specific fields modified")
PYEOF

chmod 644 "$CONFIG_FILE"
echo "[OK] Configuration file permissions set"

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Stopping JiuwenSwarm Service"
echo "[INFO] ==========================================="

if systemctl is-active --quiet jiuwenswarm; then
    echo "[INFO] Stopping jiuwenswarm service..."
    systemctl stop jiuwenswarm
    echo "[OK] jiuwenswarm service stopped"
else
    echo "[WARN] jiuwenswarm service is not running"
fi

echo ""
echo "[INFO] Waiting 3 seconds..."
sleep 3

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Restarting JiuwenSwarm Service"
echo "[INFO] ==========================================="

echo "[INFO] Starting jiuwenswarm service..."
systemctl start jiuwenswarm

echo "[INFO] Waiting for service to start..."
sleep 5

if systemctl is-active --quiet jiuwenswarm; then
    echo "[OK] jiuwenswarm service started successfully"
    systemctl status jiuwenswarm --no-pager
else
    echo "[ERROR] Failed to start jiuwenswarm service"
    systemctl status jiuwenswarm --no-pager
    exit 1
fi

echo ""
echo "[INFO] ==========================================="
echo "[SUCCESS] DingTalk channel configuration completed"
echo "[INFO] ==========================================="
"""
    return script

def configure_channel_interactive():
    print("="*60)
    print("  JiuwenSwarm Message Channel Configuration")
    print("="*60)
    print("\nPlease select channel type:")
    print("  1. xiaoyi - Xiaoyi")
    print("  2. feishu - Feishu")
    print("  3. dingtalk - DingTalk")

    while True:
        choice = input("\nEnter your choice (1/2/3): ").strip()
        if choice == '1':
            channel_type = 'xiaoyi'
            break
        elif choice == '2':
            channel_type = 'feishu'
            break
        elif choice == '3':
            channel_type = 'dingtalk'
            break
        else:
            print("[ERROR] Invalid choice, please enter 1, 2, or 3")

    print(f"\n--- {channel_type} Channel Configuration ---")

    if channel_type == 'xiaoyi':
        ak = input("Xiaoyi AK: ").strip()
        if not ak:
            print("[ERROR] AK cannot be empty")
            return None
        sk = input("Xiaoyi SK: ").strip()
        if not sk:
            print("[ERROR] SK cannot be empty")
            return None
        agent_id = input("Xiaoyi Agent ID: ").strip()
        if not agent_id:
            print("[ERROR] Agent ID cannot be empty")
            return None

        print("\n" + "="*60)
        print("  Configuration Confirmation")
        print("="*60)
        print(f"\n  Channel Type: Xiaoyi")
        print(f"  AK: {ak}")
        print(f"  SK: {'*' * len(sk) if len(sk) > 8 else sk}")
        print(f"  Agent ID: {agent_id}")

        confirm = input("\nConfirm configuration? (y/n): ").strip().lower()
        if confirm != 'y':
            print("[INFO] Configuration cancelled")
            return None

        return {
            'channel_type': channel_type,
            'config': (ak, sk, agent_id)
        }

    elif channel_type == 'feishu':
        app_id = input("Feishu App ID: ").strip()
        if not app_id:
            print("[ERROR] App ID cannot be empty")
            return None
        app_secret = input("Feishu App Secret: ").strip()
        if not app_secret:
            print("[ERROR] App Secret cannot be empty")
            return None

        print("\n" + "="*60)
        print("  Configuration Confirmation")
        print("="*60)
        print(f"\n  Channel Type: Feishu")
        print(f"  App ID: {app_id}")
        print(f"  App Secret: {'*' * len(app_secret) if len(app_secret) > 8 else app_secret}")

        confirm = input("\nConfirm configuration? (y/n): ").strip().lower()
        if confirm != 'y':
            print("[INFO] Configuration cancelled")
            return None

        return {
            'channel_type': channel_type,
            'config': (app_id, app_secret)
        }

    elif channel_type == 'dingtalk':
        client_id = input("DingTalk Client ID: ").strip()
        if not client_id:
            print("[ERROR] Client ID cannot be empty")
            return None
        client_secret = input("DingTalk Client Secret: ").strip()
        if not client_secret:
            print("[ERROR] Client Secret cannot be empty")
            return None
        allow_from = input("DingTalk Allow From: ").strip()
        if not allow_from:
            print("[ERROR] Allow From cannot be empty")
            return None

        print("\n" + "="*60)
        print("  Configuration Confirmation")
        print("="*60)
        print(f"\n  Channel Type: DingTalk")
        print(f"  Client ID: {client_id}")
        print(f"  Client Secret: {'*' * len(client_secret) if len(client_secret) > 8 else client_secret}")
        print(f"  Allow From: {allow_from}")

        confirm = input("\nConfirm configuration? (y/n): ").strip().lower()
        if confirm != 'y':
            print("[INFO] Configuration cancelled")
            return None

        return {
            'channel_type': channel_type,
            'config': (client_id, client_secret, allow_from)
        }

def parse_args():
    parser = argparse.ArgumentParser(description='Configure JiuwenSwarm Message Channels')
    parser.add_argument('--channel', type=str, required=True, choices=CHANNEL_TYPES, help='Channel type: xiaoyi/feishu/dingtalk')
    parser.add_argument('--xiaoyi-ak', type=str, help='Xiaoyi AK')
    parser.add_argument('--xiaoyi-sk', type=str, help='Xiaoyi SK')
    parser.add_argument('--xiaoyi-agent-id', type=str, help='Xiaoyi Agent ID')
    parser.add_argument('--feishu-app-id', type=str, help='Feishu App ID')
    parser.add_argument('--feishu-app-secret', type=str, help='Feishu App Secret')
    parser.add_argument('--dingtalk-client-id', type=str, help='DingTalk Client ID')
    parser.add_argument('--dingtalk-client-secret', type=str, help='DingTalk Client Secret')
    parser.add_argument('--dingtalk-allow-from', type=str, help='DingTalk Allow From')
    parser.add_argument('--instance-id', type=str, help='Instance RMS resource ID')
    parser.add_argument('--ip', type=str, help='Instance public IP address')
    parser.add_argument('--interactive', action='store_true', help='Interactive configuration mode')
    return parser.parse_args()

def main():
    args = parse_args()

    try:
        AK, SK, REGION, SECURITY_TOKEN = get_huaweicloud_credentials()
    except ValueError as e:
        print(f"[ERROR] {e}")
        sys.exit(1)

    if SECURITY_TOKEN:
        print(f"[INFO] Using temporary security credentials (STS token)")

    # Get configuration
    config_result = None
    if args.interactive:
        config_result = configure_channel_interactive()
    else:
        channel_type = args.channel
        config = None

        if channel_type == 'xiaoyi':
            if args.xiaoyi_ak and args.xiaoyi_sk and args.xiaoyi_agent_id:
                config = (args.xiaoyi_ak, args.xiaoyi_sk, args.xiaoyi_agent_id)
        elif channel_type == 'feishu':
            if args.feishu_app_id and args.feishu_app_secret:
                config = (args.feishu_app_id, args.feishu_app_secret)
        elif channel_type == 'dingtalk':
            if args.dingtalk_client_id and args.dingtalk_client_secret and args.dingtalk_allow_from:
                config = (args.dingtalk_client_id, args.dingtalk_client_secret, args.dingtalk_allow_from)

        if config:
            config_result = {
                'channel_type': channel_type,
                'config': config
            }

    if not config_result:
        print("[ERROR] Invalid configuration parameters")
        sys.exit(1)

    channel_type = config_result['channel_type']
    channel_config = config_result['config']

    # Get instance info
    instance_info = None
    if args.instance_id:
        instance_info = {'instance_id': args.instance_id, 'public_ip': args.ip, 'instance_name': 'Unknown'}
    elif args.ip:
        print(f"[INFO] Querying instance info by public IP: {args.ip}")
        instance_info = query_instance_by_ip(args.ip, AK, SK, REGION, SECURITY_TOKEN)
        if not instance_info:
            print(f"[ERROR] Cannot find instance with public IP: {args.ip}")
            return
    else:
        instance_info = load_instance_info()
        if not instance_info:
            print("[ERROR] Cannot get instance info")
            print("Please provide instance info via:")
            print("  Method 1: --ip <public_ip>")
            print("  Method 2: --instance-id <RMS_resource_id>")
            return

    instance_id = instance_info.get('instance_id')
    instance_name = instance_info.get('instance_name', 'Unknown')
    public_ip = instance_info.get('public_ip')

    if not instance_id:
        print("[ERROR] Missing instance_id")
        return

    print("\n" + "="*60)
    print("  Phase 7: Message Channel Configuration")
    print("="*60)
    print(f"\nTarget Instance:")
    print(f"  Name: {instance_name}")
    print(f"  IP: {public_ip}")
    print(f"\nChannel Configuration:")
    print(f"  Channel Type: {channel_type}")

    # Generate configuration script
    if channel_type == 'xiaoyi':
        script_content = generate_xiaoyi_script(channel_config)
    elif channel_type == 'feishu':
        script_content = generate_feishu_script(channel_config)
    elif channel_type == 'dingtalk':
        script_content = generate_dingtalk_script(channel_config)
    else:
        print("[ERROR] Invalid channel type")
        return

    client = get_coc_client()
    print("\n[INFO] Creating COC client... [OK]")

    execute_uuid, script_uuid = create_and_execute_command(
        client, script_content, instance_id, instance_name, REGION
    )

    if not execute_uuid:
        print("\n[ERROR] Failed to submit configuration command")
        return

    print("\n" + "="*60)
    print("  Configuration Progress")
    print("="*60)

    success = wait_for_completion(client, execute_uuid)

    print("\n" + "="*60)
    if success:
        print("  [SUCCESS] Message channel configuration completed")
    else:
        print("  [ERROR] Message channel configuration failed")
        sys.exit(1)
    print("="*60)

    print(f"\nWeb Access: http://{public_ip}:5173")
    print("\nNext Steps:")
    print("  1. Check service status: sudo systemctl status jiuwenswarm")
    print("  2. View logs: sudo journalctl -u jiuwenswarm -f")
    print("  3. Verify configuration: curl http://localhost:5173/health")

    result = {
        'channel_type': channel_type,
        'channel_config': {k: '***' for k in ['ak', 'sk', 'app_secret', 'client_secret']} if isinstance(channel_config, tuple) else '***',
        'instance_id': instance_id,
        'instance_name': instance_name,
        'public_ip': public_ip,
        'configure_time': datetime.now().isoformat(),
        'success': success
    }

    output_path = Path(__file__).parent / "channel_config_result.json"
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(result, f, indent=2, ensure_ascii=False)

    print(f"\n[INFO] Configuration result saved to {output_path}")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
JiuwenSwarm Model Configuration Script
Configures AI model parameters (API base, key, model name, provider) for JiuwenSwarm deployment.
Uses Huawei Cloud COC (Cloud Operation Center) to execute configuration commands on target instances.
"""

import os
import sys
import json
import argparse
import logging
from pathlib import Path
from datetime import datetime

os.environ['PYTHONIOENCODING'] = 'utf-8'

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
log = logging.getLogger(__name__)

EXECUTION_TIMEOUT = 300

# Import utility modules
sys.path.insert(0, str(Path(__file__).parent))
try:
    from utils import (
        get_huaweicloud_credentials,
        get_coc_client,
        coc_query_execution,
        print_header,
        print_success,
        print_error,
        print_warning,
        print_info
    )
except ImportError as e:
    log.error(f"Failed to import utility modules: {e}")
    log.error("Please ensure utils.py exists")
    sys.exit(1)

def query_instance_by_ip(public_ip, ak, sk, region, security_token=None):
    from huaweicloudsdkcore.auth.credentials import GlobalCredentials, BasicCredentials
    from huaweicloudsdkrms.v1 import RmsClient
    from huaweicloudsdkrms.v1.region.rms_region import RmsRegion

    # RMS requires GlobalCredentials
    if security_token:
        credentials = GlobalCredentials(ak, sk).with_security_token(security_token)
    else:
        credentials = GlobalCredentials(ak, sk)
    
    client = RmsClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(RmsRegion.value_of(region)) \
        .build()

    from huaweicloudsdkrms.v1 import model
    request = model.ListAllResourcesRequest()
    request.region_id = region
    request.type = "hcss.l-instance"
    request.limit = 200

    response = client.list_all_resources(request)
    resources = response.resources if hasattr(response, 'resources') else []

    for r in resources:
        name = getattr(r, 'name', '') or getattr(r, 'resource_name', '')
        instance_id = getattr(r, 'id', '') or getattr(r, 'resource_id', '')
        props = getattr(r, 'properties', None)

        ip = None
        ecs_instance_id = None

        if props:
            resources_list = props.get('resources', [])
            for res in resources_list:
                if isinstance(res, dict):
                    attrs = res.get('resource_attributes', [])
                    for attr in attrs:
                        if isinstance(attr, dict):
                            key = attr.get('key')
                            value = attr.get('value')
                            if key == 'public_ip_address':
                                ip = value
                            if key == 'associate_instance_id':
                                ecs_instance_id = value

        if ip == public_ip:
            return {
                'instance_name': name,
                'instance_id': instance_id,
                'ecs_instance_id': ecs_instance_id,
                'public_ip': ip,
                'region': region,
                'status': props.get('status') if props else 'UNKNOWN'
            }

    return None

def load_instance_info():
    info_file = Path(__file__).parent / "new_instance_info.json"
    if info_file.exists():
        with open(info_file, 'r', encoding='utf-8') as f:
            return json.load(f)
    return None

def create_and_execute_command(client, command, instance_id, instance_name, region):
    from huaweicloudsdkcoc.v1.model.create_script_request import CreateScriptRequest
    from huaweicloudsdkcoc.v1.model.add_script_model import AddScriptModel
    from huaweicloudsdkcoc.v1.model.script_properties_model import ScriptPropertiesModel
    from huaweicloudsdkcoc.v1.model.execute_script_request import ExecuteScriptRequest
    from huaweicloudsdkcoc.v1.model.script_execute_model import ScriptExecuteModel
    from huaweicloudsdkcoc.v1.model.execute_instances_batch_info import ExecuteInstancesBatchInfo
    from huaweicloudsdkcoc.v1.model.execute_resource_instance import ExecuteResourceInstance
    from huaweicloudsdkcoc.v1.model.script_execute_param import ScriptExecuteParam
    from huaweicloudsdkcore.exceptions import exceptions

    script_name = f"jiuwenswarm-config-{datetime.now().strftime('%Y%m%d%H%M%S')}"
    description = f"JiuwenSwarm model configuration on {instance_name}"

    log.info("Creating COC script for model configuration...")
    request = CreateScriptRequest()
    properties = ScriptPropertiesModel(risk_level="LOW", version="1.0.0")
    request.body = AddScriptModel(
        name=script_name,
        type="SHELL",
        content=command,
        description=description,
        properties=properties
    )

    try:
        response = client.create_script(request)
        script_uuid = response.data if hasattr(response, 'data') else str(response)
        log.info(f"[OK] Script created: {script_uuid}")
    except exceptions.ClientRequestException as e:
        log.error(f"Script creation failed: {e.error_code}: {e.error_msg}")
        return None, None

    log.info("Executing command on target instance...")

    execute_request = ExecuteScriptRequest()
    execute_request.script_uuid = script_uuid

    execute_param = ScriptExecuteParam(timeout=EXECUTION_TIMEOUT, success_rate=100, execute_user="root")

    instance = ExecuteResourceInstance(
        resource_id=instance_id,
        region_id=region,
        provider="HCSS",
        type="L-INSTANCE"
    )

    execute_request.body = ScriptExecuteModel(
        execute_batches=[ExecuteInstancesBatchInfo(
            batch_index=1,
            target_instances=[instance],
            rotation_strategy="CONTINUE"
        )],
        execute_param=execute_param
    )

    try:
        execute_response = client.execute_script(execute_request)
        execute_uuid = execute_response.data if hasattr(execute_response, 'data') else str(execute_response)
        log.info(f"[OK] Execution submitted: {execute_uuid}")
        return execute_uuid, script_uuid
    except exceptions.ClientRequestException as e:
        log.error(f"Script execution failed: {e.error_code}: {e.error_msg}")
        return None, None

def wait_for_completion(client, execute_uuid, timeout=300, interval=10):
    """Wait for command execution to complete - using Huawei Cloud COC GetScriptJobInfo API"""
    import time
    
    print_info(f"\nWaiting for command execution...")
    print_info(f"Timeout: {timeout}s, Polling Interval: {interval}s")

    start_time = datetime.now()

    while True:
        elapsed = (datetime.now() - start_time).total_seconds()
        if elapsed > timeout:
            print_error(f"Command execution timeout ({timeout}s)")
            return False

        try:
            # Query status using Huawei Cloud COC GetScriptJobInfo API
            result = coc_query_execution(execute_uuid)
            
            if not result.get("ok"):
                error_info = result.get("error", {})
                print_warning(f"Status query failed: {error_info.get('message', 'Unknown error')}")
                time.sleep(interval)
                continue
            
            job_info = result.get("result", {})
            status = job_info.get('status', 'UNKNOWN')
            
            # Task status mapping
            STATUS_MAP = {
                'READY': 'Preparing',
                'PROCESSING': 'Processing',
                'FINISHED': 'Completed',
                'ABNORMAL': 'Abnormal',
                'CANCELED': 'Canceled'
            }
            status_display = STATUS_MAP.get(status, status)
            
            print(f"  Status: {status} ({status_display}) (Elapsed: {int(elapsed)}s)", end='\r')

            # According to Huawei Cloud COC API, script execution ends when status is ABNORMAL, CANCELED, or FINISHED
            if status == 'FINISHED':
                success_count = job_info.get('success_count', 0)
                fail_count = job_info.get('fail_count', 0)
                print(f"\n[OK] Command execution completed. Success: {success_count}, Failed: {fail_count}")
                return success_count > 0

            elif status in ['ABNORMAL', 'CANCELED']:
                error_msg = job_info.get('error', job_info.get('error_message', 'Unknown error'))
                print(f"\n[ERROR] Command execution failed! Status: {status} ({status_display})")
                if error_msg:
                    print_error(f"Error Message: {error_msg}")
                return False

        except Exception as e:
            print(f"\n[WARN] Error checking status: {e}")

        time.sleep(interval)

    return False

def generate_config_script(config):
    api_base = config['api_base']
    api_key = config['api_key']
    model_name = config['model_name']
    model_provider = config['model_provider']
    
    test_script = '''#!/bin/bash
set -e

echo "[INFO] Configuring JiuwenSwarm model..."

CONFIG_DIR="/root/.jiuwenswarm/config"
ENV_FILE="$CONFIG_DIR/.env"

# Ensure config directory exists
mkdir -p "$CONFIG_DIR"

# If config file doesn't exist, create a basic config file
if [ ! -f "$ENV_FILE" ]; then
    echo "[INFO] Config file does not exist, creating new file"
    cat > "$ENV_FILE" << 'EOF'
# JiuwenSwarm Configuration
EOF
fi

# Backup existing config file
BACKUP_FILE="$ENV_FILE.backup.$(date +%Y%m%d%H%M%S)"
cp "$ENV_FILE" "$BACKUP_FILE"
echo "[INFO] Config file backed up: $BACKUP_FILE"

# Define the four parameters to update
API_BASE_VALUE="''' + api_base + '''"
API_KEY_VALUE="''' + api_key + '''"
MODEL_NAME_VALUE="''' + model_name + '''"
MODEL_PROVIDER_VALUE="''' + model_provider + '''"

# Use sed to update or add config parameters while preserving other content
update_param() {
    local key="$1"
    local value="$2"
    local env_file="$3"
    
    if grep -q "^[[:space:]]*$key=" "$env_file"; then
        # Parameter exists, update its value
        sed -i "s|^\s*$key=.*|$key=\"$value\"|" "$env_file"
        echo "[INFO] Updated $key"
    else
        # Parameter doesn't exist, add to end of file
        echo "$key=\"$value\"" >> "$env_file"
        echo "[INFO] Added $key"
    fi
}

# Update the four core parameters
update_param "API_BASE" "$API_BASE_VALUE" "$ENV_FILE"
update_param "API_KEY" "$API_KEY_VALUE" "$ENV_FILE"
update_param "MODEL_NAME" "$MODEL_NAME_VALUE" "$ENV_FILE"
update_param "MODEL_PROVIDER" "$MODEL_PROVIDER_VALUE" "$ENV_FILE"

echo "[INFO] Config file updated:"
echo "-----------------------------------------"
cat "$ENV_FILE"
echo "-----------------------------------------"

chmod 600 "$ENV_FILE"
echo "[OK] Configuration file permissions set"

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Stop JiuwenSwarm Service"
echo "[INFO] ==========================================="

if systemctl is-active --quiet jiuwenswarm; then
    echo "[INFO] Stopping jiuwenswarm service..."
    systemctl stop jiuwenswarm
    echo "[OK] jiuwenswarm service stopped"
else
    echo "[WARN] jiuwenswarm service is not running"
fi

echo ""
echo "[INFO] Waiting 3 seconds..."
sleep 3

echo ""
echo "[INFO] ==========================================="
echo "[INFO] Restart JiuwenSwarm Service"
echo "[INFO] ==========================================="

echo "[INFO] Starting jiuwenswarm service..."
systemctl start jiuwenswarm

echo "[INFO] Waiting for service to start..."
sleep 5

if systemctl is-active --quiet jiuwenswarm; then
    echo "[OK] jiuwenswarm service started successfully"
    systemctl status jiuwenswarm --no-pager
else
    echo "[ERROR] Failed to start jiuwenswarm service"
    systemctl status jiuwenswarm --no-pager
    exit 1
fi

echo ""
echo "[INFO] ==========================================="
echo "[SUCCESS] Model configuration completed!"
echo "[INFO] ==========================================="
'''
    return test_script

def configure_model_interactive():
    print("="*60)
    print("  JiuwenSwarm Model Configuration")
    print("="*60)
    print("\nPlease provide model configuration information:\n")

    api_base = input("Model API URL (API_BASE): ").strip()
    if not api_base:
        print("[ERROR] API URL cannot be empty")
        return None

    api_key = input("Model API Key (API_KEY): ").strip()
    if not api_key:
        print("[ERROR] API Key cannot be empty")
        return None

    model_name = input("Model Name (MODEL_NAME): ").strip()
    if not model_name:
        print("[ERROR] Model name cannot be empty")
        return None

    model_provider = input("Model Provider (MODEL_PROVIDER): ").strip()
    if not model_provider:
        print("[ERROR] Model provider cannot be empty")
        return None

    print("\n" + "="*60)
    print("  Configuration Confirmation")
    print("="*60)
    print(f"\n  API_BASE: {api_base}")
    print(f"  API_KEY: {'*' * len(api_key) if len(api_key) > 8 else api_key}")
    print(f"  MODEL_NAME: {model_name}")
    print(f"  MODEL_PROVIDER: {model_provider}")

    confirm = input("\nConfirm configuration? (y/n): ").strip().lower()
    if confirm != 'y':
        print("[INFO] Configuration cancelled")
        return None

    return {
        'api_base': api_base,
        'api_key': api_key,
        'model_name': model_name,
        'model_provider': model_provider
    }

def parse_args():
    parser = argparse.ArgumentParser(description='Configure JiuwenSwarm Model Parameters')
    parser.add_argument('--api-base', type=str, help='Model API URL')
    parser.add_argument('--api-key', type=str, help='Model API Key')
    parser.add_argument('--model-name', type=str, help='Model Name')
    parser.add_argument('--model-provider', type=str, help='Model Provider')
    parser.add_argument('--config', type=str, help='JSON configuration file')
    parser.add_argument('--instance-id', type=str, help='Instance RMS resource ID')
    parser.add_argument('--ip', type=str, help='Instance public IP address')
    parser.add_argument('--interactive', action='store_true', help='Interactive configuration mode')
    return parser.parse_args()

def main():
    args = parse_args()

    try:
        AK, SK, REGION, SECURITY_TOKEN = get_huaweicloud_credentials()
    except ValueError as e:
        print(f"[ERROR] {e}")
        sys.exit(1)

    if SECURITY_TOKEN:
        print(f"[INFO] Using temporary security credentials (STS token)")

    config = None
    if args.config:
        with open(args.config, 'r', encoding='utf-8') as f:
            config = json.load(f)
    elif args.api_base and args.api_key and args.model_name and args.model_provider:
        config = {
            'api_base': args.api_base,
            'api_key': args.api_key,
            'model_name': args.model_name,
            'model_provider': args.model_provider
        }
    elif args.interactive:
        config = configure_model_interactive()
    else:
        config = configure_model_interactive()

    if not config:
        return

    instance_info = None
    if args.instance_id:
        instance_info = {'instance_id': args.instance_id, 'public_ip': args.ip, 'instance_name': 'Unknown'}
    elif args.ip:
        print(f"[INFO] Querying instance info by public IP: {args.ip}")
        instance_info = query_instance_by_ip(args.ip, AK, SK, REGION, SECURITY_TOKEN)
        if not instance_info:
            print(f"[ERROR] Cannot find instance with public IP: {args.ip}")
            return
    else:
        instance_info = load_instance_info()
        if not instance_info:
            print("[ERROR] Cannot get instance info")
            print("Please provide instance info via:")
            print("  Method 1: --ip <public_ip>")
            print("  Method 2: --instance-id <RMS_resource_id>")
            return

    instance_id = instance_info.get('instance_id')
    instance_name = instance_info.get('instance_name', 'Unknown')
    public_ip = instance_info.get('public_ip')

    if not instance_id:
        print("[ERROR] Missing instance_id")
        return

    print("\n" + "="*60)
    print("  Phase 6: Configure JiuwenSwarm Model")
    print("="*60)
    print(f"\nTarget Instance:")
    print(f"  Name: {instance_name}")
    print(f"  IP: {public_ip}")
    print(f"\nModel Configuration:")
    print(f"  API_BASE: {config['api_base']}")
    print(f"  MODEL_NAME: {config['model_name']}")
    print(f"  MODEL_PROVIDER: {config['model_provider']}")

    script_content = generate_config_script(config)

    client = get_coc_client()
    print("\n[INFO] Creating COC client... [OK]")

    execute_uuid, script_uuid = create_and_execute_command(
        client, script_content, instance_id, instance_name, REGION
    )

    if not execute_uuid:
        print("\n[ERROR] Failed to submit configuration command")
        return

    print("\n" + "="*60)
    print("  Configuration Progress")
    print("="*60)

    success = wait_for_completion(client, execute_uuid)

    print("\n" + "="*60)
    if success:
        print("  [SUCCESS] Model configuration successful!")
    else:
        print("  [ERROR] Model configuration failed")
        sys.exit(1)
    print("="*60)

    print(f"\nWeb Access: http://{public_ip}:5173")
    print("\nNext Steps:")
    print("  1. Restart service to apply configuration:")
    print("     # Method 1: Use pkill to stop and start")
    print("     pkill -f jiuwen")
    print("     source /opt/jiuwenswarm-env/bin/activate && jiuwenswarm-start")
    print("")
    print("     # Method 2: Use systemd restart")
    print("     sudo systemctl restart jiuwenswarm")
    print("")
    print("     # Method 3: Use configuration update script (Recommended)")
    print("     bash /opt/jiuwenswarm-env/configure-and-restart.sh model /root/.jiuwenswarm/config/.env")
    print("")
    print("  2. Check service status: sudo systemctl status jiuwenswarm")
    print("  3. View logs: sudo journalctl -u jiuwenswarm -f")
    print("  4. Verify configuration: curl http://localhost:5173/health")

    result = {
        'config': config,
        'instance_id': instance_id,
        'instance_name': instance_name,
        'public_ip': public_ip,
        'configure_time': datetime.now().isoformat(),
        'success': success
    }

    output_path = Path(__file__).parent / "model_config_result.json"
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(result, f, indent=2, ensure_ascii=False)

    print(f"\n[INFO] Configuration result saved to {output_path}")
    print("\nNext step: Run config_channel.py to configure message channels")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Flexus L Instance Creation Script
Creates Huawei Cloud Flexus L instances for JiuwenSwarm deployment.
Handles instance provisioning, resource allocation, and status monitoring.
"""

import os
import sys
import json
import time
import uuid
import argparse
import logging
from datetime import datetime
from urllib.parse import urlparse
from pathlib import Path

os.environ['PYTHONIOENCODING'] = 'utf-8'

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
log = logging.getLogger(__name__)

try:
    import requests
except ImportError:
    log.error("requests module not installed")
    sys.exit(1)

FLEXUS_API_ENDPOINT = "https://hcss.cn-north-4.myhuaweicloud.com/v1/light-instances"

sys.path.insert(0, str(Path(__file__).parent))
from utils import get_huaweicloud_credentials


def get_project_id_by_region(ak: str, sk: str, security_token: Optional[str], region: str) -> Optional[str]:
    """Get Project ID for a specified region"""
    iam_endpoint = "https://iam.myhuaweicloud.com/v3/projects"
    
    try:
        from huaweicloudsdkcore.signer.signer import Signer
        from huaweicloudsdkcore.sdk_request import SdkRequest
        from huaweicloudsdkcore.auth.credentials import BasicCredentials, GlobalCredentials

        if security_token:
            credentials = BasicCredentials(ak, sk).with_security_token(security_token)
        else:
            credentials = BasicCredentials(ak, sk)
        signer = Signer(credentials)
        
        request = SdkRequest()
        request.method = "GET"
        request.schema = "https"
        request.host = "iam.myhuaweicloud.com"
        request.resource_path = "/v3/projects"
        request.body = ""
        request.header_params = {
            "Content-Type": "application/json",
            "Client-Request-Id": str(uuid.uuid4())
        }
        if security_token:
            request.header_params["X-Security-Token"] = security_token
        request.query_params = []
        
        signed_request = signer.sign(request)
        
        headers = {}
        for key, value in signed_request.header_params.items():
            if isinstance(value, bytes):
                headers[key] = value.decode('iso-8859-1')
            else:
                headers[key] = str(value)
        
        resp = requests.get(iam_endpoint, headers=headers, timeout=30)
        if resp.status_code == 200:
            data = resp.json()
            projects = data.get('projects', [])
            if projects:
                for project in projects:
                    project_name = project.get('name', '')
                    if project_name == region:
                        return project.get('id')
                return projects[0].get('id')
        return None
    except Exception as e:
        print(f"Failed to get Project ID: {e}")
        return None

def get_flexus_flavors_for_region(region: str):
    return {
        "small": "hf.small.1.linux",
        "medium": "hf.medium.1.linux",
        "large": "hf.large.1.linux",
        "xlarge": "hf.xlarge.1.linux",
        "2xlarge": "hf.2xlarge.1.linux"
    }

def create_flexus_l_instance(ak, sk, security_token, project_id, region, instance_name, flavor="medium", wait=True, timeout=600):
    flavors = get_flexus_flavors_for_region(region)
    flavor_ref = flavors.get(flavor)
    if not flavor_ref:
        raise ValueError(f"Unsupported flavor: {flavor}")

    request_body = {
        "instance_name": instance_name,
        "plan_spec": flavor_ref,
        "image_ref": {
            "image_name": "Ubuntu",
            "image_version": "24.04"
        },
        "region": region,
        "charging_mode": "prePaid",
        "period_type": "month",
        "period_num": 1,
        "purchase_quantity": 1,
        "description": f"JiuwenSwarm deployment - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
        "is_auto_renew": True,
        "is_auto_pay": True,
        "extra_resources": [
            {"type": "evs", "size": 50},
            {"type": "cbr", "size": 50},
            {"type": "hss"}
        ]
    }

    if not project_id:
        project_id = get_project_id_by_region(ak, sk, security_token, region)
        if not project_id:
            raise ValueError(f"Failed to get Project ID for region {region}")

    from huaweicloudsdkcore.signer.signer import Signer
    from huaweicloudsdkcore.sdk_request import SdkRequest
    from huaweicloudsdkcore.auth.credentials import GlobalCredentials, BasicCredentials

    # Use AK/SK direct signature to call Flexus L API, add X-Project-Id header to identify project
    credentials = BasicCredentials(ak, sk, project_id)
    if security_token:
        credentials = credentials.with_security_token(security_token)

    signer = Signer(credentials)

    parsed_url = urlparse(FLEXUS_API_ENDPOINT)
    body_str = json.dumps(request_body, ensure_ascii=False, separators=(',', ':'))

    request = SdkRequest()
    request.method = "POST"
    request.schema = parsed_url.scheme
    request.host = parsed_url.hostname
    request.resource_path = parsed_url.path
    request.body = body_str
    request.header_params = {
        "Content-Type": "application/json",
        "Client-Request-Id": str(uuid.uuid4()),
        "X-Id": "/v1/light-instances",
        "X-Project-Id": project_id
    }
    request.query_params = []

    signed_request = signer.sign(request)

    headers = {}
    for key, value in signed_request.header_params.items():
        if isinstance(value, bytes):
            headers[key] = value.decode('iso-8859-1')
        else:
            headers[key] = str(value)
    
    # Manually add X-Security-Token header for temporary credentials (not automatically added by SDK signing)
    if security_token:
        headers["X-Security-Token"] = security_token

    resp = requests.post(FLEXUS_API_ENDPOINT, headers=headers, data=body_str, timeout=30)

    if resp.status_code in [200, 201, 202]:
        result = resp.json()
        order_id = result.get('order_id')
        log.info(f"Instance creation request submitted, Order ID: {order_id}")
        return order_id
    else:
        log.error(f"Instance creation failed: HTTP {resp.status_code}, {resp.text}")
        return None

def query_instance_status(ak, sk, security_token, region, resource_id):
    from huaweicloudsdkcore.auth.credentials import GlobalCredentials
    from huaweicloudsdkrms.v1 import RmsClient
    from huaweicloudsdkrms.v1.region.rms_region import RmsRegion

    # RMS requires GlobalCredentials
    if security_token:
        credentials = GlobalCredentials(ak, sk).with_security_token(security_token)
    else:
        credentials = GlobalCredentials(ak, sk)
    
    client = RmsClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(RmsRegion.value_of(region)) \
        .build()

    from huaweicloudsdkrms.v1 import model
    request = model.ListAllResourcesRequest()
    request.region_id = region
    request.type = "hcss.l-instance"
    request.limit = 200

    response = client.list_all_resources(request)
    resources = response.resources if hasattr(response, 'resources') else []

    for r in resources:
        rid = getattr(r, 'id', '') or getattr(r, 'resource_id', '')
        if rid == resource_id:
            props = getattr(r, 'properties', None)
            if props:
                return props.get('status', 'UNKNOWN')
            return 'UNKNOWN'

    return None

def get_instance_info(ak, sk, security_token, region, resource_id):
    from huaweicloudsdkcore.auth.credentials import GlobalCredentials
    from huaweicloudsdkrms.v1 import RmsClient
    from huaweicloudsdkrms.v1.region.rms_region import RmsRegion

    # RMS requires GlobalCredentials
    if security_token:
        credentials = GlobalCredentials(ak, sk).with_security_token(security_token)
    else:
        credentials = GlobalCredentials(ak, sk)
    
    client = RmsClient.new_builder() \
        .with_credentials(credentials) \
        .with_region(RmsRegion.value_of(region)) \
        .build()

    from huaweicloudsdkrms.v1 import model
    request = model.ListAllResourcesRequest()
    request.region_id = region
    request.type = "hcss.l-instance"
    request.limit = 200

    response = client.list_all_resources(request)
    resources = response.resources if hasattr(response, 'resources') else []

    for r in resources:
        rid = getattr(r, 'id', '') or getattr(r, 'resource_id', '')
        if rid == resource_id:
            name = getattr(r, 'name', '') or getattr(r, 'resource_name', '')
            instance_id = rid
            props = getattr(r, 'properties', None)

            public_ip = None
            ecs_instance_id = None

            if props:
                resources_list = props.get('resources', [])
                for res in resources_list:
                    if isinstance(res, dict):
                        attrs = res.get('resource_attributes', [])
                        for attr in attrs:
                            if isinstance(attr, dict):
                                key = attr.get('key')
                                value = attr.get('value')
                                if key == 'public_ip_address':
                                    public_ip = value
                                if key == 'associate_instance_id':
                                    ecs_instance_id = value

            return {
                'instance_name': name,
                'instance_id': instance_id,
                'ecs_instance_id': ecs_instance_id,
                'public_ip': public_ip,
                'region': region,
                'status': props.get('status') if props else 'UNKNOWN'
            }

    return None

def show_confirmation(instance_name, flavor, region):
    flavor_display = {
        "small": "small (1 vCPU, 2GB RAM)",
        "medium": "medium (2 vCPU, 4GB RAM)",
        "large": "large (4 vCPU, 8GB RAM)",
        "xlarge": "xlarge (8 vCPU, 16GB RAM)",
        "2xlarge": "2xlarge (16 vCPU, 32GB RAM)"
    }

    print("\n" + "=" * 60)
    print("  ⚠️ Cloud Resource Creation Confirmation")
    print("=" * 60)
    print(f"\nOperation to perform: Create new Flexus L Instance\n")
    print("Instance Specification:")
    print(f"  - Name: {instance_name}")
    print(f"  - Flavor: {flavor_display.get(flavor, flavor)}")
    print(f"  - Region: {region}")
    print(f"  - Estimated Cost: ~100 CNY/month (actual price subject to Huawei Cloud pricing)\n")
    print("Resources will be created immediately after confirmation.")
    print("=" * 60)
    print("\nPlease enter 'confirm' or 'yes' to continue:")
    print("> ", end="")

    response = input().strip().lower()
    return response in ['confirm', 'yes', 'ok', 'y']

def parse_args():
    parser = argparse.ArgumentParser(description='Create Flexus L Instance')
    parser.add_argument('--name', type=str, default=f"jiuwenSwarm-{datetime.now().strftime('%Y%m%d%H%M%S')}", help='Instance name')
    parser.add_argument('--flavor', type=str, default='medium', choices=['small', 'medium', 'large', 'xlarge', '2xlarge'], help='Instance flavor')
    parser.add_argument('--region', type=str, default='cn-north-4', help='Region (cn-north-4 only)')
    parser.add_argument('--wait', action='store_true', help='Wait for instance creation to complete')
    parser.add_argument('--timeout', type=int, default=600, help='Timeout in seconds')
    parser.add_argument('--confirm', action='store_true', help='Skip confirmation prompt')
    return parser.parse_args()

def main():
    args = parse_args()

    print("\n" + "=" * 60)
    print("  Phase 2: Create Flexus L Instance")
    print("=" * 60)

    try:
        AK, SK, REGION, SECURITY_TOKEN = get_huaweicloud_credentials()
    except ValueError as e:
        print(f"[ERROR] {e}")
        sys.exit(1)

    # Validate region - only cn-north-4 is supported
    if args.region != 'cn-north-4':
        print(f"[ERROR] Only cn-north-4 region is supported, current region: {args.region}")
        print("[INFO] Please use --region cn-north-4 or use the default value")
        sys.exit(1)

    if SECURITY_TOKEN:
        print(f"[INFO] Using temporary security credentials (STS token)")

    if not args.confirm:
        if not show_confirmation(args.name, args.flavor, args.region):
            print("\n[INFO] User cancelled operation")
            sys.exit(0)

    print(f"\n[INFO] Starting to create Flexus L instance...")
    print(f"[INFO] Instance name: {args.name}")
    print(f"[INFO] Flavor: {args.flavor}")
    print(f"[INFO] Region: {args.region}")

    project_id = get_project_id_by_region(AK, SK, SECURITY_TOKEN, args.region)
    if not project_id:
        print("[ERROR] Failed to get Project ID")
        sys.exit(1)
    print(f"[INFO] Project ID: {project_id}")

    order_id = create_flexus_l_instance(AK, SK, SECURITY_TOKEN, project_id, args.region, args.name, args.flavor, args.wait, args.timeout)
    if not order_id:
        print("[ERROR] Instance creation request failed")
        sys.exit(1)

    print(f"[INFO] Order ID: {order_id}")

    result_file = Path(__file__).parent / "instance_order.json"
    with open(result_file, 'w', encoding='utf-8') as f:
        json.dump({'order_id': order_id, 'instance_name': args.name, 'flavor': args.flavor, 'region': args.region}, f, indent=2)
    print(f"[INFO] Order information saved to: {result_file}")

    if args.wait:
        print(f"\n[INFO] Waiting for instance creation to complete (timeout: {args.timeout} seconds)...")

        elapsed = 0
        interval = 30
        resource_id = None

        while elapsed < args.timeout:
            time.sleep(interval)
            elapsed += interval

            try:
                from huaweicloudsdkcore.auth.credentials import GlobalCredentials, BasicCredentials
                from huaweicloudsdkrms.v1 import RmsClient
                from huaweicloudsdkrms.v1.region.rms_region import RmsRegion
                from huaweicloudsdkrms.v1 import model

                if SECURITY_TOKEN:
                    credentials = GlobalCredentials(AK, SK).with_security_token(SECURITY_TOKEN)
                else:
                    credentials = GlobalCredentials(AK, SK)
                
                client = RmsClient.new_builder() \
                    .with_credentials(credentials) \
                    .with_region(RmsRegion.value_of(args.region)) \
                    .build()

                request = model.ListAllResourcesRequest()
                request.region_id = args.region
                request.type = "hcss.l-instance"
                request.limit = 200

                response = client.list_all_resources(request)
                resources = response.resources if hasattr(response, 'resources') else []

                for r in resources:
                    name = getattr(r, 'name', '') or getattr(r, 'resource_name', '')
                    if name == args.name:
                        resource_id = getattr(r, 'id', '') or getattr(r, 'resource_id', '')
                        props = getattr(r, 'properties', None)
                        status = props.get('status') if props else 'UNKNOWN'
                        print(f"[{elapsed}s] Instance status: {status}")

                        if status == 'RUNNING':
                            print("\n[SUCCESS] Instance created successfully!")
                            instance_info = get_instance_info(AK, SK, SECURITY_TOKEN, args.region, resource_id)
                            if instance_info:
                                info_file = Path(__file__).parent / "new_instance_info.json"
                                with open(info_file, 'w', encoding='utf-8') as f:
                                    json.dump(instance_info, f, indent=2, ensure_ascii=False)
                                print(f"[INFO] Instance information saved to: {info_file}")
                                print(f"\nInstance Information:")
                                print(f"  - Instance ID: {instance_info['instance_id']}")
                                print(f"  - Public IP: {instance_info['public_ip']}")
                                print(f"  - ECS Instance ID: {instance_info['ecs_instance_id']}")
                            print("\nNext step: Run install_deps.py for COC remote dependency installation")
                            sys.exit(0)
                        break

            except Exception as e:
                print(f"[WARN] Error querying instance status: {e}")

        print("[ERROR] Instance creation timeout")
        sys.exit(1)

    print("\n[INFO] Instance creation request submitted, use RMS API to query instance status")
    print("Next step: Run install_deps.py for COC remote dependency installation")

if __name__ == "__main__":
    main()