ai-project-manage-cli 6.0.65 → 6.0.67

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-project-manage-cli",
-  "version": "6.0.65",
+  "version": "6.0.67",
   "description": "命令行工具：后续用于调用平台后端 API 完成运维与自动化操作",
   "type": "module",
   "private": false,
@@ -25,6 +25,7 @@
     "esbuild": "~0.28.0",
     "vitest": "~4.1.5",
     "@types/dockerode": "~4.0.1",
+    "@types/ssh2": "~1.15.0",
     "@types/ssh2-sftp-client": "~9.0.6"
   },
   "engines": {
@@ -41,6 +42,7 @@
     "yaml": "~2.8.4",
     "minio": "~8.0.7",
     "dockerode": "~5.0.0",
+    "ssh2": "~1.16.0",
     "ssh2-sftp-client": "~12.0.1",
     "jszip": "~3.10.1"
   }

package/template/apm.config.json

@@ -1,7 +1,3 @@
 {
-  "name": "",
-  "deploy": {
-    "test": "npm run deploy:test && python .apm/deploy/deploy.py",
-    "online": "npm run deploy:online && python .apm/deploy/deploy.py"
-  }
-}
+  "name": ""
+}

package/template/deploy/README.md

@@ -1,10 +1,8 @@
-## 前端部署
+## 部署
 
-部署测试环境： `npm run deploy:test`
-部署线上环境： `npm run deploy:online`
+部署测试环境：`apm deploy test`
+部署线上环境：`apm deploy online`
 
-## 后端部署（不区分正式环境和测试环境）
-`python .apm/deploy/deploy.py`
 
 ## 前端产物下载地址
 
@@ -12,4 +10,5 @@ http://<服务器地址>/dist.zip
 http://<服务器地址>/{name}.jar.zip
 
 ## 测试地址
-http://<服务器地址>
+
+http://<服务器地址>

package/template/skills/apm-deploy/SKILL.md

@@ -1,10 +1,8 @@
 ## 工作流程
 
-### 步骤1: 阅读部署文档  
-使用**Read**工具阅读 `.apm/deploy/README.md`
+在项目根目录执行 `apm deploy <环境名称>`
 
-### 步骤2: 按照文档执行部署命令，禁止猜测参数
+## 示例
 
-如果遇到以下情况则无需部署，直接退出部署流程
-1. 没有找到部署文档，或者部署文档没有可执行的部署命令（或者说部署不可执行）
-2. 用户没有明确部署环境
+1. 部署测试环境：`apm deploy test`
+2. 部署正式环境: `apm deploy online`

package/template/deploy/deploy.py

@@ -1,564 +0,0 @@
-#!/usr/bin/env python3
-"""自动部署脚本"""
-
-from __future__ import annotations
-
-import json
-import posixpath
-import re
-import shlex
-import shutil
-import subprocess
-import sys
-import time
-import zipfile
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-import paramiko
-
-SCRIPT_DIR = Path(__file__).resolve().parent
-PROJECT_ROOT = SCRIPT_DIR.parent.parent
-APM_CONFIG_PATH = PROJECT_ROOT / ".apm" / "apm.config.json"
-DEPLOY_CACHE_DIR = SCRIPT_DIR / ".deploy_cache"
-MANIFEST_FILE = DEPLOY_CACHE_DIR / "manifest.json"
-SPRINGBOOT_SCRIPT = "springboot.sh"
-MAVEN_MODULE = "jeecg-module-system/jeecg-system-start"
-MAVEN_PROFILE = "dev"
-
-if sys.platform == "win32" and hasattr(sys.stdout, "reconfigure"):
-    sys.stdout.reconfigure(encoding="utf-8")
-    sys.stderr.reconfigure(encoding="utf-8")
-
-
-def log(message: str) -> None:
-    print(f"[{datetime.now().strftime('%H:%M:%S')}] {message}")
-
-
-def fail(message: str, code: int = 1) -> None:
-    log(f"ERROR: {message}")
-    sys.exit(code)
-
-
-def expand_path(path_str: str) -> Path:
-    return Path(path_str).expanduser().resolve()
-
-
-def load_apm_config(apm_path: Path) -> dict[str, Any]:
-    with apm_path.open("r", encoding="utf-8") as handle:
-        data = json.load(handle)
-
-    name = str(data["name"]).strip()
-    deploy = data["wisdomDeploy"]
-    health = data["healthCheck"]
-
-    jar_path = str(deploy["jarPath"]).strip()
-    remote_app_dir = posixpath.dirname(jar_path)
-
-    return {
-        "project_name": name,
-        "host": deploy["host"],
-        "port": deploy["port"],
-        "username": deploy["username"],
-        "password": deploy["password"],
-        "remote_vue_dist_dir": str(deploy["remotePath"]).strip(),
-        "remote_app_dir": remote_app_dir,
-        "remote_lib_dir": posixpath.join(remote_app_dir, "lib"),
-        "startup_jar": posixpath.basename(jar_path),
-        "package_name": f"{name}.jar.zip",
-        "maven_local_repo": str(deploy["mavenLocalRepo"]).strip(),
-        "health_check_port": health["port"],
-        "health_check_context": health["context"],
-        "health_check_timeout": health["timeout"],
-    }
-
-
-def load_config() -> dict[str, Any]:
-    return load_apm_config(APM_CONFIG_PATH)
-
-
-def get_target_dir() -> Path:
-    return PROJECT_ROOT / MAVEN_MODULE / "target"
-
-
-def get_maven_local_repo(config: dict[str, Any]) -> Path:
-    return expand_path(str(config["maven_local_repo"]).strip())
-
-
-@dataclass
-class UpdateEntry:
-    path: Path
-    arcname: str
-    reason: str
-
-
-def relative_key(path: Path) -> str:
-    return path.resolve().relative_to(PROJECT_ROOT.resolve()).as_posix()
-
-
-def file_signature(path: Path) -> dict[str, float | int]:
-    stat = path.stat()
-    return {"size": int(stat.st_size), "mtime": float(stat.st_mtime)}
-
-
-def load_manifest() -> dict[str, dict[str, float | int]]:
-    if not MANIFEST_FILE.exists():
-        return {}
-    with MANIFEST_FILE.open("r", encoding="utf-8") as handle:
-        return json.load(handle)
-
-
-def save_manifest(manifest: dict[str, dict[str, float | int]]) -> None:
-    DEPLOY_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    with MANIFEST_FILE.open("w", encoding="utf-8") as handle:
-        json.dump(manifest, handle, ensure_ascii=False, indent=2)
-
-
-def is_project_lib_jar(jar_name: str) -> bool:
-    return jar_name.startswith("jeecg-")
-
-
-def list_lib_files_to_upload(
-    local_lib_dir: Path,
-    remote_stats: dict[str, paramiko.SFTPAttributes],
-    *,
-    manifest: dict[str, dict[str, float | int]] | None = None,
-) -> list[UpdateEntry]:
-    entries: list[UpdateEntry] = []
-    for jar_file in sorted(local_lib_dir.glob("*.jar")):
-        remote_attr = remote_stats.get(jar_file.name)
-        should_upload, reason = should_upload_lib_file(
-            jar_file,
-            remote_attr,
-            manifest,
-        )
-        if should_upload:
-            entries.append(
-                UpdateEntry(
-                    path=jar_file,
-                    arcname=jar_file.name,
-                    reason=reason,
-                )
-            )
-    return entries
-
-
-def create_update_package(entries: list[UpdateEntry], package_name: str) -> Path:
-    DEPLOY_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    zip_path = DEPLOY_CACHE_DIR / package_name
-
-    log(f"创建更新包: {zip_path.name}（{len(entries)} 个文件）")
-    with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as archive:
-        for entry in entries:
-            archive.write(entry.path, arcname=entry.arcname)
-            log(f"  打包: {entry.arcname} ({entry.reason})")
-
-    return zip_path
-
-
-def upload_update_package(
-    sftp: paramiko.SFTPClient,
-    zip_path: Path,
-    config: dict[str, Any],
-) -> str:
-    remote_dir = config["remote_vue_dist_dir"]
-    remote_path = f"{remote_dir}/{zip_path.name}"
-
-    log(f"上传更新包 -> {remote_path}")
-
-    try:
-        sftp.put(str(zip_path), remote_path)
-        log("更新包上传成功")
-    except OSError as exc:
-        fail(f"更新包上传失败: {exc}")
-
-    return remote_path
-
-
-def update_manifest_entries(
-    manifest: dict[str, dict[str, float | int]],
-    entries: list[UpdateEntry],
-) -> dict[str, dict[str, float | int]]:
-    for entry in entries:
-        manifest[relative_key(entry.path)] = file_signature(entry.path)
-    return manifest
-
-
-def get_remote_file_stats(
-    sftp: paramiko.SFTPClient,
-    remote_dir: str,
-) -> dict[str, paramiko.SFTPAttributes]:
-    stats: dict[str, paramiko.SFTPAttributes] = {}
-    try:
-        for attr in sftp.listdir_attr(remote_dir):
-            if attr.filename.endswith(".jar"):
-                stats[attr.filename] = attr
-    except FileNotFoundError:
-        pass
-    return stats
-
-
-def should_upload_lib_file(
-    local_path: Path,
-    remote_attr: paramiko.SFTPAttributes | None,
-    manifest: dict[str, dict[str, float | int]] | None = None,
-) -> tuple[bool, str]:
-    if remote_attr is None:
-        return False, "远程不存在，跳过"
-
-    local_size = int(local_path.stat().st_size)
-    remote_size = int(remote_attr.st_size)
-    if local_size != remote_size:
-        return True, f"大小变化 {remote_size} -> {local_size}"
-
-    if is_project_lib_jar(local_path.name) and manifest is not None:
-        key = relative_key(local_path)
-        current = file_signature(local_path)
-        previous = manifest.get(key)
-        if previous is None:
-            return True, "项目模块未记录"
-        if int(previous["size"]) != current["size"]:
-            return True, "项目模块大小变化"
-        if float(previous["mtime"]) < current["mtime"]:
-            return True, "项目模块重新构建"
-
-    return False, "大小一致，跳过"
-
-
-def get_mvn_executable() -> str:
-    candidates = ("mvn.cmd", "mvn.bat", "mvn") if sys.platform == "win32" else ("mvn",)
-    for name in candidates:
-        found = shutil.which(name)
-        if found:
-            return found
-    fail("未找到 mvn 命令，请确认 Maven 已安装并加入 PATH")
-
-
-def run_maven_build(config: dict[str, Any]) -> None:
-    profile = MAVEN_PROFILE
-    maven_repo = get_maven_local_repo(config)
-    cmd = [
-        get_mvn_executable(),
-        "clean",
-        "package",
-        f"-P{profile}",
-        f"-Dmaven.repo.local={maven_repo}",
-        "-DskipTests",
-    ]
-
-    log(f"开始 Maven 构建: {' '.join(cmd)}")
-    log(f"Maven 本地仓库: {maven_repo}")
-    result = subprocess.run(
-        cmd,
-        cwd=PROJECT_ROOT,
-    )
-    if result.returncode != 0:
-        fail(f"Maven 构建失败，退出码: {result.returncode}")
-
-
-def locate_lib_dir() -> Path:
-    target_dir = get_target_dir()
-    if not target_dir.exists():
-        fail(f"构建产物目录不存在: {target_dir}")
-
-    lib_dir = target_dir / "lib"
-    if not lib_dir.is_dir():
-        fail(f"lib 目录不存在: {lib_dir}")
-
-    lib_jars = list(lib_dir.glob("*.jar"))
-    if not lib_jars:
-        fail(f"lib 目录下没有依赖 JAR: {lib_dir}")
-
-    log(f"定位 lib 产物: {len(lib_jars)} 个")
-    return lib_dir
-
-
-def connect_ssh(config: dict[str, Any]) -> paramiko.SSHClient:
-    client = paramiko.SSHClient()
-    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
-
-    log(f"连接服务器 {config['username']}@{config['host']}:{config['port']}")
-    connect_kwargs: dict[str, Any] = {
-        "hostname": config["host"],
-        "port": int(config["port"]),
-        "username": config["username"],
-        "password": config["password"],
-        "timeout": 30,
-        "allow_agent": False,
-        "look_for_keys": False,
-    }
-
-    try:
-        client.connect(**connect_kwargs)
-    except Exception as exc:
-        fail(f"SSH 连接失败: {exc}")
-
-    return client
-
-
-def read_channel_stream(channel: paramiko.Channel) -> str:
-    """流式读取 SSH 通道输出，避免长时间命令无回显。"""
-    chunks: list[str] = []
-    while not channel.closed:
-        if channel.recv_ready():
-            data = channel.recv(4096)
-            if not data:
-                break
-            text = data.decode("utf-8", errors="replace")
-            chunks.append(text)
-            print(text, end="", flush=True)
-        elif channel.exit_status_ready():
-            while channel.recv_ready():
-                data = channel.recv(4096)
-                if data:
-                    text = data.decode("utf-8", errors="replace")
-                    chunks.append(text)
-                    print(text, end="", flush=True)
-            break
-        else:
-            time.sleep(0.2)
-
-    combined = "".join(chunks)
-    if combined and not combined.endswith("\n"):
-        print()
-    return combined.strip()
-
-
-def run_remote_command(
-    client: paramiko.SSHClient,
-    command: str,
-    *,
-    check: bool = True,
-    get_pty: bool = False,
-    stream: bool = False,
-    timeout_secs: float | None = None,
-) -> tuple[int, str, str]:
-    log(f"远程执行: {command}")
-    _, stdout, stderr = client.exec_command(command, get_pty=get_pty)
-    channel = stdout.channel
-    if timeout_secs is not None:
-        channel.settimeout(timeout_secs)
-
-    if stream:
-        out = read_channel_stream(channel)
-        err = ""
-    else:
-        out = stdout.read().decode("utf-8", errors="replace").strip()
-        err = "" if get_pty else stderr.read().decode("utf-8", errors="replace").strip()
-
-    exit_code = channel.recv_exit_status()
-
-    if not stream:
-        if out:
-            print(out)
-        if err:
-            print(err, file=sys.stderr)
-
-    if check and exit_code != 0:
-        fail(f"远程命令失败 (exit {exit_code}): {command}")
-
-    return exit_code, out, err
-
-
-def extract_update_package_on_remote(
-    client: paramiko.SSHClient,
-    config: dict[str, Any],
-    remote_zip_path: str,
-) -> int:
-    """解压更新包到 lib 目录，仅覆盖远程已存在的 JAR。"""
-    remote_lib_dir = config["remote_lib_dir"]
-    quoted_zip = shlex.quote(remote_zip_path)
-    quoted_lib = shlex.quote(remote_lib_dir)
-
-    script = f"""
-set -e
-TMP=$(mktemp -d)
-trap 'rm -rf "$TMP"' EXIT
-unzip -oq {quoted_zip} -d "$TMP"
-updated=0
-while IFS= read -r -d '' src; do
-  name=$(basename "$src")
-  dest={quoted_lib}/"$name"
-  if [ -f "$dest" ]; then
-    cp -f "$src" "$dest"
-    echo "覆盖: $name"
-    updated=$((updated + 1))
-  else
-    echo "跳过(远程不存在): $name"
-  fi
-done < <(find "$TMP" -name '*.jar' -type f -print0)
-echo "UPDATED_COUNT=$updated"
-"""
-
-    _, out, _ = run_remote_command(client, script)
-    match = re.search(r"UPDATED_COUNT=(\d+)", out)
-    if not match:
-        fail(f"远程解压失败，未获取更新数量\n输出: {out or '(空)'}")
-
-    updated = int(match.group(1))
-    log(f"lib 解压完成: 覆盖 {updated} 个")
-    return updated
-
-
-def springboot_output_indicates_success(action: str, combined: str) -> bool:
-    """springboot.sh 经 SSH 执行时 exit code 不可靠，需结合输出判断。"""
-    lower = combined.lower()
-    if action == "health":
-        return "健康检查通过" in combined
-    if action in {"start", "restart"}:
-        return "is starting" in combined or "is running" in lower
-    if action == "stop":
-        return (
-            "is stopping" in combined
-            or "not running" in lower
-            or "please check it" in lower
-        )
-    if action == "status":
-        return "running" in lower or "not running" in lower
-    return True
-
-
-def run_springboot_action(
-    client: paramiko.SSHClient,
-    config: dict[str, Any],
-    action: str,
-    *args: str,
-) -> str:
-    if action in {"start", "restart"}:
-        if not args:
-            fail(f"远程 {action} 缺少 jar 参数")
-        jar = args[0].strip().splitlines()[0].strip()
-        if not jar:
-            fail(f"无效的 jar 名称: {args[0]!r}")
-
-    command = " && ".join(
-        [
-            f"cd {shlex.quote(config['remote_app_dir'])}",
-            " ".join(
-                [f"./{SPRINGBOOT_SCRIPT}", *map(shlex.quote, (action, *args))]
-            ),
-        ]
-    )
-    exit_code, out, err = run_remote_command(
-        client,
-        command,
-        check=False,
-    )
-    combined = f"{out}\n{err}".strip()
-    output_ok = springboot_output_indicates_success(action, combined)
-    if action == "health":
-        if exit_code != 0 or not output_ok:
-            fail(
-                f"健康检查失败\n"
-                f"命令: {command}\n输出: {combined or '(空)'}"
-            )
-        return combined
-    if exit_code != 0 and not output_ok:
-        fail(f"远程 {action} 失败: {' '.join(args)}\n{combined}")
-    if action in {"start", "restart"} and not output_ok:
-        fail(
-            f"远程 {action} 未成功: {' '.join(args)}\n"
-            f"命令: {command}\n输出: {combined or '(空)'}"
-        )
-    return combined
-
-
-def get_running_jar(
-    client: paramiko.SSHClient,
-    app_dir: str,
-    config: dict[str, Any],
-) -> str | None:
-    combined = run_springboot_action(
-        client, config, "status", config["startup_jar"]
-    )
-    text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", combined).strip().lower()
-    if "not running" in text:
-        return None
-    if "running" in text:
-        return config["startup_jar"]
-    return None
-
-
-def health_check_service(
-    client: paramiko.SSHClient,
-    config: dict[str, Any],
-) -> None:
-    port = str(int(config["health_check_port"]))
-    context = str(config["health_check_context"]).strip()
-    timeout = str(int(config["health_check_timeout"]))
-    log(f"健康检查: springboot.sh health {port} {context} {timeout}")
-    run_springboot_action(client, config, "health", port, context, timeout)
-
-
-def main() -> None:
-    config = load_config()
-
-    log(f"=== 自动部署: {config['project_name']} ===")
-    log(f"配置文件: {APM_CONFIG_PATH}")
-    log(f"项目根目录: {PROJECT_ROOT}")
-
-    run_maven_build(config)
-
-    lib_dir = locate_lib_dir()
-    manifest = load_manifest()
-
-    client = connect_ssh(config)
-    need_restart = False
-    lib_upload_entries: list[UpdateEntry] = []
-    try:
-        sftp = client.open_sftp()
-        try:
-            app_dir = config["remote_app_dir"]
-            remote_lib_stats = get_remote_file_stats(sftp, config["remote_lib_dir"])
-
-            log("收集 JAR 更新...")
-            lib_upload_entries = list_lib_files_to_upload(
-                lib_dir,
-                remote_lib_stats,
-                manifest=manifest,
-            )
-
-            updated = 0
-            if lib_upload_entries:
-                zip_path = create_update_package(
-                    lib_upload_entries,
-                    config["package_name"],
-                )
-                remote_zip_path = upload_update_package(sftp, zip_path, config)
-                log("远程解压 lib 目录（仅覆盖已有 JAR）...")
-                updated = extract_update_package_on_remote(
-                    client,
-                    config,
-                    remote_zip_path,
-                )
-            else:
-                log("无 JAR 需要更新，跳过更新包上传")
-
-            running_jar = get_running_jar(client, app_dir, config)
-            need_restart = updated > 0
-            if not need_restart and not running_jar:
-                log("服务未运行，需要启动")
-                need_restart = True
-            elif not need_restart:
-                log("没有文件需要更新，跳过重启")
-
-            if need_restart:
-                log("重启服务...")
-                run_springboot_action(client, config, "restart", config["startup_jar"])
-
-            health_check_service(client, config)
-
-            if lib_upload_entries:
-                save_manifest(update_manifest_entries(manifest, lib_upload_entries))
-        finally:
-            sftp.close()
-    finally:
-        client.close()
-
-    log("部署完成")
-
-
-if __name__ == "__main__":
-    main()