1. 项目概述与核心价值

最近在折腾一个挺有意思的场景：如何让一台已经部署了OpenClaw的电脑，能自动给另一台“干净”的电脑远程安装OpenClaw。听起来有点像“鸡生蛋，蛋生鸡”，但实际应用价值很大。想象一下，你作为运维或者一个技术团队的负责人，手里有一批新到的开发机或者测试服务器，你需要为它们统一部署AI助手环境。手动一台台去操作，下载、安装、配置，不仅耗时费力，还容易出错。如果能让其中一台“母机”自动完成这个任务，效率就完全不一样了。

这个项目的核心，就是利用 OpenClaw 的自动化能力和 向日葵远程控制 的远程桌面与命令行通道，结合 MCP（Model Context Protocol） 协议，构建一个跨设备的自动化部署流水线。OpenClaw是一个开源的AI智能体框架，它不仅能理解自然语言指令，还能通过调用各种Skill（技能）来执行复杂的操作序列。而向日葵，则为我们提供了稳定的远程控制连接，尤其是在需要图形界面交互或穿透复杂网络时，它比纯SSH方案更可靠、更通用。MCP协议则是连接AI智能体（OpenClaw）与外部工具（在这里，可以理解为通过向日葵去操作另一台电脑的“能力”）的桥梁。

简单来说，这个项目就是教会你的OpenClaw一个新技能： “远程装机” 。你只需要对部署好的OpenClaw说一句：“帮我把OpenClaw装到IP是xxx的那台电脑上”，它就能自动启动向日葵连接过去，执行一系列安装命令，直到在目标机器上看到一个全新的OpenClaw服务跑起来。这不仅仅是省了几步操作，更是将部署流程标准化、代码化、自动化，是DevOps理念在AI基础设施管理上的一个具体实践。

2. 核心组件与工作原理深度解析

要实现“A电脑指挥B电脑给B自己装软件”，我们需要拆解几个核心组件，并理解它们是如何协同工作的。这不仅仅是工具堆砌，更是一套精巧的系统设计。

2.1 OpenClaw：自动化大脑与执行引擎

OpenClaw在这里扮演着“总指挥”和“决策大脑”的角色。它不是一个简单的脚本执行器，而是一个具备规划、决策和工具调用能力的AI智能体框架。

• 核心能力 ：OpenClaw通过接入大语言模型（LLM），能够理解你的自然语言需求，并将其分解为一系列可执行的操作步骤（Plan）。例如，你下达“给192.168.1.100装OpenClaw”的指令，它内部可能会生成这样的计划：1. 检查本地向日葵客户端状态；2. 通过向日葵连接到目标IP；3. 在目标机器上执行系统环境检测；4. 下载OpenClaw安装包；5. 执行安装脚本；6. 验证安装结果。
• Skill机制 ：OpenClaw的功能扩展依赖于Skill。我们需要为它开发或配置一个专门的“远程部署Skill”。这个Skill的本质，是一组工具（Tools）的定义和实现。在本项目中，这个Skill需要包含“通过向日葵建立远程连接”、“在远程会话中执行命令”、“上传文件到远程主机”等关键工具。
• 上下文管理 ：在整个自动化流程中，OpenClaw需要维护操作上下文。比如，记住目标机器的IP、向日葵的会话ID、上一步命令的执行结果等，以便决定下一步该做什么。如果某一步失败了（例如网络超时），它还应能根据预设策略进行重试或转入错误处理流程。

2.2 向日葵远程控制：稳定的远程操作通道

为什么选择向日葵而不是纯粹的SSH？这基于几个现实考量：

1. 环境普适性 ：目标机器可能是一台全新的、未安装任何服务的Windows或Linux电脑。SSH服务通常不是默认开启的，而向日葵客户端安装简单，且提供图形界面和命令行双重控制能力，适应性更强。
2. 网络穿透性 ：在很多办公或实验室网络环境下，设备可能位于不同的子网或具有复杂的防火墙规则。向日葵的P2P或中转服务能较好地解决内网穿透问题，提供稳定的连接。
3. 交互完整性 ：安装过程可能涉及图形界面的确认（如许可协议）、终端交互（如输入sudo密码）等。向日葵的远程桌面功能可以完整模拟这些交互，这是纯命令行SSH难以完美处理的。
4. 状态可控 ：向日葵提供了丰富的API或命令行工具，可以用于查询连接状态、启动/结束会话等，便于OpenClaw进行流程控制。

我们的方案中，主控机（A电脑）需要安装向日葵的控制端，而被控机（B电脑）需要安装向日葵的客户端。通常，我们可以先在B电脑上手动安装一次向日葵客户端（这是唯一需要手动干预的步骤，但可以通过制作预装镜像或启动盘来批量解决），并设置好无人值守访问权限（包括设置访问密码）。

2.3 MCP协议：能力连接的标准化接口

MCP是连接OpenClaw与“向日葵操作能力”的关键。你可以把MCP想象成一套标准的插座和插头规范。

• MCP Server（服务端） ：在本项目中，我们需要实现一个 自定义的MCP Server 。这个Server并不复杂，它对外提供几个标准的“工具函数”，例如 connect_to_sunlogin(host, password) 、 execute_remote_command(command) 、 upload_file(local_path, remote_path) 、 capture_screenshot() 等。这些函数的内部实现，会调用向日葵提供的命令行工具（如 sunloginclient ）或API，来完成实际的操作。
• MCP Client（客户端） ：OpenClaw框架内置或通过插件支持MCP Client。我们只需要在OpenClaw的配置文件中，指明我们自定义的MCP Server的地址（通常是本地的一个HTTP或Stdio服务）。配置成功后，OpenClaw就能“发现”并调用这个Server提供的所有工具。
• 协议优势 ：使用MCP的好处是 解耦 和 标准化 。OpenClaw不需要知道向日葵的具体命令行怎么敲，它只需要按照MCP协议调用 execute_remote_command 。未来如果我们想把远程控制工具从向日葵换成ToDesk、RustDesk，只需要重新实现一个提供同样工具接口的MCP Server即可，OpenClaw侧的配置几乎不用改动。

工作流全景 ：

1. 用户在A电脑的OpenClaw界面输入指令。
2. OpenClaw的LLM理解指令，生成任务规划。
3. 规划中需要“远程执行命令”，于是OpenClaw的MCP Client调用本地注册的“向日葵MCP Server”提供的工具。
4. “向日葵MCP Server”收到调用请求，翻译成具体的向日葵命令行操作，控制向日葵客户端连接到B电脑。
5. 向日葵在B电脑上建立远程会话，并执行相应的命令（如运行安装脚本）。
6. 命令执行结果通过向日葵通道返回给MCP Server，再通过MCP协议返回给OpenClaw。
7. OpenClaw根据返回结果决定下一步动作，循环直至任务完成。

3. 实战部署：构建向日葵MCP Server

理论清晰后，我们进入实战环节。首先，我们需要在A电脑（主控机）上构建这个核心的“向日葵MCP Server”。

3.1 环境准备与依赖安装

假设我们的主控机是Ubuntu 22.04系统，被控机是一台干净的Ubuntu 22.04（后续会扩展到其他系统）。

在主控机（A电脑）上操作：

1. 安装向日葵控制端 ：

   # 下载向日葵Linux控制端.deb包（请从官网获取最新版本链接）
   wget -O sunlogin.deb https://down.oray.com/sunlogin/linux/sunloginclient-xx.x.x-amd64.deb
   # 安装依赖
   sudo apt update
   sudo apt install -y libwebkit2gtk-4.0-37 libappindicator3-1
   # 安装向日葵
   sudo dpkg -i sunlogin.deb
   # 如果报依赖错误，运行以下命令修复
   sudo apt --fix-broken install -y
   

   安装后，通常向日葵会自动启动。你需要进行初次图形化配置，设置一个易记的账号以便后续命令行调用。更关键的是，你需要获取向日葵的命令行工具路径，通常是 /usr/local/sunlogin/bin/sunloginclient 。

2. 安装Python及MCP SDK ：我们将使用Python来快速开发MCP Server。OpenClaw官方推荐使用 mcp Python库。

   # 确保有Python 3.10+
   python3 --version
   # 创建项目目录并进入
   mkdir ~/sunlogin-mcp-server && cd ~/sunlogin-mcp-server
   # 创建虚拟环境（推荐）
   python3 -m venv venv
   source venv/bin/activate
   # 安装mcp库和必要的依赖
   pip install mcp
   pip install psutil # 用于进程检查
   

3.2 编写向日葵MCP Server核心代码

在项目目录下创建 server.py 文件：

#!/usr/bin/env python3
import asyncio
import subprocess
import json
import os
import sys
from typing import Any, List
import psutil

from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions
import mcp.server.stdio
import mcp.types as types

# 向日葵命令行客户端路径，根据你的实际安装位置调整
SUNLOGIN_CLI = "/usr/local/sunlogin/bin/sunloginclient"

class SunloginMCPServer:
    def __init__(self):
        self.server = Server("sunlogin-mcp-server")
        # 当前活动的远程会话ID，用于关联多个操作
        self.current_session_id = None

        # 注册工具（Tools）
        self.server.list_tools().callback(self.list_tools)
        self.server.call_tool().callback(self.call_tool)

    def list_tools(self) -> List[types.Tool]:
        """定义此MCP Server提供的所有工具"""
        return [
            types.Tool(
                name="connect_to_host",
                description="通过向日葵连接到指定的远程主机。需要主机IP（或向日葵ID）和访问密码。",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "host": {
                            "type": "string",
                            "description": "远程主机的IP地址或向日葵客户端ID"
                        },
                        "password": {
                            "type": "string",
                            "description": "远程主机的向日葵访问密码"
                        }
                    },
                    "required": ["host", "password"]
                }
            ),
            types.Tool(
                name="execute_remote_command",
                description="在已连接的远程主机上执行Shell命令。",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "command": {
                            "type": "string",
                            "description": "要在远程主机上执行的命令，例如 'ls -la' 或 'sudo apt update'"
                        },
                        "wait_time": {
                            "type": "number",
                            "description": "命令执行后等待的秒数（用于观察输出或完成安装），默认5秒",
                            "default": 5
                        }
                    },
                    "required": ["command"]
                }
            ),
            types.Tool(
                name="upload_file_via_sunlogin",
                description="【模拟】通过向日葵的文件传输功能上传文件到远程主机。注意：此功能依赖于向日葵GUI，本示例为模拟流程。",
                inputSchema={
                    "type": "object",
                    "properties": {
                        "local_file_path": {"type": "string", "description": "本地文件完整路径"},
                        "remote_directory": {"type": "string", "description": "远程目标目录（如 /tmp/）"}
                    },
                    "required": ["local_file_path", "remote_directory"]
                }
            ),
            types.Tool(
                name="check_sunlogin_status",
                description="检查本地向日葵客户端的运行状态。",
                inputSchema={
                    "type": "object",
                    "properties": {}
                }
            ),
            types.Tool(
                name="disconnect_host",
                description="断开当前的向日葵远程连接。",
                inputSchema={
                    "type": "object",
                    "properties": {}
                }
            )
        ]

    async def call_tool(self, name: str, arguments: dict) -> List[types.TextContent]:
        """处理工具调用请求"""
        if name == "check_sunlogin_status":
            return await self._check_status()
        elif name == "connect_to_host":
            host = arguments.get("host")
            password = arguments.get("password")
            return await self._connect(host, password)
        elif name == "execute_remote_command":
            cmd = arguments.get("command")
            wait = arguments.get("wait_time", 5)
            return await self._execute(cmd, wait)
        elif name == "upload_file_via_sunlogin":
            local_path = arguments.get("local_file_path")
            remote_dir = arguments.get("remote_directory")
            return await self._upload_file(local_path, remote_dir)
        elif name == "disconnect_host":
            return await self._disconnect()
        else:
            raise ValueError(f"未知工具: {name}")

    async def _check_status(self) -> List[types.TextContent]:
        """检查向日葵进程是否运行"""
        is_running = False
        for proc in psutil.process_iter(['name']):
            if 'sunlogin' in proc.info['name'].lower():
                is_running = True
                break
        status = "运行中" if is_running else "未运行"
        cli_exists = os.path.exists(SUNLOGIN_CLI)
        cli_status = "存在" if cli_exists else "未找到"
        msg = f"向日葵客户端状态: {status}\n命令行工具路径({SUNLOGIN_CLI}): {cli_status}"
        if not cli_exists:
            msg += "\n**警告：命令行工具未找到，可能无法执行远程操作。请检查安装。**"
        return [types.TextContent(type="text", text=msg)]

    async def _connect(self, host: str, password: str) -> List[types.TextContent]:
        """使用向日葵命令行发起远程连接"""
        # 注意：向日葵命令行连接通常需要GUI环境支持，且可能弹窗。
        # 这里是一个模拟流程。实际生产环境可能需要更复杂的交互处理（如使用expect脚本处理弹窗）。
        cmd = [SUNLOGIN_CLI, "--host", host, "--password", password, "--type", "control"]
        try:
            # 启动连接进程。这是一个非阻塞操作，连接会由向日葵GUI处理。
            process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
            # 给一点时间让连接初始化
            await asyncio.sleep(3)
            # 这里简化处理，实际应通过查询向日葵API或窗口列表来确认连接成功
            self.current_session_id = f"session_{host}" # 模拟会话ID
            return [types.TextContent(type="text", text=f"已尝试连接到主机 {host}。请确保向日葵GUI已启动并处理了连接请求。当前会话标识: {self.current_session_id}")]
        except FileNotFoundError:
            return [types.TextContent(type="text", text=f"错误：未找到向日葵命令行工具 {SUNLOGIN_CLI}。请检查安装。")]
        except Exception as e:
            return [types.TextContent(type="text", text=f"连接过程中发生错误: {str(e)}")]

    async def _execute(self, command: str, wait_time: int) -> List[types.TextContent]:
        """模拟在远程主机上执行命令。
        真实场景下，这需要利用向日葵的“远程命令行”功能或通过已建立的远程桌面发送按键事件来实现，极其复杂。
        本示例展示逻辑流程，并强烈建议替代方案。"""
        if not self.current_session_id:
            return [types.TextContent(type="text", text="错误：未建立远程连接。请先使用 connect_to_host 工具。")]

        # **重要说明**：向日葵原生并不提供稳定的纯命令行远程执行API。
        # 实际实现有两种思路：
        # 1. 通过向日葵的“远程命令行”功能（如果目标系统支持且已开启）。
        # 2. 通过模拟键盘输入，在远程桌面的终端里输入命令（依赖UI自动化，脆弱且复杂）。
        # 因此，以下代码为**概念演示**。
        simulated_output = f"""
[模拟执行] 在会话 {self.current_session_id} 中执行命令: `{command}`
等待 {wait_time} 秒...
[模拟输出]:
user@remote-machine:~$ {command}
... (命令执行结果模拟)
"""
        # 在实际项目中，这里应该调用一个真正能执行远程命令的子进程。
        # 例如，如果目标机已预先配置好SSH，我们可以在这里调用 `sshpass -p 'password' ssh user@host command`
        # 但这偏离了“纯向日葵”的范畴。因此，本项目更可行的架构是“向日葵建立通道 + SSH执行命令”。
        return [types.TextContent(type="text", text=simulated_output)]

    async def _upload_file(self, local_path: str, remote_dir: str) -> List[types.TextContent]:
        """模拟文件上传。向日葵Linux版文件传输功能需GUI操作，难以纯命令行自动化。"""
        if not os.path.exists(local_path):
            return [types.TextContent(type="text", text=f"错误：本地文件不存在 {local_path}")]
        # 同样，这是一个复杂UI操作。实际方案可能是：先将文件上传到某个共享存储或Web服务器，然后在远程执行wget/curl命令下载。
        msg = f"""
[模拟操作] 文件上传请求。
本地文件: {local_path}
远程目录: {remote_dir}
**注意**：向日葵命令行不支持直接文件传输自动化。
**建议替代方案**：
1. 在公网或内网搭建一个简单的HTTP服务器（如 python -m http.server）。
2. 使用 `execute_remote_command` 工具，让远程机执行 `wget http://your-server/file -O {remote_dir}/file`。
"""
        return [types.TextContent(type="text", text=msg)]

    async def _disconnect(self) -> List[types.TextContent]:
        """断开连接"""
        if self.current_session_id:
            old_id = self.current_session_id
            self.current_session_id = None
            # 实际应调用向日葵命令结束会话，如 `sunloginclient --quit`
            return [types.TextContent(type="text", text=f"已断开连接 (会话 {old_id})。")]
        return [types.TextContent(type="text", text="当前无活跃连接。")]

    async def run(self):
        """启动MCP Server（使用stdio通信）"""
        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
            await self.server.run(
                read_stream,
                write_stream,
                InitializationOptions(
                    server_name="sunlogin-mcp",
                    server_version="0.1.0",
                    capabilities=self.server.get_capabilities(
                        notification_options=NotificationOptions(),
                        experimental_capabilities={},
                    ),
                ),
            )

if __name__ == "__main__":
    server = SunloginMCPServer()
    asyncio.run(server.run())

关键提示与避坑指南 ：

1. 核心限制 ：上述代码揭示了本项目最大的挑战—— 向日葵Linux命令行客户端的自动化能力非常有限 。 sunloginclient 命令主要用于启动连接，但后续的远程命令执行、文件传输等，严重依赖GUI交互，难以通过纯脚本稳定自动化。
2. 生产环境建议架构 ：一个更可靠、更自动化的方案是 “向日葵隧道 + SSH” 。
   • 步骤一（向日葵） ：使用向日葵建立到目标机的远程桌面连接。可以编写一个脚本，利用 sunloginclient 命令和 expect 或 zenity 工具来自动处理连接弹窗和密码输入。
   • 步骤二（SSH） ： 在目标机上预先安装并启用SSH服务 。这可以通过制作一个预装了SSH Server和向日葵客户端的系统镜像来实现。一旦向日葵连接建立，主控机就能通过 localhost:转发端口 或直接通过内网IP，使用SSH连接到目标机。
   • 步骤三（自动化） ：此后所有复杂的安装操作（ apt install , wget , docker run 等），全部通过 SSH通道 执行。SSH是专为远程命令行和文件传输（SCP/SFTP）设计的协议，稳定且易于自动化。
   • 优势 ：这样，我们自定义的MCP Server工具（如 execute_remote_command ）的内部实现，就从脆弱的“模拟向日葵GUI操作”变成了稳定的“调用Paramiko库执行SSH命令”。文件上传也变成了简单的SCP操作。
3. 代码中的模拟部分 ：上面的 _execute 和 _upload_file 函数是模拟逻辑。在实际开发中，你应该将其替换为基于SSH（Paramiko）的真实实现。 _connect 函数也需要增强，确保向日葵连接成功建立，并获取可用于SSH连接的IP和端口信息。

3.3 配置OpenClaw接入MCP Server

编写好MCP Server后，我们需要让OpenClaw知道并使用它。

1. 启动MCP Server ：在A电脑上，运行我们刚刚写的Server。因为它使用stdio通信，通常需要由OpenClaw进程来启动。我们需要在OpenClaw的配置中声明。

   # 测试一下Server是否能正常运行
   cd ~/sunlogin-mcp-server
   source venv/bin/activate
   python server.py
   # 如果看到没有报错，并且进程挂起等待输入，说明Server基本正常。按Ctrl+C退出测试。
   

2. 修改OpenClaw配置 ：找到OpenClaw的配置文件（例如 ~/.openclaw/config.yaml 或项目目录下的 config.yaml ）。

   # 在配置文件中找到或添加 mcp_servers 部分
   mcp_servers:
     sunlogin:
       command: "python3"
       args: ["/home/your_user/sunlogin-mcp-server/server.py"] # 替换为你的实际路径
       # 或者如果打包成了可执行文件，直接指定路径
       # command: "/home/your_user/sunlogin-mcp-server/venv/bin/python"
       # args: ["/home/your_user/sunlogin-mcp-server/server.py"]
       env:
         PYTHONPATH: "/home/your_user/sunlogin-mcp-server" # 可选，确保模块导入
   

   这个配置告诉OpenClaw：启动一个名为“sunlogin”的MCP Server，通过运行指定的Python命令来启动我们编写的server.py。

3. 重启OpenClaw ：保存配置后，重启OpenClaw服务或应用。

   # 如果你是用systemd管理的服务
   sudo systemctl restart openclaw
   # 或者如果你是在开发模式直接运行
   pkill -f openclaw
   cd /path/to/openclaw && ./start.sh &
   

4. 验证接入 ：在OpenClaw的Web界面或CLI中，尝试列出可用工具。你应该能看到 connect_to_host , execute_remote_command 等工具。如果看不到，检查OpenClaw日志，通常会有MCP Server连接失败的详细错误信息。

4. 设计自动化安装OpenClaw的Skill与工作流

现在，我们有了“远程操作”的能力（尽管目前是模拟的，但概念已通），接下来就是设计一个完整的Skill，让OpenClaw能执行“安装OpenClaw”这个复杂任务。

4.1 创建OpenClaw部署Skill

在OpenClaw中，Skill可以通过YAML文件定义。我们在OpenClaw的skills目录下创建一个新文件，例如 remote_install_openclaw.yaml 。

name: remote_openclaw_installer
description: 远程在目标Linux主机上自动化安装OpenClaw服务。
author: YourName
version: 1.0.0

# 这个Skill依赖我们刚才配置的 `sunlogin` MCP Server提供的工具
required_mcp_servers:
  - sunlogin

# 定义这个Skill提供的“高级”工具
tools:
  - name: install_openclaw_on_host
    description: 在指定的远程主机上全自动安装OpenClaw。此流程包括系统更新、依赖安装、Docker部署OpenClaw等步骤。
    inputSchema:
      type: object
      properties:
        target_host:
          type: string
          description: 目标主机的IP地址或向日葵ID
        sunlogin_password:
          type: string
          description: 目标主机的向日葵访问密码
        target_username:
          type: string
          description: 目标主机上拥有sudo权限的用户名（用于SSH，如果采用SSH方案）
        target_ssh_password:
          type: string
          description: 目标主机的SSH密码（如果采用SSH方案）
          default: ""
        openclaw_version:
          type: string
          description: 要安装的OpenClaw版本，例如 'latest' 或 'v1.2.3'
          default: "latest"
      required:
        - target_host
        - sunlogin_password

# 定义这个Skill的工作流（Workflow）。OpenClaw的LLM会根据这个蓝图来规划步骤。
workflow:
  - step: check_local_sunlogin
    tool: sunlogin.check_sunlogin_status
    args: {}
    description: 检查主控机向日葵状态

  - step: establish_remote_connection
    tool: sunlogin.connect_to_host
    args:
      host: "{{ target_host }}"
      password: "{{ sunlogin_password }}"
    description: 连接到目标主机

  - step: verify_remote_os
    tool: sunlogin.execute_remote_command
    args:
      command: "cat /etc/os-release && uname -m"
      wait_time: 3
    description: 确认目标主机操作系统和架构

  - step: update_system_packages
    tool: sunlogin.execute_remote_command
    args:
      command: "sudo apt update && sudo apt upgrade -y"
      wait_time: 60 # 系统更新可能较久
    description: 更新系统软件包（适用于Debian/Ubuntu）

  - step: install_docker_if_needed
    tool: sunlogin.execute_remote_command
    args:
      command: |
        if ! command -v docker &> /dev/null; then
          echo "Docker not found, installing..."
          sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
          curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
          echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
          sudo apt update
          sudo apt install -y docker-ce docker-ce-cli containerd.io
          sudo usermod -aG docker $USER
          newgrp docker # 这个命令在远程非交互式shell中可能不生效，需要处理
        else
          echo "Docker is already installed."
        fi
      wait_time: 120 # Docker安装耗时
    description: 安装Docker引擎

  - step: deploy_openclaw_via_docker
    tool: sunlogin.execute_remote_command
    args:
      command: |
        # 拉取指定版本的OpenClaw镜像
        docker pull openwebui/openclaw:{{ openclaw_version or 'latest' }}
        # 停止并移除旧容器（如果存在）
        docker stop openclaw 2>/dev/null || true
        docker rm openclaw 2>/dev/null || true
        # 运行新容器
        docker run -d \
          --name openclaw \
          --restart unless-stopped \
          -p 3000:8080 \
          -v ~/openclaw_data:/app/backend/data \
          openwebui/openclaw:{{ openclaw_version or 'latest' }}
      wait_time: 30
    description: 使用Docker部署OpenClaw容器

  - step: verify_installation
    tool: sunlogin.execute_remote_command
    args:
      command: "sleep 10 && curl -f http://localhost:3000/api/health || echo 'Service might still be starting...'"
      wait_time: 15
    description: 验证OpenClaw服务是否健康运行

  - step: disconnect_after_completion
    tool: sunlogin.disconnect_host
    args: {}
    description: 安装完成，断开远程连接

4.2 工作流详解与关键步骤优化

这个YAML定义了一个清晰的工作流。但其中几个关键步骤需要根据我们之前讨论的“ 向日葵+SSH ”混合架构进行优化：

• establish_remote_connection ：这一步不仅要用向日葵建立远程桌面连接， 更重要的是，要确保SSH通道可用 。在连接成功后，我们的MCP Server内部应该尝试通过某个端口（比如转发到本地的2222端口）SSH连接到目标机。这可能需要修改MCP Server的 _connect 函数，使其在连接向日葵后，自动设置端口转发并测试SSH连接。
• execute_remote_command ：在优化后的架构中，这个工具的内部实现应该从“模拟”改为真实的SSH命令执行。我们可以使用Python的 paramiko 库。这样， update_system_packages 、 install_docker_if_needed 等步骤才是真正可执行的。
• install_docker_if_needed ：脚本中的 newgrp docker 在非交互式SSH会话中无效。更可靠的做法是，在安装Docker后，直接使用 sudo 来运行docker命令，或者在脚本末尾执行 sg docker -c '...' 。更好的实践是，在安装脚本中直接修改当前会话的组信息，或者告知用户需要注销重新登录。
• 错误处理与重试 ：上述工作流是线性的，一步失败则全盘皆输。在生产级Skill中，应该为每个步骤定义错误处理策略，例如重试机制、失败回滚或发送通知。

4.3 在OpenClaw中测试Skill

1. 加载Skill ：将编写好的 remote_install_openclaw.yaml 文件放到OpenClaw的skills加载路径下，或者通过OpenClaw的管理界面导入。
2. 触发安装 ：在OpenClaw的聊天界面中，你可以输入自然语言指令，例如：

   “使用 remote_openclaw_installer 技能，在主机 192.168.1.100 上安装最新版的OpenClaw，向日葵密码是 abc123。”

3. 观察执行 ：OpenClaw的LLM会解析你的指令，匹配到 install_openclaw_on_host 工具，并填入参数。然后，它会按照 workflow 中定义的步骤，依次调用底层的MCP工具（ check_sunlogin_status , connect_to_host ...）。你可以在OpenClaw的日志或执行跟踪界面中，看到每一步的调用和结果。

5. 常见问题、排查技巧与进阶优化

在实际操作中，你一定会遇到各种问题。以下是我在搭建和测试过程中遇到的典型问题及解决方案。

5.1 连接与权限问题

• 问题一：向日葵连接失败，提示“连接被拒绝”或“密码错误”。

  • 排查 ：
    1. 确认目标机的向日葵客户端已启动并登录了账号（或设置了无人值守访问密码）。
    2. 确认主控机输入的访问密码正确。注意向日葵的“访问密码”和“系统密码”可能不同。
    3. 检查防火墙设置，是否阻止了向日葵的端口（默认可能是 80/tcp, 443/tcp, 8200/tcp 等，以实际版本为准）。
    4. 如果目标机在复杂的NAT后，确保向日葵的“代理设置”正确，或尝试使用“识别码”连接。
  • 技巧 ：先在图形界面手动用向日葵连接一次目标机，确保一切正常，再尝试自动化。可以将连接成功的配置（如识别码、密码）记录下来用于脚本。

• 问题二：SSH连接失败（在混合架构中）。

  • 排查 ：
    1. 目标机是否安装了 openssh-server ？( sudo apt install openssh-server )
    2. SSH服务是否在运行？( sudo systemctl status ssh )
    3. 防火墙是否开放了22端口（或你自定义的端口）？( sudo ufw allow 22/tcp )
    4. 主控机是否拥有目标机的SSH登录权限？建议使用SSH密钥对认证，避免在脚本中硬编码密码。
  • 技巧 ：在MCP Server的 _connect 函数中，加入SSH连接测试环节。如果SSH连接失败，则整个流程应暂停并报错，而不是继续执行注定失败的“模拟命令”。

5.2 命令执行与环境问题

• 问题三：远程执行 sudo 命令时卡住，需要输入密码。

  • 解决 ：这是自动化的大敌。有两种主流方案：
    1. 配置 sudo 免密码 ：在目标机上，为你用于SSH的用户配置 NOPASSWD 。编辑 /etc/sudoers 文件（使用 visudo 命令），添加一行： your_username ALL=(ALL) NOPASSWD: ALL 。 注意安全风险 ，仅限在受控的测试或内网环境使用。
    2. 使用 expect 脚本或 pexpect 库 ：在MCP Server的SSH执行函数中，如果检测到命令需要sudo密码，自动通过标准输入发送密码。这种方法更通用但稍复杂。
  • 我的选择 ：在自动化部署场景下，我通常选择方案1，因为目标机器是干净的、受控的。部署完成后，可以根据需要再修改sudoers配置。

• 问题四：Docker安装或OpenClaw镜像拉取速度慢。

  • 解决 ：
    1. 为Docker配置国内镜像加速器。可以在安装Docker的步骤中，增加配置镜像仓库的步骤。
    2. 对于OpenClaw镜像，如果 docker.io 拉取慢，可以尝试先拉取到本地有加速器的环境，再导出为文件，通过SCP传到目标机，最后 docker load 导入。
  • 技巧 ：将镜像加速器的配置写成脚本片段，集成到 install_docker_if_needed 步骤中。

5.3 OpenClaw与MCP Server交互问题

• 问题五：OpenClaw报错 [openclaw] could not start the cli. 或 MCP Server连接失败。

  • 排查 ：
    1. 检查OpenClaw配置文件中 mcp_servers 的 command 和 args 路径是否正确，是否有执行权限。
    2. 手动在终端运行配置中的命令，看MCP Server是否能独立启动并输出日志。
    3. 查看OpenClaw的详细日志，通常会有MCP Server进程的标准错误输出，里面包含了根本原因。
    4. 确保Python虚拟环境（如果用了）的路径在 command 中正确指定，或者将依赖包安装到系统Python环境。
  • 常见原因 ：Python路径错误、缺少依赖库（如 mcp ）、脚本语法错误、端口冲突等。

• 问题六：Skill中的工具调用失败，提示“Tool not found”。

  • 排查 ：
    1. 确认OpenClaw成功加载了包含该Skill的YAML文件。
    2. 确认Skill YAML中 required_mcp_servers 的名字与 config.yaml 中定义的 mcp_servers 的key完全一致（例如都是 sunlogin ）。
    3. 在OpenClaw界面中，使用列出所有可用工具的命令，检查 sunlogin. 为前缀的工具是否出现。

5.4 进阶优化方向

1. 状态持久化与断点续传 ：安装过程可能因网络中断而失败。可以设计一个简单的状态机，将每一步的成功状态记录到本地文件或数据库中。当任务重启时，可以从上一个失败点继续，而不是从头开始。
2. 多目标并发部署 ：修改Skill和MCP Server，使其支持传入一个主机列表。利用Python的 asyncio 库，可以并发地向多台目标机发起向日葵连接和SSH操作，大幅提升批量部署效率。
3. 更丰富的反馈与通知 ：在安装流程的关键节点（开始、成功、失败），让MCP Server调用消息推送工具（如Server酱、钉钉机器人、飞书Webhook），将结果实时通知到你的手机或工作群。
4. 异构系统支持 ：目前的脚本主要针对Debian/Ubuntu。可以增强 verify_remote_os 步骤，根据检测到的系统类型（CentOS, AlmaLinux, Windows等），分支执行不同的安装脚本（如使用yum、winget等）。
5. 安全加固 ：将密码、密钥等敏感信息从Skill的输入参数和脚本中移出，改用OpenClaw的密钥管理功能或外部密钥库（如HashiCorp Vault）来动态获取。

这个项目从概念到实现，涉及了远程控制、协议桥接、自动化编排和系统部署多个层面。最初的“纯向日葵”方案在自动化深度上会遇到瓶颈，而“向日葵+SSH”的混合架构则结合了二者的优势：向日葵解决初始连接和网络穿透问题，SSH提供稳定强大的远程执行能力。通过MCP协议，我们将这套混合能力封装成标准的工具，完美融入到OpenClaw的AI智能体生态中，最终实现了“一句话部署”的愿景。整个过程踩坑不少，但打通后的成就感十足，也为后续更复杂的跨设备自动化运维任务打下了坚实的基础。