sophhub 0.4.2 → 0.4.4

package/skills/agent-install/src/scripts/list_agents.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import difflib
+import json
+import re
+import subprocess
+import sys
+from typing import Any
+
+
+ID_PATTERN = re.compile(r"^[a-z0-9][a-z0-9_-]*$", re.IGNORECASE)
+
+
+def normalize_text(value: str) -> str:
+    return re.sub(r"[\s_\-]+", "", value.strip().lower())
+
+
+def run_sophhub_agent_list() -> tuple[int, str, str]:
+    result = subprocess.run(
+        ["npx", "-y", "sophhub@latest", "agent", "list", "--json"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return result.returncode, result.stdout, result.stderr
+
+
+def extract_agents_from_json(data: Any) -> list[dict[str, str]]:
+    if isinstance(data, dict):
+        for key in ("agents", "items", "data", "list"):
+            value = data.get(key)
+            if isinstance(value, list):
+                return extract_agents_from_json(value)
+        if any(key in data for key in ("id", "agent_id", "name", "description", "desc")):
+            return [normalize_agent_record(data)]
+        return []
+
+    if isinstance(data, list):
+        result: list[dict[str, str]] = []
+        for item in data:
+            if isinstance(item, dict):
+                result.append(normalize_agent_record(item))
+            elif isinstance(item, str):
+                parsed = parse_text_line(item)
+                if parsed:
+                    result.append(parsed)
+        return dedupe_agents(result)
+
+    return []
+
+
+def normalize_agent_record(item: dict[str, Any]) -> dict[str, str]:
+    agent_id = first_non_empty_str(
+        item.get("id"),
+        item.get("agent_id"),
+        item.get("agentId"),
+        item.get("slug"),
+        item.get("key"),
+        item.get("code"),
+    )
+    name = first_non_empty_str(item.get("name"), item.get("title"), item.get("displayName"))
+    description = first_non_empty_str(
+        item.get("description"),
+        item.get("desc"),
+        item.get("summary"),
+        item.get("intro"),
+    )
+
+    if not agent_id and name and ID_PATTERN.match(name):
+        agent_id = name
+
+    return {
+        "agent_id": agent_id or "",
+        "name": name or "",
+        "description": description or "",
+    }
+
+
+def first_non_empty_str(*values: Any) -> str | None:
+    for value in values:
+        if isinstance(value, str) and value.strip():
+            return value.strip()
+    return None
+
+
+def parse_text_line(line: str) -> dict[str, str] | None:
+    raw = line.strip()
+    if not raw:
+        return None
+    if raw.startswith(("npm ", "Error:", "error:", "WARN", "warning:")):
+        return None
+    if set(raw) <= {"-", "=", "|", " "}:
+        return None
+
+    cleaned = re.sub(r"^\s*(?:[-*]|\d+\.)\s*", "", raw)
+    if "|" in cleaned:
+        parts = [part.strip() for part in cleaned.split("|") if part.strip()]
+        if len(parts) >= 2 and ID_PATTERN.match(parts[0]):
+            return {
+                "agent_id": parts[0],
+                "name": parts[1] if len(parts) >= 2 else "",
+                "description": " | ".join(parts[2:]) if len(parts) >= 3 else "",
+            }
+
+    for splitter in (r"\s+-\s+", r"\s{2,}", r"\s+:\s+"):
+        parts = re.split(splitter, cleaned, maxsplit=2)
+        if len(parts) >= 2 and ID_PATTERN.match(parts[0].strip()):
+            return {
+                "agent_id": parts[0].strip(),
+                "name": parts[1].strip() if len(parts) >= 2 else "",
+                "description": parts[2].strip() if len(parts) >= 3 else "",
+            }
+
+    first_word, _, rest = cleaned.partition(" ")
+    if ID_PATTERN.match(first_word):
+        return {
+            "agent_id": first_word.strip(),
+            "name": "",
+            "description": rest.strip(),
+        }
+
+    return None
+
+
+def parse_agents_output(stdout: str) -> list[dict[str, str]]:
+    stripped = stdout.strip()
+    if not stripped:
+        return []
+
+    try:
+        data = json.loads(stripped)
+    except json.JSONDecodeError:
+        data = None
+
+    if data is not None:
+        return dedupe_agents(extract_agents_from_json(data))
+
+    result: list[dict[str, str]] = []
+    for line in stripped.splitlines():
+        parsed = parse_text_line(line)
+        if parsed:
+            result.append(parsed)
+    return dedupe_agents(result)
+
+
+def dedupe_agents(agents: list[dict[str, str]]) -> list[dict[str, str]]:
+    deduped: list[dict[str, str]] = []
+    seen: set[tuple[str, str]] = set()
+    for agent in agents:
+        agent_id = agent.get("agent_id", "").strip()
+        name = agent.get("name", "").strip()
+        description = agent.get("description", "").strip()
+        key = (agent_id.lower(), name.lower())
+        if not agent_id or key in seen:
+            continue
+        deduped.append(
+            {
+                "agent_id": agent_id,
+                "name": name,
+                "description": description,
+            }
+        )
+        seen.add(key)
+    return deduped
+
+
+def score_agent(agent: dict[str, str], query: str) -> tuple[int, str]:
+    normalized_query = normalize_text(query)
+    agent_id = agent.get("agent_id", "")
+    name = agent.get("name", "")
+    description = agent.get("description", "")
+
+    fields = [
+        ("agent_id", agent_id),
+        ("name", name),
+        ("description", description),
+    ]
+
+    for label, value in fields:
+        if normalize_text(value) == normalized_query and value:
+            return 100, f"exact_{label}"
+
+    if normalized_query in normalize_text(agent_id):
+        return 95, "contains_agent_id"
+    if normalized_query in normalize_text(name):
+        return 90, "contains_name"
+    if normalized_query in normalize_text(description):
+        return 80, "contains_description"
+
+    ratios = []
+    for label, value in fields[:2]:
+        if value:
+            ratio = difflib.SequenceMatcher(None, normalized_query, normalize_text(value)).ratio()
+            ratios.append((int(ratio * 100), f"similar_{label}"))
+
+    if ratios:
+        best_score, best_reason = max(ratios, key=lambda item: item[0])
+        if best_score >= 45:
+            return best_score, best_reason
+
+    return 0, "no_match"
+
+
+def build_resolution(agents: list[dict[str, str]], query: str, limit: int) -> dict[str, Any]:
+    scored = []
+    for agent in agents:
+        score, reason = score_agent(agent, query)
+        if score > 0:
+            item = dict(agent)
+            item["score"] = score
+            item["match_reason"] = reason
+            scored.append(item)
+
+    scored.sort(key=lambda item: (-item["score"], item["agent_id"]))
+    candidates = scored[:limit]
+
+    exact_agent = next((item for item in candidates if item["score"] == 100 and item["match_reason"] == "exact_agent_id"), None)
+    resolved_agent_id = exact_agent["agent_id"] if exact_agent else None
+    if resolved_agent_id:
+        confirmation_message = f"已精确匹配到 Agent：{resolved_agent_id}，可以继续安装。"
+        suggested_replies = [resolved_agent_id]
+        status = "EXACT_MATCH"
+    elif candidates:
+        lines = ["我找到了以下候选 Agent，请确认要安装哪一个："]
+        for index, candidate in enumerate(candidates, start=1):
+            name = f"（{candidate['name']}）" if candidate.get("name") else ""
+            desc = f" - {candidate['description']}" if candidate.get("description") else ""
+            lines.append(f"{index}. {candidate['agent_id']}{name}{desc}")
+        confirmation_message = "\n".join(lines)
+        suggested_replies = [candidate["agent_id"] for candidate in candidates]
+        status = "NEEDS_CONFIRMATION"
+    else:
+        confirmation_message = "没有找到匹配的 Agent，请换一个更准确的名称、ID 或功能描述。"
+        suggested_replies = []
+        status = "NO_MATCH"
+
+    return {
+        "query": query,
+        "status": status,
+        "resolved_agent_id": resolved_agent_id,
+        "needs_confirmation": resolved_agent_id is None,
+        "candidates": candidates,
+        "confirmation_message": confirmation_message,
+        "suggested_replies": suggested_replies,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="列出可用 Agent，并支持模糊匹配")
+    parser.add_argument("--query", help="用户输入的 Agent 名称、别名或描述关键词")
+    parser.add_argument("--limit", type=int, default=5, help="返回候选数量")
+    parser.add_argument("--input-file", help="从文件读取 sophhub agent list --json 输出，便于调试")
+    args = parser.parse_args()
+
+    if args.input_file:
+        stdout = open(args.input_file, "r", encoding="utf-8").read()
+        stderr = ""
+        returncode = 0
+    else:
+        returncode, stdout, stderr = run_sophhub_agent_list()
+
+    agents = parse_agents_output(stdout)
+
+    payload: dict[str, Any] = {
+        "ok": returncode == 0,
+        "total_agents": len(agents),
+        "agents": agents,
+        "raw_stdout": stdout,
+    }
+
+    if stderr:
+        payload["stderr"] = stderr
+
+    if args.query:
+        payload["resolution"] = build_resolution(agents, args.query, max(1, args.limit))
+
+    json.dump(payload, sys.stdout, indent=2, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0 if args.input_file or returncode == 0 else returncode
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/agent-install/src/scripts/resolve_install_params.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from common import (
+    build_agent_entry,
+    default_openclaw_config_path,
+    load_agent_definition,
+    load_openclaw_config,
+    merge_placeholder_catalog_with_detected,
+    normalize_placeholder_catalog,
+    read_agent_placeholders,
+    resolve_agent_directory,
+    resolve_existing_agent_entry,
+)
+
+
+def resolve_install_params(agent_id: str, source_path: Path, config_path: Path) -> dict[str, object]:
+    agent_def = load_agent_definition(agent_id, source_path)
+    agent_dir = resolve_agent_directory(agent_id, source_path)
+    entry = build_agent_entry(agent_def)
+    identity = entry.get("identity", {})
+    placeholders = read_agent_placeholders(agent_id, source_path)
+    placeholder_catalog = normalize_placeholder_catalog(agent_def.get("placeholder_catalog"))
+    placeholders_detail = merge_placeholder_catalog_with_detected(placeholder_catalog, placeholders)
+    current_openclaw_id = None
+    installed = False
+
+    try:
+        openclaw = load_openclaw_config(config_path)
+    except FileNotFoundError:
+        openclaw = None
+
+    if openclaw is not None:
+        existing_entry = resolve_existing_agent_entry(config_path, openclaw, agent_id, entry["workspace"])
+        if existing_entry is not None:
+            current_openclaw_id = existing_entry.get("id")
+            installed = True
+
+    return {
+        "ok": True,
+        "agent_id": agent_id,
+        "source_path": str(source_path),
+        "config_path": str(config_path),
+        "agent_directory": str(agent_dir),
+        "openclaw_id": current_openclaw_id or agent_id,
+        "current_openclaw_id": current_openclaw_id,
+        "installed": installed,
+        "workspace": entry["workspace"],
+        "agent_name": entry.get("name") or (identity.get("name") if isinstance(identity, dict) else None),
+        "identity_name": identity.get("name") if isinstance(identity, dict) else None,
+        "placeholders": placeholders,
+        "placeholder_catalog": placeholder_catalog,
+        "placeholders_detail": placeholders_detail,
+        "needs_name_confirmation": bool(placeholders),
+        "message": "已解析 Agent 的默认安装参数。",
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="解析 Agent 安装参数")
+    parser.add_argument("--agent-id", required=True, help="Agent ID")
+    parser.add_argument(
+        "--path",
+        required=True,
+        help="Agent 下载目录（sophhub agent download 的 --path）",
+    )
+    parser.add_argument(
+        "--config",
+        default=str(default_openclaw_config_path()),
+        help="openclaw.json 路径",
+    )
+    args = parser.parse_args()
+
+    result = resolve_install_params(
+        args.agent_id,
+        Path(args.path).expanduser().resolve(),
+        Path(args.config).expanduser().resolve(),
+    )
+    json.dump(result, sys.stdout, indent=2, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/agent-install/src/scripts/update_agent_md.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from common import markdown_files_in_dir, read_agent_placeholders, resolve_agent_directory
+
+
+def parse_replacements(values: list[str]) -> dict[str, str]:
+    replacements: dict[str, str] = {}
+    for value in values:
+        if "=" not in value:
+            raise ValueError(f"replace 参数格式错误: {value}")
+        key, raw_replacement = value.split("=", 1)
+        placeholder = key.strip()
+        replacement = raw_replacement.strip()
+        if not placeholder or not replacement:
+            raise ValueError(f"replace 参数格式错误: {value}")
+        replacements[placeholder] = replacement
+    return replacements
+
+
+def update_agent_md(agent_id: str, source_path: Path, replacements: dict[str, str]) -> dict[str, object]:
+    agent_dir = resolve_agent_directory(agent_id, source_path)
+    md_files = markdown_files_in_dir(agent_dir)
+    placeholders = read_agent_placeholders(agent_id, source_path)
+    updated_files: list[str] = []
+
+    for md_path in md_files:
+        original = md_path.read_text(encoding="utf-8")
+        updated = original
+        for placeholder, replacement in replacements.items():
+            updated = updated.replace(placeholder, replacement)
+        if updated != original:
+            md_path.write_text(updated, encoding="utf-8")
+            updated_files.append(md_path.name)
+
+    return {
+        "ok": True,
+        "agent_id": agent_id,
+        "agent_directory": str(agent_dir),
+        "placeholders": placeholders,
+        "replacements": replacements,
+        "updated_files": updated_files,
+        "message": "Agent 模板中的占位（placeholder_catalog / token）替换完成。",
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="按 token 替换 Agent 模板 .md（见 placeholder_catalog）")
+    parser.add_argument("--agent-id", required=True, help="Agent ID")
+    parser.add_argument("--path", required=True, help="Agent 下载目录（sophhub agent download 的 --path）")
+    parser.add_argument(
+        "--replace",
+        action="append",
+        default=[],
+        help='token 替换，格式如 --replace "{{客服助手}}=客服助手A"（token 与配置侧 label 见 placeholder_catalog）',
+    )
+    args = parser.parse_args()
+
+    replacements = parse_replacements(args.replace)
+    result = update_agent_md(
+        args.agent_id,
+        Path(args.path).expanduser().resolve(),
+        replacements,
+    )
+    json.dump(result, sys.stdout, indent=2, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/skills/agent-install/src/scripts/update_openclaw.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from common import (
+    build_agent_entry,
+    build_bot_api_account,
+    deep_merge_dict,
+    default_openclaw_config_path,
+    dump_json,
+    find_agent_entry,
+    find_bot_api_accounts_by_agent_id,
+    find_agent_by_workspace,
+    load_agent_definition,
+    load_openclaw_config,
+    resolve_existing_agent_entry,
+    write_install_state,
+)
+
+
+def normalized_override(value: str | None) -> str | None:
+    if isinstance(value, str):
+        stripped = value.strip()
+        if stripped:
+            return stripped
+    return None
+
+
+def upsert_agent(config: dict, entry: dict) -> str:
+    config.setdefault("agents", {})
+    agents = config["agents"].setdefault("list", [])
+
+    for index, agent in enumerate(agents):
+        if isinstance(agent, dict) and agent.get("id") == entry["id"]:
+            agents[index] = deep_merge_dict(agent, entry)
+            return "updated"
+
+    agents.append(entry)
+    return "created"
+
+
+def ensure_bot_api(
+    config: dict,
+    agent_def: dict,
+    *,
+    target_agent_id: str,
+    name_override: str | None = None,
+) -> dict[str, object] | None:
+    existing_accounts = find_bot_api_accounts_by_agent_id(config, target_agent_id)
+    existing_secret = None
+    if existing_accounts:
+        first_account = next(iter(existing_accounts.values()))
+        existing_secret = first_account.get("apiSecret")
+
+    built = build_bot_api_account(
+        agent_def,
+        agent_id_override=target_agent_id,
+        existing_secret=existing_secret,
+        name_override=name_override,
+    )
+    if built is None:
+        return None
+
+    account_id, account = built
+    plugins = config.setdefault("plugins", {})
+    allow = plugins.setdefault("allow", [])
+    if "bot-api" not in allow:
+        allow.append("bot-api")
+    entries = plugins.setdefault("entries", {})
+    entries.setdefault("bot-api", {})["enabled"] = True
+
+    channels = config.setdefault("channels", {})
+    bot_api = channels.setdefault("bot-api", {})
+    accounts = bot_api.setdefault("accounts", {})
+    action = "updated" if account_id in accounts else "created"
+    accounts[account_id] = account
+
+    return {
+        "account_id": account_id,
+        "action": action,
+        "apiSecret": account["apiSecret"],
+    }
+
+
+def update_openclaw(
+    agent_id: str,
+    config_path: Path,
+    *,
+    source_path: Path | None = None,
+    openclaw_id_override: str | None = None,
+    workspace_override: str | None = None,
+    name_override: str | None = None,
+) -> dict[str, object]:
+    resolved_openclaw_id = normalized_override(openclaw_id_override)
+    resolved_workspace = normalized_override(workspace_override)
+    resolved_name = normalized_override(name_override)
+    agent_def = load_agent_definition(agent_id, source_path)
+    config = load_openclaw_config(config_path)
+    desired_workspace = resolved_workspace or agent_def.get("install", {}).get("workspace") or agent_def.get("workspace")
+    previous = resolve_existing_agent_entry(config_path, config, agent_id, desired_workspace)
+    if previous is None and resolved_openclaw_id:
+        existing_by_target_id = find_agent_entry(config, resolved_openclaw_id)
+        if existing_by_target_id is not None:
+            raise ValueError(f"目标 openclaw id 已存在且不属于当前 Agent: {resolved_openclaw_id}")
+    if previous is not None:
+        target_agent_id = previous.get("id") if previous.get("id") else agent_id
+    else:
+        target_agent_id = resolved_openclaw_id or agent_id
+
+    entry = build_agent_entry(
+        agent_def,
+        target_id_override=target_agent_id,
+        workspace_override=resolved_workspace,
+        name_override=resolved_name,
+    )
+    agent_action = upsert_agent(config, entry)
+    bot_api_result = ensure_bot_api(
+        config,
+        agent_def,
+        target_agent_id=target_agent_id,
+        name_override=resolved_name,
+    )
+
+    dump_json(config_path, config)
+    state_path = write_install_state(
+        config_path,
+        target_agent_id,
+        {
+            "agent_id": agent_id,
+            "openclaw_id": target_agent_id,
+            "version": agent_def["version"],
+            "workspace": entry["workspace"],
+            "agentDir": entry.get("agentDir"),
+        },
+    )
+
+    return {
+        "agent_id": agent_id,
+        "openclaw_id": target_agent_id,
+        "agent_action": agent_action,
+        "bot_api": bot_api_result,
+        "workspace": entry["workspace"],
+        "name": entry.get("name") or entry.get("identity", {}).get("name"),
+        "agent_dir": entry.get("agentDir"),
+        "previous_workspace": previous.get("workspace") if previous else None,
+        "version": agent_def["version"],
+        "install_state": str(state_path),
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="根据 .config.json 幂等更新 openclaw.json")
+    parser.add_argument("--agent-id", required=True, help="Agent ID")
+    parser.add_argument("--source-path", help="Agent 下载目录（sophhub agent download 的 --path）")
+    parser.add_argument("--openclaw-id", help="目标 openclaw id（resolve_install_params 与流程确认结果）")
+    parser.add_argument("--workspace", help="目标 workspace（流程确认结果）")
+    parser.add_argument("--name", help="显示名称 agent_name（流程确认结果）")
+    parser.add_argument(
+        "--config",
+        default=str(default_openclaw_config_path()),
+        help="openclaw.json 路径",
+    )
+    args = parser.parse_args()
+
+    result = update_openclaw(
+        args.agent_id,
+        Path(args.config).expanduser().resolve(),
+        source_path=Path(args.source_path).expanduser().resolve() if args.source_path else None,
+        openclaw_id_override=args.openclaw_id,
+        workspace_override=args.workspace,
+        name_override=args.name,
+    )
+    json.dump(result, sys.stdout, indent=2, ensure_ascii=False)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())