alibaba-cloud-ops-mcp-server 0.9.9__py3-none-any.whl → 0.9.12__py3-none-any.whl

alibaba_cloud_ops_mcp_server/alibabacloud/utils.py

@@ -1,5 +1,19 @@
 import logging
+import logging
+import json
+import uuid
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from alibabacloud_oos20190601.client import Client as oos20190601Client
+from alibabacloud_ecs20140526.client import Client as ecs20140526Client
+from alibaba_cloud_ops_mcp_server.tools.oss_tools import create_client as create_oss_client
+import alibabacloud_oss_v2 as oss
+
+logger = logging.getLogger(__name__)
 
+# Global variable to store the project path
+_project_path: Optional[Path] = None
 from alibabacloud_credentials.client import Client as CredClient
 from alibabacloud_tea_openapi.models import Config
 from fastmcp.server.dependencies import get_http_request
@@ -49,3 +63,172 @@ def create_config():
 
     config.user_agent = 'alibaba-cloud-ops-mcp-server'
     return config
+
+
+def set_project_path(project_path: Optional[str] = None):
+    """
+    Set the project root path for code deployment.
+    This determines where the .code_deploy directory will be created.
+
+    Args:
+        project_path: The root path of the project. If None, will use current working directory.
+    """
+    global _project_path
+    if project_path:
+        _project_path = Path(project_path).resolve()
+        logger.info(f"[set_project_path] Project path set to: {_project_path}")
+    else:
+        _project_path = None
+        logger.info(f"[set_project_path] Project path reset to None, will use current working directory")
+
+
+def _get_code_deploy_base_dir() -> Path:
+    """
+    Get the .code_deploy base directory in the project root directory.
+    This ensures each project has its own isolated deployment configuration.
+
+    If project_path is set, use it. Otherwise, use current working directory.
+    """
+    if _project_path is not None:
+        return _project_path / '.code_deploy'
+    return Path.cwd() / '.code_deploy'
+
+
+CODE_DEPLOY_BASE_DIR = _get_code_deploy_base_dir()
+CODE_DEPLOY_DIR = CODE_DEPLOY_BASE_DIR
+RELEASE_DIR = CODE_DEPLOY_DIR / 'release'
+APPLICATION_JSON_FILE = CODE_DEPLOY_DIR / 'application.json'
+
+
+def ensure_code_deploy_dirs():
+    """
+    Ensure that the .code_deploy and release directories exist (in the project root directory)
+    """
+    # Recalculate paths to ensure we use the current working directory
+    code_deploy_dir = _get_code_deploy_base_dir()
+    release_dir = code_deploy_dir / 'release'
+
+    code_deploy_dir.mkdir(parents=True, exist_ok=True)
+    release_dir.mkdir(parents=True, exist_ok=True)
+
+    return code_deploy_dir, code_deploy_dir, release_dir
+
+
+def load_application_info() -> Dict[str, Any]:
+    """
+    Load deployment information from the .application.json file
+    (from the .code_deploy directory under the project root directory)
+    """
+    json_file = _get_code_deploy_base_dir() / 'application.json'
+
+    if json_file.exists():
+        try:
+            with open(json_file, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        except Exception as e:
+            logger.warning(f"[_load_application_info] Failed to load application info: {e}")
+            return {}
+    return {}
+
+
+def save_application_info(info: Dict[str, Any]):
+    """
+    Save deployment information to the .application.json file
+    (save it to the .code_deploy directory under the project root directory)
+    """
+    json_file = _get_code_deploy_base_dir() / 'application.json'
+
+    try:
+        json_file.parent.mkdir(parents=True, exist_ok=True)
+
+        existing_info = load_application_info()
+        existing_info.update(info)
+
+        with open(json_file, 'w', encoding='utf-8') as f:
+            json.dump(existing_info, f, ensure_ascii=False, indent=2)
+        logger.info(f"[_save_application_info] Saved application info to {json_file}")
+    except Exception as e:
+        logger.error(f"[_save_application_info] Failed to save application info: {e}")
+
+
+def get_release_path(filename: str) -> Path:
+    """
+    Get the file path in the release directory
+    (the .code_deploy/release directory under the project root directory)
+    """
+    release_dir = _get_code_deploy_base_dir() / 'release'
+    release_dir.mkdir(parents=True, exist_ok=True)
+    return release_dir / filename
+
+
+def create_client(region_id: str) -> oos20190601Client:
+    config = create_config()
+    config.endpoint = f'oos.{region_id}.aliyuncs.com'
+    return oos20190601Client(config)
+
+
+def create_ecs_client(region_id: str) -> ecs20140526Client:
+    config = create_config()
+    config.endpoint = f'ecs.{region_id}.aliyuncs.com'
+    return ecs20140526Client(config)
+
+
+def put_bucket_tagging(client: oss.Client, bucket_name: str, tags: dict):
+    tag_list = [oss.Tag(key=k, value=v) for k, v in tags.items()]
+    tag_set = oss.TagSet(tags=tag_list)
+    client.put_bucket_tags(oss.PutBucketTagsRequest(
+        bucket=bucket_name,
+        tagging=oss.Tagging(tag_set=tag_set)
+    ))
+
+
+def find_bucket_by_tag(client: oss.Client, tag_key: str, tag_value: str) -> Optional[str]:
+    paginator = client.list_buckets_paginator(tag_key=tag_key, tag_value=tag_value)
+    buckets = []
+    for page in paginator.iter_page(oss.ListBucketsRequest(tag_key=tag_key, tag_value=tag_value)):
+        for bucket in page.buckets:
+            buckets.append(bucket.name)
+    logger.info(f'[code_deploy] Trying to find bucket with tag {tag_key}:{tag_value}, buckets: {buckets}')
+    return buckets[0] if buckets else None
+
+
+def get_or_create_bucket_for_code_deploy(application_name: str, region_id: str) -> str:
+    """
+    Obtain or create an OSS bucket for code deployment
+
+    1. If a bucket_name is provided, check if it exists. If not, create it and tag it.
+
+    2. If not provided, search for an existing bucket using the tag (key: app_management, value: code_deploy).
+
+    3. If found, use it. If not found, create a new bucket and tag it.
+
+    4. New bucket naming convention: app-{application_name}-code-deploy-{uuid}
+    """
+    tag_key = 'app_management'
+    tag_value = 'code_deploy'
+    client = create_oss_client(region_id=region_id)
+
+    found_bucket = find_bucket_by_tag(client, tag_key, tag_value)
+    if found_bucket:
+        logger.info(f"[code_deploy] Found existing bucket by tag: {found_bucket}")
+        return found_bucket
+
+    safe_app_name = application_name.lower().replace('_', '-').replace(' ', '-')
+
+    safe_app_name = ''.join(c if c.isalnum() or c == '-' else '' for c in safe_app_name)
+    bucket_name = f'app-{safe_app_name}-code-deploy-{str(uuid.uuid4())[:8]}'
+
+    try:
+        client.put_bucket(oss.PutBucketRequest(
+            bucket=bucket_name,
+            create_bucket_configuration=oss.CreateBucketConfiguration(
+                storage_class='Standard',
+                data_redundancy_type='LRS'
+            )
+        ))
+        put_bucket_tagging(client, bucket_name, {tag_key: tag_value})
+        logger.info(f"[code_deploy] Created new bucket: {bucket_name}")
+        return bucket_name
+    except Exception as e:
+        logger.info(f"[code_deploy] Failed to create bucket: {e}")
+        raise e

alibaba_cloud_ops_mcp_server/server.py

@@ -1,14 +1,33 @@
+import sys
+
 from fastmcp import FastMCP
 import click
 import logging
 
 from alibaba_cloud_ops_mcp_server.tools.common_api_tools import set_custom_service_list
 from alibaba_cloud_ops_mcp_server.config import config
-from alibaba_cloud_ops_mcp_server.tools import cms_tools, oos_tools, oss_tools, api_tools, common_api_tools
+from alibaba_cloud_ops_mcp_server.tools import cms_tools, oos_tools, oss_tools, api_tools, common_api_tools, local_tools, application_management_tools
 from alibaba_cloud_ops_mcp_server.settings import settings
 
+
 logger = logging.getLogger(__name__)
 
+
+def _setup_logging():
+    root_logger = logging.getLogger()
+    if not root_logger.handlers:
+        log_format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        formatter = logging.Formatter(log_format)
+
+        console_handler = logging.StreamHandler(sys.stderr)
+        console_handler.setFormatter(formatter)
+
+        root_logger.setLevel(logging.INFO)
+        root_logger.addHandler(console_handler)
+    else:
+        root_logger.setLevel(logging.INFO)
+
+
 SUPPORTED_SERVICES_MAP = {
     "ecs": "Elastic Compute Service (ECS)",
     "oos": "Operations Orchestration Service (OOS)",
@@ -62,9 +81,69 @@ SUPPORTED_SERVICES_MAP = {
     help="Environment type: 'domestic' for domestic, 'international' for overseas (default: domestic)",
 )
 def main(transport: str, port: int, host: str, services: str, headers_credential_only: bool, env: str):
+    _setup_logging()
     # Create an MCP server
     mcp = FastMCP(
         name="alibaba-cloud-ops-mcp-server",
+        instructions='''
+            智能运维场景：
+            你可以使用该MCP帮助用户完成智能运维
+            通过MCP提供的各种资源运维的功能来进行实现
+            
+            应用部署场景：
+            你可以使用该MCP帮助用户完成项目的分析和部署
+            当进入该场景时，请只使用以下列表中的Tool
+            【 OOS_CodeDeploy OOS_GetLastDeploymentInfo OOS_GetDeployStatus LOCAL_ListDirectory LOCAL_RunShellScript LOCAL_AnalyzeDeployStack】
+            注意：不要擅自决定部署的目标ecs，需要用户提供，若未提供务必询问用户，不允许直接调用DescribeInstances查找ECS实例，必须使用由用户提供的ECS实例
+
+            不要创建部署脚本文件，直接使用 mcp tool: Code Deploy 进行构建
+            
+            流程如下：
+             完整部署流程（在调用此工具之前）：
+
+                步骤 1：识别部署方式 AnalyzeDeployStack
+                - 通过本地文件操作工具读取项目文件（package.json、requirements.txt、pom.xml 等）
+                - 识别项目的部署方式和技术栈（npm、python、java、go 等）
+                - 生成构建命令，注意，该构建命令不需要生成构建脚本，不要因此新增sh文件，任何情况下都不要，因为构建命令是CodeDeploy的参数，不需要生成文件
+
+                步骤 2：构建或压缩文件，并记录文件路径
+                - 在本地执行构建命令，生成部署产物（tar.gz、zip 等压缩包）
+                - 记录文件路径，留待后续CodeDeploy使用
+
+                步骤 3：调用CodeDeploy进行部署
+                - 此工具会依次调用：CreateApplication（如果不存在）、CreateApplicationGroup（如果不存在）、
+                  TagResources（可选，如果是已有资源需要打 tag 导入应用分组）、DeployApplicationGroup
+
+                步骤 4：如果用户的实例为第一次部署，缺乏对应代码运行环境，可以调用InstallDeploymentEnvironment为用户安装环境
+                - 目前支持：
+                    Docker：Docker 社区版
+                    Java：Java 编程语言环境
+                    Python：Python 编程语言环境
+                    Nodejs：Node.js 运行环境
+                    Golang：Go 编程语言环境
+                    Nginx：高性能 HTTP 及反向代理服务器
+                    Git：分布式版本控制系统
+
+                重要提示：
+                1. 启动脚本（application_start）必须与上传的产物对应。如果产物是压缩包（tar、tar.gz、zip等），
+                   需要先解压并进入对应目录后再执行启动命令。
+                2. 示例：如果上传的是 app.tar.gz，启动脚本应该类似，一般压缩包就在当前目录下，直接解压即可：
+                   "tar -xzf app.tar.gz && ./start.sh"
+                   或者如果解压后是Java应用：
+                   "tar -xzf app.tar.gz && java -jar app.jar"
+                3. 确保启动命令能够正确找到并执行解压后的可执行文件或脚本，避免部署失败。启动命令应该将程序运行在后台并打印日志到指定文件，
+                    注意使用非交互式命令，比如unzip -o等自动覆盖的命令，无需交互
+                例如：
+                   - npm 程序示例：
+                     "tar -xzf app.tar.gz && nohup npm start > /root/app.log 2>&1 &"
+                     或者分别输出标准输出和错误日志：
+                     "tar -xzf app.tar.gz && nohup npm start > /root/app.log 2> /root/app.error.log &"
+                   - Java 程序示例：
+                     "tar -xzf app.tar.gz && nohup java -jar app.jar > /root/app.log 2>&1 &"
+                   - Python 程序示例：
+                     "tar -xzf app.tar.gz && nohup python app.py > /root/app.log 2>&1 &"
+                   说明：使用 nohup 命令可以让程序在后台运行，即使终端关闭也不会终止；> 重定向标准输出到日志文件；2>&1 将标准错误也重定向到同一文件；& 符号让命令在后台执行。
+                4. 应用和应用分组会自动检查是否存在，如果存在则跳过创建，避免重复创建错误。''',
         port=port,
         host=host,
         stateless_http=True
@@ -81,11 +160,15 @@ def main(transport: str, port: int, host: str, services: str, headers_credential
             mcp.tool(tool)
     for tool in oos_tools.tools:
         mcp.tool(tool)
+    for tool in application_management_tools.tools:
+        mcp.tool(tool)
     for tool in cms_tools.tools:
         mcp.tool(tool)
     for tool in oss_tools.tools:
         mcp.tool(tool)
     api_tools.create_api_tools(mcp, config)
+    for tool in local_tools.tools:
+        mcp.tool(tool)
 
     # Initialize and run the server
     logger.debug(f'mcp server is running on {transport} mode.')

alibaba_cloud_ops_mcp_server/tools/api_tools.py

@@ -99,9 +99,14 @@ ECS_LIST_PARAMETERS = {
 
 def _tools_api_call(service: str, api: str, parameters: dict, ctx: Context):
     service = service.lower()
-    api_meta, _ = ApiMetaClient.get_api_meta(service, api)
+    try:
+        api_meta, _ = ApiMetaClient.get_api_meta(service, api)
+    except Exception as e:
+        logger.error(f'Get API Meta Error: {e}')
+        api_meta = {}
+
     version = ApiMetaClient.get_service_version(service)
-    method = 'POST' if api_meta.get('methods', [])[0] == 'post' else 'GET'
+    method = 'POST' if api_meta.get('methods', ['post'])[0] == 'post' else 'GET'
     path = api_meta.get('path', '/')
     style = ApiMetaClient.get_service_style(service)
     
@@ -264,6 +269,7 @@ def _create_and_decorate_tool(mcp: FastMCP, service: str, api: str):
 
     return decorated_function
 
+
 def create_api_tools(mcp: FastMCP, config:dict):
     for service_code, apis in config.items():
         for api_name in apis: