OpenClaw 自动优化启动脚本

openclaw OpenClaw手册 2026-04-09 6

我来帮你创建一个自动适配的OpenClaw工具，OpenClaw通常指的是一个多功能自动化工具或抓取系统,这里我设计一个通用的自动适配框架：

OpenClaw 自动优化启动脚本-第1张图片-OpenClaw 开源免费 -中文免费安装

import platform
import os
import sys
import subprocess
import time
from typing import Dict, Any, Optional, List
import json
class OpenClawAutoAdapter:
    """
    OpenClaw 自动适配器
    根据运行环境自动调整配置和参数
    """
    def __init__(self):
        self.system_info = self._detect_system()
        self.config = self._load_default_config()
        self.adaptations = {}
    def _detect_system(self) -> Dict[str, Any]:
        """检测系统信息"""
        system_info = {
            'platform': platform.system(),
            'platform_release': platform.release(),
            'platform_version': platform.version(),
            'architecture': platform.machine(),
            'processor': platform.processor(),
            'python_version': platform.python_version(),
            'cwd': os.getcwd(),
            'cpu_count': os.cpu_count(),
            'memory': self._get_memory_info()
        }
        return system_info
    def _get_memory_info(self) -> Dict[str, Any]:
        """获取内存信息"""
        try:
            import psutil
            memory = psutil.virtual_memory()
            return {
                'total': memory.total,
                'available': memory.available,
                'percent': memory.percent,
                'used': memory.used,
                'free': memory.free
            }
        except ImportError:
            return {'error': 'psutil not installed'}
    def _load_default_config(self) -> Dict[str, Any]:
        """加载默认配置"""
        return {
            'performance_mode': 'balanced',
            'concurrency_level': 4,
            'timeout': 30,
            'retry_count': 3,
            'cache_enabled': True,
            'log_level': 'INFO',
            'platform_specific': {}
        }
    def auto_adapt(self) -> Dict[str, Any]:
        """执行自动适配"""
        adaptations = {}
        # 根据系统平台适配
        adaptations.update(self._adapt_by_platform())
        # 根据硬件性能适配
        adaptations.update(self._adapt_by_hardware())
        # 根据网络环境适配
        adaptations.update(self._adapt_by_network())
        # 根据应用场景适配
        adaptations.update(self._adapt_by_scenario())
        self.adaptations = adaptations
        return adaptations
    def _adapt_by_platform(self) -> Dict[str, Any]:
        """根据平台适配"""
        adaptations = {}
        platform_name = self.system_info['platform']
        if platform_name == 'Windows':
            adaptations.update({
                'path_separator': '\\',
                'temp_dir': os.getenv('TEMP', 'C:\\Temp'),
                'max_path_length': 260,
                'shell_mode': 'cmd' if os.getenv('COMSPEC') else 'powershell'
            })
        elif platform_name == 'Linux':
            adaptations.update({
                'path_separator': '/',
                'temp_dir': '/tmp',
                'max_path_length': 4096,
                'shell_mode': 'bash'
            })
        elif platform_name == 'Darwin':  # macOS
            adaptations.update({
                'path_separator': '/',
                'temp_dir': '/tmp',
                'max_path_length': 1024,
                'shell_mode': 'zsh'
            })
        # 设置平台特定的环境变量
        adaptations['env_vars'] = self._get_platform_env_vars()
        return adaptations
    def _adapt_by_hardware(self) -> Dict[str, Any]:
        """根据硬件性能适配"""
        adaptations = {}
        # 根据CPU核心数调整并发
        cpu_count = self.system_info.get('cpu_count', 4)
        if cpu_count >= 8:
            adaptations['concurrency_level'] = min(cpu_count - 2, 16)
            adaptations['performance_mode'] = 'high'
        elif cpu_count >= 4:
            adaptations['concurrency_level'] = cpu_count
            adaptations['performance_mode'] = 'balanced'
        else:
            adaptations['concurrency_level'] = max(1, cpu_count - 1)
            adaptations['performance_mode'] = 'low'
        # 根据内存调整
        memory_info = self.system_info.get('memory', {})
        if isinstance(memory_info, dict) and 'total' in memory_info:
            total_memory = memory_info['total'] / (1024**3)  # 转换为GB
            if total_memory >= 16:
                adaptations['batch_size'] = 1000
                adaptations['cache_size'] = '2GB'
            elif total_memory >= 8:
                adaptations['batch_size'] = 500
                adaptations['cache_size'] = '1GB'
            else:
                adaptations['batch_size'] = 100
                adaptations['cache_size'] = '512MB'
        return adaptations
    def _adapt_by_network(self) -> Dict[str, Any]:
        """根据网络环境适配"""
        adaptations = {
            'network_timeout': 30,
            'chunk_size': 8192,
            'use_compression': True
        }
        try:
            # 测试网络延迟
            import socket
            start = time.time()
            socket.create_connection(("8.8.8.8", 53), timeout=2)
            latency = (time.time() - start) * 1000  # 转换为毫秒
            if latency < 50:
                adaptations.update({
                    'network_mode': 'fast',
                    'chunk_size': 16384,
                    'parallel_downloads': 5
                })
            elif latency < 200:
                adaptations.update({
                    'network_mode': 'normal',
                    'chunk_size': 8192,
                    'parallel_downloads': 3
                })
            else:
                adaptations.update({
                    'network_mode': 'slow',
                    'chunk_size': 4096,
                    'parallel_downloads': 1,
                    'use_compression': False
                })
        except:
            adaptations['network_mode'] = 'offline'
        return adaptations
    def _adapt_by_scenario(self) -> Dict[str, Any]:
        """根据应用场景适配"""
        adaptations = {}
        # 检测是否在容器中运行
        if self._is_in_container():
            adaptations.update({
                'containerized': True,
                'resource_limits': self._detect_container_limits(),
                'persistence_mode': 'volume'
            })
        # 检测是否为开发环境
        if self._is_development_env():
            adaptations.update({
                'debug_mode': True,
                'log_level': 'DEBUG',
                'profiling_enabled': True
            })
        return adaptations
    def _get_platform_env_vars(self) -> Dict[str, str]:
        """获取平台环境变量"""
        env_vars = {}
        important_vars = ['PATH', 'HOME', 'USER', 'TEMP', 'TMP']
        for var in important_vars:
            value = os.getenv(var)
            if value:
                env_vars[var] = value
        return env_vars
    def _is_in_container(self) -> bool:
        """检测是否在容器中运行"""
        # 检查常见的容器标记文件
        container_indicators = [
            '/.dockerenv',
            '/run/.containerenv',
            '/proc/self/cgroup'
        ]
        for indicator in container_indicators:
            if os.path.exists(indicator):
                with open(indicator, 'r') as f:
                    content = f.read()
                    if 'docker' in content.lower() or 'container' in content.lower():
                        return True
        # 检查cgroup信息
        try:
            with open('/proc/1/cgroup', 'r') as f:
                if 'docker' in f.read() or 'kubepods' in f.read():
                    return True
        except:
            pass
        return False
    def _detect_container_limits(self) -> Dict[str, Any]:
        """检测容器资源限制"""
        limits = {}
        try:
            # 检测CPU限制
            if os.path.exists('/sys/fs/cgroup/cpu/cpu.cfs_quota_us'):
                with open('/sys/fs/cgroup/cpu/cpu.cfs_quota_us', 'r') as f:
                    quota = int(f.read().strip())
                with open('/sys/fs/cgroup/cpu/cpu.cfs_period_us', 'r') as f:
                    period = int(f.read().strip())
                if quota > 0:
                    limits['cpu_cores'] = quota / period
            # 检测内存限制
            if os.path.exists('/sys/fs/cgroup/memory/memory.limit_in_bytes'):
                with open('/sys/fs/cgroup/memory/memory.limit_in_bytes', 'r') as f:
                    memory_limit = int(f.read().strip())
                    if memory_limit < 2**63 - 1:  # 不是无限
                        limits['memory_limit'] = memory_limit
        except:
            pass
        return limits
    def _is_development_env(self) -> bool:
        """检测是否为开发环境"""
        # 检查常见开发环境变量
        dev_indicators = [
            'PYCHARM_HOSTED',  # PyCharm
            'VSCODE_PID',      # VS Code
            'JUPYTER_SERVER_ROOT',  # Jupyter
            'DEBUG',
            'DEVELOPMENT'
        ]
        for indicator in dev_indicators:
            if os.getenv(indicator):
                return True
        # 检查当前目录是否有开发文件
        dev_files = ['.git', 'requirements.txt', 'setup.py', 'pyproject.toml']
        for file in dev_files:
            if os.path.exists(file):
                return True
        return False
    def get_optimized_config(self) -> Dict[str, Any]:
        """获取优化后的配置"""
        optimized = self.config.copy()
        # 应用适配结果
        for category, settings in self.adaptations.items():
            if isinstance(settings, dict):
                for key, value in settings.items():
                    optimized[key] = value
            else:
                optimized[category] = settings
        return optimized
    def print_diagnostics(self):
        """打印诊断信息"""
        print("=" * 60)
        print("OpenClaw 自动适配诊断报告")
        print("=" * 60)
        print("\n[系统信息]")
        for key, value in self.system_info.items():
            if key == 'memory' and isinstance(value, dict):
                print(f"  内存: {value.get('total', 0) / (1024**3):.1f}GB "
                      f"(已用: {value.get('percent', 0)}%)")
            elif key not in ['platform_release', 'platform_version']:
                print(f"  {key}: {value}")
        print("\n[适配配置]")
        optimized = self.get_optimized_config()
        for key, value in optimized.items():
            print(f"  {key}: {value}")
        print("\n[建议优化]")
        suggestions = self.get_suggestions()
        for suggestion in suggestions:
            print(f"  • {suggestion}")
        print("=" * 60)
    def get_suggestions(self) -> List[str]:
        """获取优化建议"""
        suggestions = []
        # 根据系统信息给出建议
        if self.system_info['platform'] == 'Windows':
            suggestions.append("在Windows上建议使用NTFS文件系统以获得更好的性能")
        if self.system_info.get('cpu_count', 0) < 4:
            suggestions.append("CPU核心数较少，建议减少并发任务数量")
        memory_info = self.system_info.get('memory', {})
        if isinstance(memory_info, dict) and memory_info.get('percent', 0) > 80:
            suggestions.append("内存使用率较高，建议增加物理内存或减少缓存大小")
        if self.adaptations.get('network_mode') == 'slow':
            suggestions.append("网络延迟较高，建议优化网络连接或使用本地缓存")
        return suggestions
    def save_config(self, filepath: str = 'openclaw_config.json'):
        """保存配置到文件"""
        config = {
            'system_info': self.system_info,
            'adaptations': self.adaptations,
            'optimized_config': self.get_optimized_config(),
            'timestamp': time.strftime('%Y-%m-%d %H:%M:%S')
        }
        with open(filepath, 'w', encoding='utf-8') as f:
            json.dump(config, f, indent=2, ensure_ascii=False)
        print(f"配置已保存到: {filepath}")
    def create_startup_script(self):
        """创建启动脚本"""
        platform_name = self.system_info['platform']
        script_content = self._generate_startup_script(platform_name)
        if platform_name == 'Windows':
            filename = 'start_openclaw.bat'
        else:
            filename = 'start_openclaw.sh'
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(script_content)
        if platform_name != 'Windows':
            os.chmod(filename, 0o755)
        print(f"启动脚本已创建: {filename}")
    def _generate_startup_script(self, platform: str) -> str:
        """生成平台特定的启动脚本"""
        optimized = self.get_optimized_config()
        if platform == 'Windows':
            script = f"""@echo off
REM OpenClaw 自动优化启动脚本
REM 生成时间: {time.strftime('%Y-%m-%d %H:%M:%S')}
set OPENCLAW_CONCURRENCY={optimized.get('concurrency_level', 4)}
set OPENCLAW_PERFORMANCE_MODE={optimized.get('performance_mode', 'balanced')}
set OPENCLAW_LOG_LEVEL={optimized.get('log_level', 'INFO')}
echo 启动 OpenClaw 使用优化配置...
echo 并发级别: %OPENCLAW_CONCURRENCY%
echo 性能模式: %OPENCLAW_PERFORMANCE_MODE%
python -m openclaw.main %*
"""
        else:
            script = f"""#!/bin/bash# 生成时间: {time.strftime('%Y-%m-%d %H:%M:%S')}
export OPENCLAW_CONCURRENCY={optimized.get('concurrency_level', 4)}
export OPENCLAW_PERFORMANCE_MODE={optimized.get('performance_mode', 'balanced')}
export OPENCLAW_LOG_LEVEL={optimized.get('log_level', 'INFO')}
echo "启动 OpenClaw 使用优化配置..."
echo "并发级别: $OPENCLAW_CONCURRENCY"
echo "性能模式: $OPENCLAW_PERFORMANCE_MODE"
python -m openclaw.main "$@"
"""
        return script
# 使用示例
def main():
    """主函数示例"""
    print("正在初始化 OpenClaw 自动适配器...")
    # 创建适配器实例
    adapter = OpenClawAutoAdapter()
    # 执行自动适配
    print("正在检测系统环境并自动适配...")
    adaptations = adapter.auto_adapt()
    # 打印诊断信息
    adapter.print_diagnostics()
    # 保存配置
    adapter.save_config()
    # 创建启动脚本
    adapter.create_startup_script()
    # 获取优化后的配置
    optimized_config = adapter.get_optimized_config()
    print(f"\n优化配置已应用，并发级别: {optimized_config.get('concurrency_level')}")
    return optimized_config
if __name__ == "__main__":
    # 安装可选依赖（如果需要）
    try:
        import psutil
    except ImportError:
        print("建议安装 psutil 以获得更好的系统检测: pip install psutil")
    config = main()

这个OpenClaw自动适配器包含以下功能：

主要特性：

系统检测：
- 自动检测操作系统平台
- 检测CPU核心数和架构
- 检测内存大小和使用情况
- 检测Python版本
智能适配：
- 平台适配：根据Windows/Linux/macOS调整路径、环境变量等
- 硬件适配：根据CPU核心数和内存调整并发级别和缓存大小
- 网络适配：根据网络延迟调整下载参数
- 场景适配：识别开发环境、容器环境等
配置优化：
- 自动优化性能参数
- 生成平台特定的启动脚本
- 保存和加载配置

使用方法：

# 基本使用
adapter = OpenClawAutoAdapter()
adapter.auto_adapt()
config = adapter.get_optimized_config()
# 使用优化后的配置
print(f"建议并发数: {config['concurrency_level']}")
print(f"性能模式: {config['performance_mode']}")
# 保存配置
adapter.save_config('my_config.json')
# 创建启动脚本
adapter.create_startup_script()

扩展建议：

添加更多适配规则：

def _adapt_by_application(self):
 """根据应用类型适配"""
 # 检测是否是Web爬虫、数据分析、机器学习等场景
 pass

添加性能监控：

def monitor_performance(self):
 """监控性能并动态调整"""
 # 实时监控CPU、内存使用情况
 # 动态调整参数
 pass

添加云环境适配：

def _detect_cloud_provider(self):
 """检测云服务提供商"""
 # 检测AWS、Azure、Google Cloud等
 pass

这个框架可以根据你的具体需求进行扩展,添加更多自动适配功能。

标签： OpenClaw 自动优化

本文地址： https://www.apenclaw.com.cn/post/316.html