loongclaw-devkit 0.1.0__py3-none-any.whl

loongclaw_devkit/__init__.py

@@ -0,0 +1,5 @@
+"""LoongClaw DevKit — MCP 开发者工具包"""
+
+from loongclaw_devkit.server import main
+
+__all__ = ["main"]

loongclaw_devkit/__main__.py

@@ -0,0 +1,5 @@
+"""python -m loongclaw_devkit 入口"""
+
+from loongclaw_devkit.server import main
+
+main()

loongclaw_devkit/publish.py

@@ -0,0 +1,660 @@
+#!/usr/bin/env python3
+"""LoongClaw MCP 一键发布工具
+
+交互模式（人类用）：
+    python publish.py
+
+自动模式（AI 用）：
+    python publish.py --auto --id my-mcp --version 1.0.0 --access public --json-output
+
+首次运行后配置保存到 .publish.json，后续 --auto 自动读取。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+# ── 常量 ──────────────────────────────────────────────────
+CLOUD_API_BASE = "https://yun.loongclaw.com"
+UPLOAD_ENDPOINT = "/v1/store/upload"
+ENTRYPOINT = "server.py"  # 入口文件，始终明文
+CONFIG_FILE = ".publish.json"
+IGNORE_PATTERNS = {
+    "__pycache__", ".pytest_cache", ".ruff_cache", ".git", ".venv",
+    "logs", "cache", ".coverage", "*.pyc", "*.pyo", ".publish.json",
+    "publish.py", "setup.py", "build", "dist", "*.egg-info",
+}
+
+
+# ── 工具函数 ──────────────────────────────────────────────
+
+def should_skip(name: str) -> bool:
+    if name in IGNORE_PATTERNS:
+        return True
+    return any(
+        name.endswith(p[1:]) for p in IGNORE_PATTERNS if p.startswith("*")
+    )
+
+
+def print_step(n: int, total: int, msg: str) -> None:
+    print(f"\n[{n}/{total}] {msg}")
+
+
+def detect_project_info(project_dir: Path) -> dict:
+    """从 server.py 的 FastMCP 实例中提取插件信息。"""
+    entry = project_dir / ENTRYPOINT
+    if not entry.exists():
+        return {}
+
+    text = entry.read_text(encoding="utf-8", errors="replace")
+    info: dict = {}
+
+    # FastMCP("name", ...) 或 FastMCP(name="...")
+    m = re.search(r'FastMCP\(\s*["\']([^"\']+)["\']', text)
+    if m:
+        info["id"] = m.group(1)
+
+    # instructions=("...") 或 description="..."
+    m = re.search(r'(?:instructions|description)\s*=\s*["\'\(]+(.*?)[\)"\']', text, re.DOTALL)
+    if m:
+        info["description"] = " ".join(m.group(1).split())[:200]
+
+    return info
+
+
+def find_py_files(project_dir: Path) -> list[Path]:
+    """递归查找所有 .py 文件，排除忽略项。"""
+    results = []
+    for p in sorted(project_dir.rglob("*.py")):
+        if any(should_skip(part) for part in p.relative_to(project_dir).parts):
+            continue
+        results.append(p)
+    return results
+
+
+def validate_project(project_dir: Path) -> list[str]:
+    """校验项目结构，返回错误列表。"""
+    errors = []
+    entry = project_dir / ENTRYPOINT
+    if not entry.exists():
+        errors.append(f"缺少入口文件 {ENTRYPOINT}")
+    else:
+        text = entry.read_text(encoding="utf-8", errors="replace")
+        if "FastMCP" not in text:
+            errors.append(f"{ENTRYPOINT} 中未找到 FastMCP 实例")
+        if "mcp.run(" not in text and ".run(" not in text:
+            errors.append(f"{ENTRYPOINT} 中未找到 mcp.run() 调用")
+
+    req = project_dir / "requirements.txt"
+    if not req.exists():
+        errors.append("缺少 requirements.txt")
+
+    return errors
+
+
+# ── 加密（Cython 编译）──────────────────────────────────
+
+def encrypt_files(
+    project_dir: Path,
+    py_files: list[Path],
+    skip_encrypt: list[str],
+    staging_dir: Path,
+) -> tuple[list[str], list[str]]:
+    """编译 .py → .so/.pyd，返回 (加密文件列表, 明文文件列表)。"""
+    always_plain = {ENTRYPOINT, "publish.py", "setup.py", "__init__.py"}
+    skip_set = set(skip_encrypt) | always_plain
+
+    to_encrypt = []
+    plain_files = []
+
+    for f in py_files:
+        rel = str(f.relative_to(project_dir))
+        name = f.name
+        if name in skip_set or rel in skip_set:
+            plain_files.append(rel)
+        else:
+            to_encrypt.append(f)
+
+    if not to_encrypt:
+        print("  ℹ 无需加密的文件")
+        return [], [str(f.relative_to(project_dir)) for f in py_files]
+
+    # 检查 Cython 是否安装
+    try:
+        import Cython  # noqa: F401
+    except ImportError:
+        print("  ⚠ Cython 未安装，正在安装...")
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "cython", "-q"],
+        )
+
+    encrypted_names = []
+    for f in to_encrypt:
+        rel = f.relative_to(project_dir)
+        module_name = f.stem
+        work_dir = staging_dir / rel.parent
+        work_dir.mkdir(parents=True, exist_ok=True)
+
+        # 复制为 .pyx
+        pyx_path = work_dir / f"{module_name}.pyx"
+        shutil.copy2(f, pyx_path)
+
+        # 编译
+        print(f"  🔒 编译 {rel}...")
+        setup_code = (
+            "from setuptools import setup\n"
+            "from Cython.Build import cythonize\n"
+            f"setup(ext_modules=cythonize('{module_name}.pyx', "
+            "compiler_directives={'language_level': '3'}))\n"
+        )
+        setup_file = work_dir / "_setup_tmp.py"
+        setup_file.write_text(setup_code)
+
+        result = subprocess.run(
+            [sys.executable, str(setup_file), "build_ext", "--inplace"],
+            cwd=str(work_dir),
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            print(f"  ❌ 编译失败: {rel}")
+            print(f"     {result.stderr[:500]}")
+            # 回退：保留明文
+            plain_files.append(str(rel))
+            continue
+
+        # 收集编译产物
+        so_files = list(work_dir.glob(f"{module_name}.cpython-*.so")) + \
+                   list(work_dir.glob(f"{module_name}.cp*-*.pyd"))
+        if so_files:
+            encrypted_names.append(str(rel))
+        else:
+            print(f"  ⚠ 未找到编译产物: {rel}，保留明文")
+            plain_files.append(str(rel))
+
+        # 清理中间文件
+        for tmp in [pyx_path, setup_file]:
+            tmp.unlink(missing_ok=True)
+        for c_file in work_dir.glob(f"{module_name}.c"):
+            c_file.unlink(missing_ok=True)
+        for build_dir in work_dir.glob("build"):
+            shutil.rmtree(build_dir, ignore_errors=True)
+
+    return encrypted_names, plain_files
+
+
+# ── 打包 ─────────────────────────────────────────────────
+
+def package_project(
+    project_dir: Path,
+    staging_dir: Path,
+    plain_files: list[str],
+) -> Path:
+    """收集明文文件 + 编译产物 + vendor wheels → project.zip"""
+    # 复制明文文件
+    for rel in plain_files:
+        src = project_dir / rel
+        dst = staging_dir / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        if src.exists():
+            shutil.copy2(src, dst)
+
+    # 复制非 .py 文件（配置、模板等）
+    for f in sorted(project_dir.rglob("*")):
+        if f.is_dir():
+            continue
+        rel = f.relative_to(project_dir)
+        if any(should_skip(part) for part in rel.parts):
+            continue
+        if f.suffix == ".py":
+            continue  # .py 已处理
+        dst = staging_dir / rel
+        if not dst.exists():
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(f, dst)
+
+    # requirements.txt → vendor wheels
+    req = staging_dir / "requirements.txt"
+    if req.exists():
+        vendor_dir = staging_dir / "_vendor"
+        vendor_dir.mkdir(exist_ok=True)
+        print("  📦 下载离线 wheel 包...")
+        result = subprocess.run(
+            [
+                sys.executable, "-m", "pip", "download",
+                "-r", str(req), "-d", str(vendor_dir),
+                "--only-binary=:all:",
+            ],
+            capture_output=True, text=True,
+        )
+        if result.returncode != 0:
+            # 尝试清华镜像
+            subprocess.run(
+                [
+                    sys.executable, "-m", "pip", "download",
+                    "-r", str(req), "-d", str(vendor_dir),
+                    "--only-binary=:all:",
+                    "-i", "https://pypi.tuna.tsinghua.edu.cn/simple",
+                    "--trusted-host", "pypi.tuna.tsinghua.edu.cn",
+                ],
+                capture_output=True, text=True,
+            )
+
+    # 打 zip
+    zip_path = project_dir / "project.zip"
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for root, dirs, files in os.walk(staging_dir):
+            dirs[:] = [d for d in dirs if not should_skip(d)]
+            for fname in sorted(files):
+                if should_skip(fname):
+                    continue
+                full = Path(root) / fname
+                arcname = full.relative_to(staging_dir)
+                zf.write(full, arcname)
+
+    return zip_path
+
+
+# ── Manifest 生成 ────────────────────────────────────────
+
+def generate_manifest(
+    project_dir: Path,
+    staging_dir: Path,
+    config: dict,
+) -> dict:
+    """生成 manifest.json。"""
+    # 收集 staging 中的所有文件
+    all_files = []
+    for f in sorted(staging_dir.rglob("*")):
+        if f.is_dir():
+            continue
+        rel = str(f.relative_to(staging_dir))
+        if not should_skip(f.name):
+            all_files.append(rel)
+
+    # 检测 configFields
+    config_fields = []
+    entry = project_dir / ENTRYPOINT
+    if entry.exists():
+        text = entry.read_text(encoding="utf-8", errors="replace")
+        for m in re.finditer(
+            r'os\.environ\.get\(["\'](\w+)["\'](?:,\s*["\']([^"\']*)["\'])?\)',
+            text,
+        ):
+            key = m.group(1)
+            default = m.group(2) or ""
+            if key not in ("PATH", "HOME", "USER", "LANG"):
+                config_fields.append({
+                    "key": key,
+                    "label": key.replace("_", " ").title(),
+                    "default": default,
+                    "required": default == "",
+                })
+
+    manifest = {
+        "id": config["id"],
+        "name": config.get("name", config["id"]),
+        "description": config.get("description", ""),
+        "version": config["version"],
+        "author": config.get("author", ""),
+        "icon": config.get("icon", "🔧"),
+        "runtime": "python",
+        "entrypoint": ENTRYPOINT,
+        "files": [],
+        "env": {},
+        "configFields": config_fields,
+        "sourceArchive": "project.zip",
+    }
+
+    # 写到 staging
+    manifest_path = staging_dir / "manifest.json"
+    manifest_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    return manifest
+
+
+# ── 上传 ──────────────────────────────────────────────────
+
+def upload_to_cloud(
+    project_dir: Path,
+    config: dict,
+    manifest: dict,
+) -> dict:
+    """上传到 LoongClaw Cloud API。"""
+    import urllib.request
+    import urllib.error
+
+    token = config.get("token", "")
+    if not token:
+        token = os.environ.get("LOONGCLAW_TOKEN", "")
+    if not token:
+        return {"status": "error", "step": "upload",
+                "error": "缺少认证 token。设置环境变量 LOONGCLAW_TOKEN 或在 .publish.json 中配置 token",
+                "fix": "运行 python publish.py --reconfigure 设置 token"}
+
+    # 构造上传请求
+    zip_path = project_dir / "project.zip"
+    if not zip_path.exists():
+        return {"status": "error", "step": "upload",
+                "error": "project.zip 不存在",
+                "fix": "检查打包步骤是否成功"}
+
+    manifest_path = project_dir / "_staging" / "manifest.json"
+    if not manifest_path.exists():
+        manifest_path = project_dir / "manifest.json"
+
+    # multipart/form-data 上传
+    boundary = "----LoongClawUpload"
+    body = b""
+
+    # manifest.json 部分
+    body += f"--{boundary}\r\n".encode()
+    body += b'Content-Disposition: form-data; name="manifest"; filename="manifest.json"\r\n'
+    body += b"Content-Type: application/json\r\n\r\n"
+    body += json.dumps(manifest, ensure_ascii=False).encode("utf-8")
+    body += b"\r\n"
+
+    # project.zip 部分
+    body += f"--{boundary}\r\n".encode()
+    body += b'Content-Disposition: form-data; name="archive"; filename="project.zip"\r\n'
+    body += b"Content-Type: application/zip\r\n\r\n"
+    body += zip_path.read_bytes()
+    body += b"\r\n"
+
+    # accessType 部分
+    body += f"--{boundary}\r\n".encode()
+    body += b'Content-Disposition: form-data; name="accessType"\r\n\r\n'
+    body += config.get("access", "public").encode()
+    body += b"\r\n"
+
+    body += f"--{boundary}--\r\n".encode()
+
+    url = f"{CLOUD_API_BASE}{UPLOAD_ENDPOINT}"
+    req = urllib.request.Request(
+        url,
+        data=body,
+        headers={
+            "Authorization": f"Bearer {token}",
+            "Content-Type": f"multipart/form-data; boundary={boundary}",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req) as resp:
+            result = json.loads(resp.read().decode("utf-8"))
+            return {"status": "success", **result}
+    except urllib.error.HTTPError as e:
+        err_body = e.read().decode("utf-8", errors="replace")
+        return {"status": "error", "step": "upload",
+                "error": f"HTTP {e.code}: {err_body[:300]}",
+                "fix": "检查 token 是否有效，或联系管理员"}
+    except urllib.error.URLError as e:
+        return {"status": "error", "step": "upload",
+                "error": f"网络错误: {e.reason}",
+                "fix": "检查网络连接和 CLOUD_API_BASE 地址"}
+
+
+# ── 配置管理 ─────────────────────────────────────────────
+
+def load_config(project_dir: Path) -> dict | None:
+    cfg_path = project_dir / CONFIG_FILE
+    if cfg_path.exists():
+        try:
+            return json.loads(cfg_path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            pass
+    return None
+
+
+def save_config(project_dir: Path, config: dict) -> None:
+    cfg_path = project_dir / CONFIG_FILE
+    # 不保存 token 到配置文件（安全）
+    safe = {k: v for k, v in config.items() if k != "token"}
+    cfg_path.write_text(
+        json.dumps(safe, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+
+# ── 交互式配置 ───────────────────────────────────────────
+
+def interactive_config(project_dir: Path, detected: dict) -> dict:
+    """交互式引导配置。"""
+    print("\n═══ LoongClaw MCP 发布工具 ═══\n")
+
+    config: dict = {}
+
+    # ID
+    default_id = detected.get("id", project_dir.name)
+    val = input(f"▶ 插件 ID [{default_id}]: ").strip()
+    config["id"] = val if val else default_id
+
+    # 名称
+    default_name = config["id"]
+    val = input(f"▶ 插件名称 [{default_name}]: ").strip()
+    config["name"] = val if val else default_name
+
+    # 描述
+    default_desc = detected.get("description", "")
+    if default_desc:
+        print(f"  （自动检测到描述：{default_desc[:60]}...）")
+    val = input(f"▶ 插件描述 [{default_desc[:60] or '无'}]: ").strip()
+    config["description"] = val if val else default_desc
+
+    # 版本
+    val = input("▶ 版本号 [1.0.0]: ").strip()
+    config["version"] = val if val else "1.0.0"
+
+    # 作者
+    val = input("▶ 作者名: ").strip()
+    config["author"] = val
+
+    # 图标
+    val = input("▶ 图标 emoji [🔧]: ").strip()
+    config["icon"] = val if val else "🔧"
+
+    # 不加密文件
+    py_files = find_py_files(project_dir)
+    encryptable = [
+        str(f.relative_to(project_dir)) for f in py_files
+        if f.name not in {ENTRYPOINT, "publish.py", "setup.py", "__init__.py"}
+    ]
+    if encryptable:
+        print(f"\n▶ 以下 {len(encryptable)} 个 .py 文件将被加密编译：")
+        for name in encryptable:
+            print(f"    {name}")
+        val = input("  不需要加密的文件（逗号分隔，留空=全加密）: ").strip()
+        config["skipEncrypt"] = [s.strip() for s in val.split(",") if s.strip()] if val else []
+    else:
+        config["skipEncrypt"] = []
+
+    # 访问类型
+    print("\n▶ 访问类型：")
+    print("  [1] 公开（所有用户免费使用）")
+    print("  [2] 付费（需联系商务开通）")
+    val = input("  选择 [1]: ").strip()
+    config["access"] = "private" if val == "2" else "public"
+
+    # 上传
+    val = input("\n▶ 自动上传到 LoongClaw 服务器？[Y/n]: ").strip().lower()
+    config["upload"] = val != "n"
+
+    if config["upload"]:
+        val = input("▶ LoongClaw API Token（环境变量 LOONGCLAW_TOKEN 也可）: ").strip()
+        if val:
+            config["token"] = val
+
+    return config
+
+
+# ── 主流程 ────────────────────────────────────────────────
+
+def run(config: dict, project_dir: Path, json_output: bool = False) -> dict:
+    """执行完整发布流程，返回结果字典。"""
+    total_steps = 6 if config.get("upload") else 5
+    result: dict = {"status": "success", "steps": {}}
+
+    # Step 1: 校验
+    print_step(1, total_steps, "校验项目结构...")
+    errors = validate_project(project_dir)
+    if errors:
+        result = {
+            "status": "error", "step": "validate",
+            "errors": errors,
+            "fix": "; ".join(errors),
+        }
+        if json_output:
+            print(json.dumps(result, ensure_ascii=False))
+        else:
+            for e in errors:
+                print(f"  ❌ {e}")
+        return result
+    print("  ✅ 项目结构正确")
+    result["steps"]["validate"] = "ok"
+
+    # Step 2: 准备 staging
+    staging_dir = project_dir / "_staging"
+    if staging_dir.exists():
+        shutil.rmtree(staging_dir)
+    staging_dir.mkdir()
+
+    # Step 3: 加密编译
+    print_step(2, total_steps, "Cython 加密编译...")
+    py_files = find_py_files(project_dir)
+    encrypted, plain = encrypt_files(
+        project_dir, py_files,
+        config.get("skipEncrypt", []),
+        staging_dir,
+    )
+    print(f"  ✅ 加密 {len(encrypted)} 个，明文 {len(plain)} 个")
+    result["steps"]["encrypt"] = {"encrypted": len(encrypted), "plain": len(plain)}
+
+    # Step 4: 打包
+    print_step(3, total_steps, "打包 project.zip...")
+    zip_path = package_project(project_dir, staging_dir, plain)
+    size_mb = zip_path.stat().st_size / 1024 / 1024
+    print(f"  ✅ {zip_path.name} ({size_mb:.1f} MB)")
+    result["steps"]["package"] = {"size_mb": round(size_mb, 1)}
+
+    # Step 5: 生成 manifest
+    print_step(4, total_steps, "生成 manifest.json...")
+    manifest = generate_manifest(project_dir, staging_dir, config)
+    print(f"  ✅ {manifest['id']} v{manifest['version']}")
+    result["steps"]["manifest"] = manifest
+
+    # Step 6: 上传（可选）
+    if config.get("upload"):
+        print_step(5, total_steps, "上传到 LoongClaw 服务器...")
+        upload_result = upload_to_cloud(project_dir, config, manifest)
+        if upload_result["status"] == "error":
+            result["status"] = "error"
+            result["step"] = "upload"
+            result["error"] = upload_result["error"]
+            result["fix"] = upload_result.get("fix", "")
+            if json_output:
+                print(json.dumps(result, ensure_ascii=False))
+            else:
+                print(f"  ❌ {upload_result['error']}")
+            # 清理 staging 但保留 zip
+            shutil.rmtree(staging_dir, ignore_errors=True)
+            return result
+        print("  ✅ 上传成功")
+        result["steps"]["upload"] = "ok"
+
+    # 保存配置
+    save_config(project_dir, config)
+
+    # 清理
+    shutil.rmtree(staging_dir, ignore_errors=True)
+
+    result["version"] = config["version"]
+    result["files_encrypted"] = len(encrypted)
+    result["uploaded"] = config.get("upload", False)
+
+    if json_output:
+        print(json.dumps(result, ensure_ascii=False))
+    else:
+        print(f"\n{'═' * 50}")
+        print(f"  发布完成！ {config['id']} v{config['version']}")
+        if config.get("access") == "private":
+            print("  📌 访问类型: 付费（需商务开通）")
+        else:
+            print("  📌 访问类型: 公开")
+        print(f"{'═' * 50}")
+
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="LoongClaw MCP 一键发布工具")
+    parser.add_argument("--auto", action="store_true",
+                        help="自动模式，使用 .publish.json 或命令行参数")
+    parser.add_argument("--reconfigure", action="store_true",
+                        help="重新配置（忽略 .publish.json）")
+    parser.add_argument("--json-output", action="store_true",
+                        help="JSON 格式输出（适合 AI 解析）")
+    parser.add_argument("--id", type=str, help="插件 ID")
+    parser.add_argument("--name", type=str, help="插件名称")
+    parser.add_argument("--version", type=str, help="版本号")
+    parser.add_argument("--access", choices=["public", "private"], help="访问类型")
+    parser.add_argument("--skip-encrypt", type=str, default="",
+                        help="不加密的文件（逗号分隔）")
+    parser.add_argument("--upload", action="store_true", help="上传到服务器")
+    parser.add_argument("--no-upload", action="store_true", help="不上传")
+    parser.add_argument("--token", type=str, help="LoongClaw API Token")
+    parser.add_argument("--dir", type=str, default=".",
+                        help="项目目录（默认当前目录）")
+    args = parser.parse_args()
+
+    project_dir = Path(args.dir).resolve()
+    json_output = args.json_output
+
+    if args.auto:
+        # 自动模式：优先命令行参数 > .publish.json > 自动检测
+        saved = load_config(project_dir) or {}
+        detected = detect_project_info(project_dir)
+
+        config = {
+            "id": args.id or saved.get("id") or detected.get("id") or project_dir.name,
+            "name": args.name or saved.get("name") or saved.get("id", project_dir.name),
+            "version": args.version or saved.get("version", "1.0.0"),
+            "description": saved.get("description") or detected.get("description", ""),
+            "author": saved.get("author", ""),
+            "icon": saved.get("icon", "🔧"),
+            "access": args.access or saved.get("access", "public"),
+            "skipEncrypt": (
+                [s.strip() for s in args.skip_encrypt.split(",") if s.strip()]
+                if args.skip_encrypt
+                else saved.get("skipEncrypt", [])
+            ),
+            "upload": args.upload or (not args.no_upload and saved.get("upload", False)),
+            "token": args.token or os.environ.get("LOONGCLAW_TOKEN", ""),
+        }
+    elif args.reconfigure or not load_config(project_dir):
+        # 交互模式
+        detected = detect_project_info(project_dir)
+        config = interactive_config(project_dir, detected)
+    else:
+        # 有配置文件 → 直接用
+        config = load_config(project_dir) or {}
+        if not config.get("id"):
+            detected = detect_project_info(project_dir)
+            config = interactive_config(project_dir, detected)
+
+    run(config, project_dir, json_output)
+
+
+if __name__ == "__main__":
+    main()

loongclaw_devkit/server.py

@@ -0,0 +1,288 @@
+"""LoongClaw DevKit MCP Server
+
+提供 3 个工具，让 AI 助手直接完成 MCP 插件的创建、发布、状态查看。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+
+# 包目录（pip install 后 publish.py 和 templates/ 在同一目录下）
+PACKAGE_DIR = Path(__file__).resolve().parent
+PUBLISH_SCRIPT = PACKAGE_DIR / "publish.py"
+TEMPLATES_DIR = PACKAGE_DIR / "templates"
+
+mcp = FastMCP(
+    "loongclaw-devkit",
+    instructions=(
+        "LoongClaw MCP 开发者工具包。"
+        "帮助开发者创建、加密打包、发布 MCP 插件到 LoongClaw 商店。"
+        "一条命令完成整个流程，无需手动操作。"
+    ),
+)
+
+
+@mcp.tool()
+def create_mcp_project(
+    project_dir: str,
+    plugin_id: str,
+    plugin_name: str = "",
+    description: str = "",
+) -> str:
+    """在指定目录创建一个新的 LoongClaw MCP 插件项目。
+
+    自动生成 server.py、requirements.txt、AGENTS.md、publish.py 等文件。
+    创建完成后可直接开始编写工具函数。
+
+    Args:
+        project_dir: 项目目录的绝对路径（会自动创建）
+        plugin_id: 插件 ID（字母数字和连字符，如 my-plugin）
+        plugin_name: 插件显示名称（留空则用 plugin_id）
+        description: 插件描述
+    """
+    target = Path(project_dir).resolve()
+
+    if target.exists() and any(target.iterdir()):
+        return json.dumps({
+            "status": "error",
+            "error": f"目录 {target} 已存在且非空",
+            "fix": "选择一个空目录或不存在的目录",
+        }, ensure_ascii=False)
+
+    target.mkdir(parents=True, exist_ok=True)
+
+    name = plugin_name or plugin_id
+
+    # 复制模板文件
+    server_template = TEMPLATES_DIR / "server_template.py"
+    if server_template.exists():
+        content = server_template.read_text(encoding="utf-8")
+        content = content.replace("{{PLUGIN_ID}}", plugin_id)
+        content = content.replace("{{PLUGIN_NAME}}", name)
+        content = content.replace("{{PLUGIN_DESCRIPTION}}", description)
+        (target / "server.py").write_text(content, encoding="utf-8")
+
+    agents_template = TEMPLATES_DIR / "AGENTS_template.md"
+    if agents_template.exists():
+        shutil.copy2(agents_template, target / "AGENTS.md")
+
+    req_template = TEMPLATES_DIR / "requirements_template.txt"
+    if req_template.exists():
+        shutil.copy2(req_template, target / "requirements.txt")
+
+    # 复制 publish.py
+    if PUBLISH_SCRIPT.exists():
+        shutil.copy2(PUBLISH_SCRIPT, target / "publish.py")
+
+    # 生成初始 .publish.json
+    config = {
+        "id": plugin_id,
+        "name": name,
+        "description": description,
+        "version": "1.0.0",
+        "author": "",
+        "icon": "🔧",
+        "access": "public",
+        "skipEncrypt": [],
+        "upload": False,
+    }
+    (target / ".publish.json").write_text(
+        json.dumps(config, ensure_ascii=False, indent=2),
+        encoding="utf-8",
+    )
+
+    return json.dumps({
+        "status": "success",
+        "project_dir": str(target),
+        "files_created": ["server.py", "requirements.txt", "AGENTS.md", "publish.py", ".publish.json"],
+        "next_steps": [
+            f"编辑 {target}/server.py 添加你的工具函数",
+            "核心业务逻辑放在 core.py 等独立文件中（自动加密）",
+            f"测试: cd {target} && python server.py",
+            f"发布: cd {target} && python publish.py",
+        ],
+    }, ensure_ascii=False)
+
+
+@mcp.tool()
+def publish_mcp(
+    project_dir: str,
+    version: str = "",
+    access: str = "",
+    upload: bool = False,
+    skip_encrypt: str = "",
+    token: str = "",
+) -> str:
+    """一键加密打包并发布 MCP 插件到 LoongClaw 商店。
+
+    自动完成：校验项目 → Cython 加密编译 → 打包 zip → 生成 manifest → 上传服务器。
+    配置保存在 .publish.json 中，后续更新只需传 version。
+
+    Args:
+        project_dir: 项目目录的绝对路径
+        version: 版本号（如 1.0.0），留空则读取 .publish.json 中的版本
+        access: 访问类型 public 或 private，留空则读取配置
+        upload: 是否上传到 LoongClaw 服务器
+        skip_encrypt: 不加密的文件列表（逗号分隔），留空则全部加密
+        token: LoongClaw API Token（也可用 LOONGCLAW_TOKEN 环境变量）
+    """
+    target = Path(project_dir).resolve()
+    if not target.exists():
+        return json.dumps({
+            "status": "error",
+            "error": f"目录不存在: {target}",
+            "fix": "检查路径是否正确",
+        }, ensure_ascii=False)
+
+    if not PUBLISH_SCRIPT.exists():
+        return json.dumps({
+            "status": "error",
+            "error": "publish.py 未找到",
+            "fix": f"确认 loongclaw-devkit 安装完整，预期位置: {PUBLISH_SCRIPT}",
+        }, ensure_ascii=False)
+
+    # 构造命令
+    cmd = [
+        sys.executable, str(PUBLISH_SCRIPT),
+        "--auto", "--json-output",
+        "--dir", str(target),
+    ]
+    if version:
+        cmd.extend(["--version", version])
+    if access:
+        cmd.extend(["--access", access])
+    if upload:
+        cmd.append("--upload")
+    else:
+        cmd.append("--no-upload")
+    if skip_encrypt:
+        cmd.extend(["--skip-encrypt", skip_encrypt])
+    if token:
+        cmd.extend(["--token", token])
+
+    try:
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            cwd=str(target),
+        )
+
+        # 尝试从 stdout 提取 JSON（最后一行）
+        lines = result.stdout.strip().split("\n")
+        for line in reversed(lines):
+            line = line.strip()
+            if line.startswith("{"):
+                try:
+                    parsed = json.loads(line)
+                    return json.dumps(parsed, ensure_ascii=False)
+                except json.JSONDecodeError:
+                    continue
+
+        # 没找到 JSON → 返回原始输出
+        return json.dumps({
+            "status": "error" if result.returncode != 0 else "unknown",
+            "stdout": result.stdout[-2000:] if result.stdout else "",
+            "stderr": result.stderr[-2000:] if result.stderr else "",
+            "fix": "检查 publish.py 输出",
+        }, ensure_ascii=False)
+
+    except Exception as e:
+        return json.dumps({
+            "status": "error",
+            "error": str(e),
+            "fix": "检查 Python 环境和 publish.py 是否可执行",
+        }, ensure_ascii=False)
+
+
+@mcp.tool()
+def check_mcp_status(plugin_id: str = "", project_dir: str = "") -> str:
+    """查看 MCP 插件的当前状态。
+
+    传入 plugin_id 查询已发布的状态，或传入 project_dir 查看本地项目状态。
+
+    Args:
+        plugin_id: 插件 ID（查询已发布状态时使用）
+        project_dir: 项目目录路径（查看本地项目状态时使用）
+    """
+    result: dict = {}
+
+    if project_dir:
+        target = Path(project_dir).resolve()
+        if not target.exists():
+            return json.dumps({
+                "status": "error",
+                "error": f"目录不存在: {target}",
+            }, ensure_ascii=False)
+
+        # 读取 .publish.json
+        config_path = target / ".publish.json"
+        if config_path.exists():
+            try:
+                config = json.loads(config_path.read_text(encoding="utf-8"))
+                result["config"] = config
+            except Exception:
+                result["config"] = None
+
+        # 检查项目文件
+        result["files"] = {
+            "server.py": (target / "server.py").exists(),
+            "requirements.txt": (target / "requirements.txt").exists(),
+            "publish.py": (target / "publish.py").exists(),
+            "AGENTS.md": (target / "AGENTS.md").exists(),
+            "project.zip": (target / "project.zip").exists(),
+            ".publish.json": config_path.exists(),
+        }
+
+        # 统计 .py 文件数量
+        py_files = list(target.rglob("*.py"))
+        result["py_file_count"] = len(py_files)
+        result["status"] = "ok"
+
+    if plugin_id:
+        # 尝试查询 Cloud API（需要 token）
+        token = os.environ.get("LOONGCLAW_TOKEN", "")
+        if token:
+            import urllib.request
+            import urllib.error
+            url = "https://yun.loongclaw.com/v1/store/mcp/registry.json"
+            req = urllib.request.Request(
+                url, headers={"Authorization": f"Bearer {token}"},
+            )
+            try:
+                with urllib.request.urlopen(req) as resp:
+                    registry = json.loads(resp.read().decode("utf-8"))
+                    servers = registry.get("servers", [])
+                    for s in servers:
+                        if s.get("id") == plugin_id:
+                            result["published"] = s
+                            break
+                    if "published" not in result:
+                        result["published"] = None
+                        result["message"] = f"'{plugin_id}' 未在商店中找到"
+            except Exception as e:
+                result["registry_error"] = str(e)
+        else:
+            result["registry_note"] = "设置 LOONGCLAW_TOKEN 环境变量可查询已发布状态"
+
+        result["status"] = result.get("status", "ok")
+
+    if not plugin_id and not project_dir:
+        return json.dumps({
+            "status": "error",
+            "error": "请至少提供 plugin_id 或 project_dir",
+            "fix": "传入要查询的插件 ID 或项目目录路径",
+        }, ensure_ascii=False)
+
+    return json.dumps(result, ensure_ascii=False, indent=2)
+
+
+def main():
+    mcp.run(transport="stdio")

loongclaw_devkit/templates/AGENTS_template.md

@@ -0,0 +1,112 @@
+# LoongClaw MCP 插件开发指南
+
+## 你正在开发什么
+
+这是一个 LoongClaw MCP 插件项目。MCP（Model Context Protocol）是让 AI 助手调用外部工具的标准协议。
+你写的每个 `@mcp.tool()` 函数都会变成 AI 可以调用的工具。
+
+## 项目结构
+
+```
+server.py           ← MCP 入口文件（必须保持明文，不要在这里写核心逻辑）
+core.py             ← 核心业务逻辑（发布时自动加密编译成 .so/.pyd）
+requirements.txt    ← Python 依赖
+publish.py          ← 一键发布脚本（不要修改）
+.publish.json       ← 发布配置（自动生成，不要手动编辑）
+```
+
+## 开发规范
+
+### 入口文件 server.py
+- 必须叫 `server.py`，不能改名
+- 必须使用 `from mcp.server.fastmcp import FastMCP`
+- 必须以 `mcp.run(transport="stdio")` 结尾
+- 只做 import + 注册工具 + 启动，不写业务逻辑
+- server.py 发布时**不会被加密**（Python 需要它来启动）
+
+### 工具函数
+- 每个 `@mcp.tool()` 的 **docstring 是 AI 看到的唯一说明**，必须写清楚：
+  - 这个工具做什么
+  - 每个参数的含义
+  - 返回什么
+- 参数用 Python 类型注解（`str`, `int`, `bool`, `list[str]`）
+- 返回值必须是 `str`（MCP 协议要求）
+- 复杂返回值用 `json.dumps()` 序列化
+
+### 核心逻辑
+- 放在独立的 .py 文件中（如 `core.py`、`utils.py`）
+- 在 server.py 中 `from core import xxx` 引用
+- 这些文件发布时**自动加密编译**为 .so/.pyd，用户看不到源码
+
+### 用户配置
+- 通过环境变量传递：`os.environ.get("MY_CONFIG", "默认值")`
+- publish.py 会自动扫描 `os.environ.get()` 调用，生成配置界面
+- 用户在 LoongClaw 安装时会看到配置表单
+
+## 发布
+
+### 交互模式（你来操作）
+```bash
+python publish.py
+```
+按提示回答问题即可。
+
+### 自动模式（AI 操作）
+```bash
+# 首次发布
+python publish.py --auto --id my-plugin --version 1.0.0 --access public --upload --json-output
+
+# 后续更新（读取 .publish.json 配置）
+python publish.py --auto --version 1.1.0 --json-output
+
+# 纯本地打包，不上传
+python publish.py --auto --no-upload --json-output
+```
+
+### 命令行参数
+| 参数 | 说明 | 示例 |
+|------|------|------|
+| `--auto` | 自动模式（不交互） | |
+| `--id` | 插件 ID | `--id my-plugin` |
+| `--name` | 显示名称 | `--name "我的插件"` |
+| `--version` | 版本号 | `--version 1.0.0` |
+| `--access` | public 或 private | `--access private` |
+| `--skip-encrypt` | 不加密的文件 | `--skip-encrypt "config.py,utils.py"` |
+| `--upload` | 上传到服务器 | |
+| `--no-upload` | 不上传 | |
+| `--token` | API Token | `--token lc-xxx` |
+| `--json-output` | JSON 输出 | |
+| `--reconfigure` | 重新配置 | |
+
+### JSON 输出格式
+成功：
+```json
+{"status": "success", "version": "1.0.0", "files_encrypted": 3, "uploaded": true}
+```
+
+失败：
+```json
+{"status": "error", "step": "encrypt", "error": "SyntaxError at line 42", "fix": "检查 core.py 第 42 行的语法错误"}
+```
+
+**`fix` 字段包含修复建议**——直接按建议修改代码，然后重新运行 `python publish.py --auto --json-output`。
+
+## 常见错误
+
+| 错误 | 原因 | 修复 |
+|------|------|------|
+| `Cython not found` | 未安装编译器 | `pip install cython` |
+| `编译失败` | macOS 缺 Xcode 工具 | `xcode-select --install` |
+| `缺少入口文件 server.py` | 文件名不对 | 确保入口叫 `server.py` |
+| `未找到 FastMCP 实例` | server.py 没用 FastMCP | 检查 import 和实例化 |
+| `HTTP 401` | Token 无效 | 重新获取 token 或设置 `LOONGCLAW_TOKEN` 环境变量 |
+
+## 本地测试
+
+```bash
+# 直接运行测试
+python server.py
+
+# 或用 MCP inspector
+mcp dev server.py
+```

loongclaw_devkit/templates/requirements_template.txt

@@ -0,0 +1 @@
+mcp[cli]>=1.0.0

loongclaw_devkit/templates/server_template.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""{{PLUGIN_NAME}} — LoongClaw MCP 插件
+
+入口文件，负责注册工具并启动 MCP 服务。
+核心业务逻辑请放在其他 .py 文件中（发布时会自动加密）。
+"""
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(
+    "{{PLUGIN_ID}}",
+    instructions=(
+        "{{PLUGIN_DESCRIPTION}}"
+    ),
+)
+
+
+@mcp.tool()
+def hello(name: str) -> str:
+    """向用户问好。这是一个示例工具，请替换为你的实际功能。
+
+    Args:
+        name: 用户的名字
+    """
+    return f"你好，{name}！这是 {{PLUGIN_NAME}} 插件。"
+
+
+# 在下方注册更多工具...
+# 核心逻辑建议放在单独的 .py 文件中（如 core.py），然后 import 使用：
+#
+# from core import process_data
+#
+# @mcp.tool()
+# def my_tool(input_text: str) -> str:
+#     """工具描述（AI 只看这段 docstring，写清楚功能和参数）"""
+#     return process_data(input_text)
+
+
+if __name__ == "__main__":
+    mcp.run(transport="stdio")

loongclaw_devkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,105 @@
+Metadata-Version: 2.4
+Name: loongclaw-devkit
+Version: 0.1.0
+Summary: LoongClaw MCP 开发者工具包 — 一键创建、加密、打包、发布 MCP 插件
+Project-URL: Homepage, https://git.zhigujiaoyu.com.cn/loongclaw/loongclaw-devkit
+Project-URL: Repository, https://git.zhigujiaoyu.com.cn/loongclaw/loongclaw-devkit
+Author: LoongClaw Team
+License-Expression: MIT
+Keywords: ai,devkit,loongclaw,mcp,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: mcp[cli]>=1.0.0
+Description-Content-Type: text/markdown
+
+# LoongClaw DevKit
+
+MCP 插件开发者工具包。一键创建、加密打包、发布 MCP 插件到 LoongClaw 商店。
+
+## 安装
+
+推荐使用 [uvx](https://docs.astral.sh/uv/)（零安装直接运行）：
+
+```bash
+uvx loongclaw-devkit
+```
+
+或用 pip 安装：
+
+```bash
+pip install loongclaw-devkit
+```
+
+## 在 AI 客户端中使用
+
+### LoongClaw 桌面客户端
+
+在 MCP 商店中搜索 `loongclaw-devkit` 一键安装。
+
+### Claude Desktop / Cursor / VS Code
+
+在 MCP 配置文件中添加：
+
+```json
+{
+  "mcpServers": {
+    "loongclaw-devkit": {
+      "command": "uvx",
+      "args": ["loongclaw-devkit"]
+    }
+  }
+}
+```
+
+## 提供的工具
+
+| 工具 | 功能 |
+|------|------|
+| `create_mcp_project` | 创建新的 MCP 插件项目（自动生成模板代码） |
+| `publish_mcp` | 一键加密编译 + 打包 + 发布到 LoongClaw 商店 |
+| `check_mcp_status` | 查看插件的本地和已发布状态 |
+
+## 快速开始
+
+让 AI 帮你完成整个流程：
+
+> "帮我创建一个天气查询的 MCP 插件，插件 ID 叫 weather-mcp"
+
+AI 会自动调用 `create_mcp_project` 生成项目骨架，你只需编写核心逻辑。
+
+完成后：
+
+> "把这个插件发布到 LoongClaw 商店"
+
+AI 调用 `publish_mcp` 完成加密编译、打包、上传。
+
+## 发布到商店
+
+上传到 LoongClaw 商店需要 API Token：
+
+```bash
+export LOONGCLAW_TOKEN="your-token-here"
+```
+
+Token 获取方式：在 LoongClaw 客户端「设置 → 开发者」中生成。
+
+没有 Token 也可以正常使用创建项目和本地打包功能。
+
+## 手动使用
+
+也可以不通过 AI，直接命令行运行：
+
+```bash
+# 启动 MCP server（开发调试用）
+loongclaw-devkit
+
+# 或用 Python 模块方式
+python -m loongclaw_devkit
+```
+
+## License
+
+MIT

loongclaw_devkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+loongclaw_devkit/__init__.py,sha256=r_AyCIRhzjgTi_jJ-QKIrqssGoLiJlrNrzuRl5GbhX4,112
+loongclaw_devkit/__main__.py,sha256=f5HJaAAU3rN_zKkxMf0TNpjb2HnuamEvbxr2_44G44M,90
+loongclaw_devkit/publish.py,sha256=lP5sK_pO7LWCbNNJ4m3mZJvp4f_tcoIRVkEO6tOJT4c,23649
+loongclaw_devkit/server.py,sha256=vTyWZjjzix5ffZuL6xXQsNp_BTHt_lNhgMsoW33S3Qk,9836
+loongclaw_devkit/templates/AGENTS_template.md,sha256=2C9ok1Rx1STZCAaRPgHDKu78mGaaZXLmCMGSvM5aWFY,3777
+loongclaw_devkit/templates/requirements_template.txt,sha256=HZOgIbNCU2k_Aak14zrp6cmD-W2gkbqENLiKHbLdPQI,16
+loongclaw_devkit/templates/server_template.py,sha256=nwIB5_2XjhJUJlVBdhGisiaO6Sxq8e7phC-00TP-iJU,989
+loongclaw_devkit-0.1.0.dist-info/METADATA,sha256=s1-0FuFHZ0BCjGB6PIXSWBOEy3XHZFUhT2CPMCkmMIw,2452
+loongclaw_devkit-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+loongclaw_devkit-0.1.0.dist-info/entry_points.txt,sha256=nG_rW60rl-BBSBDlDBaFZMTWB-dGIbeeBsre85MILgY,59
+loongclaw_devkit-0.1.0.dist-info/RECORD,,

loongclaw_devkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

loongclaw_devkit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+loongclaw-devkit = loongclaw_devkit:main