tnyma-bridge 0.1.0

package/bundle/feishu-bot-creator/feishu_bot_creator.py

@@ -0,0 +1,2063 @@
+#!/usr/bin/env python3
+# Copyright (C) 2025 Tencent. All rights reserved.
+#
+# Adapted for tnyma-bridge: this is the Tencent Lighthouse Feishu bot creator
+# spawned by bridge-node's /v1/integrations/feishu/bind/stream RPC. Paths and
+# ports are env-overridable so multiple environments (local docker, prod VM)
+# can coexist without code changes.
+"""
+飞书/Lark 开放平台 - 自动创建企业自建机器人 (非交互式)
+
+This script is invoked by bridge-node when the user clicks "扫码自动创建" in
+the tnyma-web UI. stdout emits one JSON line per event; bridge-node parses
+those lines and forwards them as SSE events to the browser.
+
+Environment knobs (all optional, defaults shown):
+    FEISHU_BOT_CDP_PORT=9222
+    FEISHU_BOT_STATE_DIR=/tmp
+    FEISHU_BOT_OPENCLAW_CONFIG=/root/.openclaw/openclaw.json
+    FEISHU_BOT_OPENCLAW_ALLOW_FROM=/root/.openclaw/credentials/feishu-default-allowFrom.json
+    FEISHU_BOT_ACCOUNT_ID=default          # channels.feishu.accounts.<id> key
+
+Usage:
+    python3 feishu_bot_creator.py init     # check/install playwright + chromium
+    python3 feishu_bot_creator.py create   # full flow (default platform: feishu)
+    python3 feishu_bot_creator.py create --platform lark
+    python3 feishu_bot_creator.py cleanup  # kill leftover browser
+"""
+
+from __future__ import annotations
+
+# ============================================================
+# 依赖自举
+# ============================================================
+import importlib
+import importlib.util
+import os
+import subprocess
+import sys
+
+_REQUIRED_PACKAGES = [("playwright", "playwright")]
+
+
+def _ensure_pip():
+    try:
+        importlib.import_module("pip")
+        return
+    except ImportError:
+        pass
+    try:
+        subprocess.check_call(
+            [sys.executable, "-m", "ensurepip", "--upgrade"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+        )
+        return
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+    import tempfile, urllib.request
+    with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+        urllib.request.urlretrieve("https://bootstrap.pypa.io/get-pip.py", f.name)
+        subprocess.check_call(
+            [sys.executable, f.name, "--quiet", "--break-system-packages"])
+
+
+def _ensure_dependencies():
+    missing = [pip for mod, pip in _REQUIRED_PACKAGES
+               if not importlib.util.find_spec(mod)]
+    if missing:
+        _ensure_pip()
+        subprocess.check_call(
+            [sys.executable, "-m", "pip", "install", "--quiet",
+             "--break-system-packages"] + missing)
+        importlib.invalidate_caches()
+        import site; site.main()
+
+    from playwright.sync_api import sync_playwright
+    try:
+        pw = sync_playwright().start()
+        pw.chromium.launch(headless=True).close()
+        pw.stop()
+    except Exception:
+        _install_system_deps()
+        env = os.environ.copy()
+        env["PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD"] = "0"
+        env["DEBIAN_FRONTEND"] = "noninteractive"
+        try:
+            subprocess.check_call(
+                [sys.executable, "-m", "playwright", "install", "chromium"],
+                env=env)
+        except subprocess.CalledProcessError:
+            try:
+                pw2 = sync_playwright().start()
+                path = pw2.chromium.executable_path
+                pw2.stop()
+                if not os.path.isfile(path):
+                    raise FileNotFoundError(path)
+            except Exception:
+                sys.exit(1)
+
+
+def _install_system_deps():
+    _LIBS_YUM = [
+        "nss", "nspr", "atk", "at-spi2-atk", "at-spi2-core",
+        "libdrm", "libXcomposite", "libXdamage", "libXrandr",
+        "mesa-libgbm", "pango", "cups-libs", "libxkbcommon",
+        "alsa-lib", "libXfixes", "libxshmfence",
+    ]
+    _LIBS_APT = [
+        "libnss3", "libnspr4", "libatk1.0-0", "libatk-bridge2.0-0",
+        "libdrm2", "libxcomposite1", "libxdamage1", "libxrandr2",
+        "libgbm1", "libpango-1.0-0", "libcups2", "libxkbcommon0",
+        "libasound2", "libxfixes3", "libxshmfence1",
+    ]
+    for pkg_mgr, libs in [
+        (["yum", "install", "-y"], _LIBS_YUM),
+        (["dnf", "install", "-y"], _LIBS_YUM),
+        (["apt-get", "install", "-y"], _LIBS_APT),
+    ]:
+        try:
+            subprocess.check_call(
+                [pkg_mgr[0], "--version"],
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            continue
+        try:
+            subprocess.call(
+                pkg_mgr + libs,
+                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+            )
+        except Exception:
+            pass
+        break
+
+
+# ============================================================
+# Stdout: line-buffered / write-through so bridge-node sees lines immediately
+# ============================================================
+if hasattr(sys.stdout, "reconfigure"):
+    sys.stdout.reconfigure(write_through=True)
+elif hasattr(sys.stdout, "buffer"):
+    import io as _io
+    sys.stdout = _io.TextIOWrapper(
+        sys.stdout.buffer, write_through=True,
+        encoding=sys.stdout.encoding, errors=sys.stdout.errors,
+    )
+
+import json
+import random
+import signal
+import ssl
+import time
+import uuid
+import urllib.request
+import urllib.error
+import urllib.parse
+from typing import Optional
+
+# ============================================================
+# Env-overridable config
+# ============================================================
+CDP_PORT = int(os.environ.get("FEISHU_BOT_CDP_PORT", "9222"))
+STATE_DIR = os.environ.get("FEISHU_BOT_STATE_DIR", "/tmp")
+OPENCLAW_CONFIG = os.environ.get(
+    "FEISHU_BOT_OPENCLAW_CONFIG", "/root/.openclaw/openclaw.json")
+OPENCLAW_ALLOW_FROM = os.environ.get(
+    "FEISHU_BOT_OPENCLAW_ALLOW_FROM",
+    "/root/.openclaw/credentials/feishu-default-allowFrom.json")
+OPENCLAW_ACCOUNT_ID = os.environ.get("FEISHU_BOT_ACCOUNT_ID", "default")
+
+LOGIN_TIMEOUT = 90
+POLL_INTERVAL = 2
+QR_MAX_RETRIES = 3
+
+# Bundled TnymaAI brand mark (the 512×512 Q-version mascot from
+# tnyma-ai-installer). Sits next to this .py file in the tarball (tsup
+# copies tools/feishu-bot-creator/assets/ → dist/feishu-bot-creator/assets/).
+# Using the local file removes the dependency on ai.tnyma.com being
+# reachable from the user's machine at create-time.
+#
+# Network URL kept as fallback only — if the bundled asset is somehow
+# missing (developer running from source without copying assets, broken
+# install), fall back to fetching over the wire.
+BUNDLED_AVATAR_PATH = os.path.join(
+    os.path.dirname(os.path.abspath(__file__)), "assets", "tnyma-ai-avatar.png")
+DEFAULT_AVATAR_URL = "https://ai.tnyma.com/assets/8-tight.png"
+
+WEBSOCKET_POLL_INTERVAL = 3
+WEBSOCKET_POLL_TIMEOUT = 60
+
+PERMISSION_UPDATE_TIMEOUT_MS = int(
+    os.environ.get("FEISHU_BOT_PERMISSION_UPDATE_TIMEOUT_MS", "60000") or "60000")
+PERMISSION_UPDATE_RETRY_DELAYS_SECONDS = [0, 5, 15, 30]
+
+# ============================================================
+# Platform configs
+# ============================================================
+PLATFORM = "feishu"
+
+_PLATFORM_CONFIGS = {
+    "feishu": {
+        "base_url": "https://open.feishu.cn",
+        "login_url": (
+            "https://accounts.feishu.cn/accounts/page/login"
+            "?app_id=7&no_trap=1"
+            "&redirect_uri=https%3A%2F%2Fopen.feishu.cn%2Fapp"
+        ),
+        "accounts_host": "accounts.feishu.cn",
+        "open_host": "open.feishu.cn",
+        "admin_audit_url": "https://feishu.cn/admin/appCenter/audit",
+        "config_domain": "feishu",
+        "primary_lang": "zh_cn",
+        "default_greeting": "Hi，我是你刚刚使用 OpenClaw 创建的机器人，你现在可以跟我聊天了！",
+        "state_file_prefix": "feishu-bot",
+        "profile_dir_name": "feishu-bot-chrome-profile",
+        "qr_default": True,
+    },
+    "lark": {
+        "base_url": "https://open.larksuite.com",
+        "login_url": (
+            "https://accounts.larksuite.com/accounts/page/login"
+            "?app_id=7&no_trap=1"
+            "&redirect_uri=https%3A%2F%2Fopen.larksuite.com%2F%3Flang%3Dzh-CN"
+        ),
+        "accounts_host": "accounts.larksuite.com",
+        "open_host": "open.larksuite.com",
+        "admin_audit_url": "https://larksuite.com/admin/appCenter/audit",
+        "config_domain": "lark",
+        "primary_lang": "en_us",
+        "default_greeting": "Hi, I'm the bot you just created with OpenClaw. You can chat with me now!",
+        "state_file_prefix": "lark-bot",
+        "profile_dir_name": "lark-bot-chrome-profile",
+        "qr_default": False,
+    },
+}
+
+
+def _pcfg(key: str):
+    return _PLATFORM_CONFIGS[PLATFORM][key]
+
+
+# Permissions
+BOT_PERMISSIONS = [
+    "im:message", "im:message.p2p_msg:readonly",
+    "im:message.group_at_msg:readonly", "im:message:send_as_bot",
+    "im:resource", "im:message.group_msg", "im:message:readonly",
+    "im:message:update", "im:message:recall", "im:message.reactions:read",
+    "im:chat", "im:chat:readonly", "im:chat:read", "im:chat:update",
+    "contact:user.base:readonly", "contact:contact.base:readonly",
+    "docx:document:readonly", "docx:document", "docx:document.block:convert",
+    "wiki:wiki:readonly", "wiki:wiki",
+    "bitable:app:readonly", "bitable:app",
+    "task:task:read", "task:task:write",
+]
+
+BOT_PERMISSIONS_NEED_AUDIT = [
+    "drive:drive:readonly",
+    "drive:drive",
+]
+
+
+def _gen_bot_name() -> str:
+    # Feishu rejects duplicate app names within the same workspace, so
+    # we still suffix a 4-digit counter — but the brand string is fixed
+    # at TnymaAI (vs. the legacy OpenClaw default).
+    if PLATFORM == "lark":
+        return f"TnymaAI-{random.randint(1000, 9999)}"
+    return f"TnymaAI-{random.randint(1000, 9999)}"
+
+
+def _state_file() -> str:
+    return os.path.join(STATE_DIR, f"{_pcfg('state_file_prefix')}-creator-state.json")
+
+
+def _save_state(data: dict) -> None:
+    with open(_state_file(), "w") as f:
+        json.dump(data, f, ensure_ascii=False)
+
+
+# ============================================================
+# Structured JSON output (stdout)
+# ============================================================
+def _emit(action: str, level: str, step: str, message: str, **extra) -> None:
+    record = {"action": action, "level": level, "step": step,
+              "message": message, "ts": int(time.time())}
+    record.update(extra)
+    print(json.dumps(record, ensure_ascii=False))
+
+
+def _log_info(step: str, message: str, **extra) -> None:
+    _emit("log", "info", step, message, **extra)
+
+
+def _log_success(step: str, message: str, **extra) -> None:
+    _emit("log", "success", step, message, **extra)
+
+
+def _log_warn(step: str, message: str, **extra) -> None:
+    _emit("log", "warn", step, message, **extra)
+
+
+def _log_error(step: str, message: str, **extra) -> None:
+    _emit("log", "error", step, message, **extra)
+
+
+def _emit_progress(step: str, message: str, current: int, total: int) -> None:
+    _emit("progress", "info", step, message, current=current, total=total)
+
+
+def _emit_finish(message: str, data: dict) -> None:
+    _emit("finish", "success", "finish", message, data=data)
+
+
+def _emit_error(step: str, message: str) -> None:
+    _emit("finish", "error", step, message)
+
+
+def _download_avatar(avatar_url: str = "") -> str:
+    # When the caller passes an explicit --avatar-url, honour it (network
+    # fetch only). Otherwise prefer the bundled brand asset shipped next
+    # to this script — that's the canonical TnymaAI mascot and removes
+    # the dependency on ai.tnyma.com being reachable.
+    if not avatar_url and os.path.isfile(BUNDLED_AVATAR_PATH) \
+            and os.path.getsize(BUNDLED_AVATAR_PATH) > 0:
+        _log_info("create_app", f"使用内置品牌头像: {BUNDLED_AVATAR_PATH}")
+        return BUNDLED_AVATAR_PATH
+
+    url = avatar_url or DEFAULT_AVATAR_URL
+    avatar_path = os.path.join(STATE_DIR, f"{_pcfg('state_file_prefix')}-avatar.png")
+    if not avatar_url and os.path.isfile(avatar_path) and os.path.getsize(avatar_path) > 0:
+        _log_info("create_app", f"使用已缓存头像: {avatar_path}")
+        return avatar_path
+
+    _log_info("create_app", f"正在下载头像: {url}")
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+    try:
+        with urllib.request.urlopen(req, context=ctx) as resp:
+            data = resp.read()
+        with open(avatar_path, "wb") as f:
+            f.write(data)
+        _log_info("create_app", f"头像下载完成: {len(data)} bytes")
+        return avatar_path
+    except Exception as e:
+        _log_warn("create_app", f"头像下载失败: {e}")
+        return ""
+
+
+def _write_openclaw_config(app_id: str, app_secret: str,
+                           account_id: str | None = None) -> bool:
+    """Write channel config in the nested schema expected by bridge-node's
+    buildChannelPatch. Merge-only: each call adds/updates one account
+    under channels.feishu.accounts.<account_id>; other accounts are
+    preserved. Required so a team flow can create N+1 Feishu apps and
+    each agent gets its own appId/appSecret.
+
+        channels.feishu.{
+            enabled: true,
+            defaultAccount: <first-account-id-seen>,
+            accounts.{<account_id>}.{
+                enabled: true,
+                name: <account_id>,
+                appId, appSecret,
+                domain, groupPolicy
+            }
+        }
+    """
+    aid = (account_id or OPENCLAW_ACCOUNT_ID or "default").strip() or "default"
+    config_dir = os.path.dirname(OPENCLAW_CONFIG)
+    os.makedirs(config_dir, exist_ok=True)
+
+    config: dict = {}
+    if os.path.isfile(OPENCLAW_CONFIG):
+        try:
+            with open(OPENCLAW_CONFIG) as f:
+                config = json.load(f)
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    channels = config.setdefault("channels", {})
+    feishu = channels.setdefault("feishu", {})
+    feishu["enabled"] = True
+    # Only set defaultAccount when it's missing — don't clobber the
+    # controller's claim when later members write their entries.
+    feishu.setdefault("defaultAccount", aid)
+    accounts = feishu.setdefault("accounts", {})
+    accounts[aid] = {
+        "enabled": True,
+        "name": aid,
+        "appId": app_id,
+        "appSecret": app_secret,
+        "domain": _pcfg("config_domain"),
+        "groupPolicy": "open",
+    }
+
+    # Atomic write: write to .tmp first then os.replace. The gateway
+    # uses a file watcher to detect config changes; if we wrote directly
+    # to OPENCLAW_CONFIG the watcher could fire mid-write and pick up
+    # a truncated JSON. os.replace is atomic on POSIX so readers see
+    # either the old file or the new one, never a half-written one.
+    tmp = OPENCLAW_CONFIG + ".tmp"
+    try:
+        with open(tmp, "w") as f:
+            json.dump(config, f, ensure_ascii=False, indent=2)
+        os.replace(tmp, OPENCLAW_CONFIG)
+        _log_success(
+            "config",
+            f"已写入配置 (account={aid}, domain={_pcfg('config_domain')})")
+        return True
+    except IOError as e:
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+        _log_error("config", f"写入配置文件失败: {e}")
+        return False
+
+
+def _allow_from_path_for_account(account_id: str | None = None) -> str:
+    aid = (account_id or OPENCLAW_ACCOUNT_ID or "default").strip() or "default"
+    return OPENCLAW_ALLOW_FROM.replace(
+        f"feishu-{OPENCLAW_ACCOUNT_ID}-allowFrom.json",
+        f"feishu-{aid}-allowFrom.json",
+    )
+
+
+def _write_allow_from(open_id: str, account_id: str | None = None) -> bool:
+    """Write the per-account allowFrom file. account_id is interpolated
+    into the path replacing the global default, so each Feishu bot in a
+    team gets its own ~/.openclaw/credentials/feishu-<id>-allowFrom.json.
+    """
+    aid = (account_id or OPENCLAW_ACCOUNT_ID or "default").strip() or "default"
+    target_path = _allow_from_path_for_account(aid)
+    _emit("write_config", "info", "config", "写入 allowFrom",
+          path=target_path)
+
+    config_dir = os.path.dirname(target_path)
+    os.makedirs(config_dir, exist_ok=True)
+
+    data = {"version": 1, "allowFrom": [open_id]}
+
+    # Same atomic write strategy as _write_openclaw_config.
+    tmp = target_path + ".tmp"
+    try:
+        with open(tmp, "w") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        os.replace(tmp, target_path)
+        _log_success("config", f"已写入 allowFrom (account={aid}, open_id={open_id})")
+        return True
+    except IOError as e:
+        try:
+            os.remove(tmp)
+        except OSError:
+            pass
+        _log_error("config", f"写入 allowFrom 失败: {e}")
+        return False
+
+
+def _cleanup_openclaw_feishu_accounts(account_ids: list[str]) -> None:
+    ids = [aid for aid in _dedupe_keep_order(account_ids) if aid != "main"]
+    if not ids:
+        return
+
+    removed_accounts: list[str] = []
+    config: dict = {}
+    if os.path.isfile(OPENCLAW_CONFIG):
+        try:
+            with open(OPENCLAW_CONFIG) as f:
+                config = json.load(f)
+        except (json.JSONDecodeError, IOError) as e:
+            _log_warn("config", f"回滚配置失败，无法读取 openclaw.json: {e}")
+            config = {}
+
+    channels = config.get("channels")
+    feishu = channels.get("feishu") if isinstance(channels, dict) else None
+    accounts = feishu.get("accounts") if isinstance(feishu, dict) else None
+    if isinstance(accounts, dict):
+        for aid in ids:
+            if accounts.pop(aid, None) is not None:
+                removed_accounts.append(aid)
+        if feishu.get("defaultAccount") in ids:
+            feishu["defaultAccount"] = next(iter(accounts.keys()), None)
+            if feishu["defaultAccount"] is None:
+                feishu.pop("defaultAccount", None)
+
+    if removed_accounts:
+        tmp = OPENCLAW_CONFIG + ".tmp"
+        try:
+            with open(tmp, "w") as f:
+                json.dump(config, f, ensure_ascii=False, indent=2)
+            os.replace(tmp, OPENCLAW_CONFIG)
+            _log_warn("config", f"已回滚本次失败流程写入的飞书账号: {removed_accounts}")
+        except IOError as e:
+            try:
+                os.remove(tmp)
+            except OSError:
+                pass
+            _log_warn("config", f"回滚 openclaw.json 失败: {e}")
+
+    for aid in ids:
+        path = _allow_from_path_for_account(aid)
+        try:
+            if os.path.isfile(path):
+                os.remove(path)
+                _log_warn("config", f"已删除失败流程残留 allowFrom: {path}")
+        except OSError as e:
+            _log_warn("config", f"删除 allowFrom 残留失败: {path}: {e}")
+
+
+def _send_greeting(app_id: str, app_secret: str, open_id: str, greeting: str = "") -> None:
+    _log_info("greeting", "发送初始问候消息")
+    greeting = greeting or _pcfg("default_greeting")
+    base_url = _pcfg("base_url")
+
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+
+    token_payload = json.dumps({
+        "app_id": app_id, "app_secret": app_secret,
+    }).encode()
+    token_req = urllib.request.Request(
+        f"{base_url}/open-apis/auth/v3/tenant_access_token/internal",
+        data=token_payload,
+        headers={"Content-Type": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(token_req, context=ctx) as resp:
+            token_data = json.loads(resp.read())
+        token = token_data.get("tenant_access_token")
+        if not token:
+            return
+    except Exception:
+        return
+
+    send_payload = json.dumps({
+        "receive_id": open_id,
+        "msg_type": "text",
+        "content": json.dumps({"text": greeting}),
+        "uuid": str(uuid.uuid4()),
+    }).encode()
+    send_req = urllib.request.Request(
+        f"{base_url}/open-apis/im/v1/messages?receive_id_type=open_id",
+        data=send_payload,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}",
+        },
+    )
+    try:
+        with urllib.request.urlopen(send_req, context=ctx) as resp:
+            resp.read()
+    except Exception:
+        pass
+
+
+def _fetch_tenant_access_token(app_id: str, app_secret: str) -> str:
+    base_url = _pcfg("base_url")
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+
+    payload = json.dumps({
+        "app_id": app_id, "app_secret": app_secret,
+    }).encode()
+    req = urllib.request.Request(
+        f"{base_url}/open-apis/auth/v3/tenant_access_token/internal",
+        data=payload,
+        headers={"Content-Type": "application/json; charset=utf-8"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, context=ctx) as resp:
+            body = json.loads(resp.read())
+    except Exception as e:
+        raise RuntimeError(f"获取 tenant_access_token 失败: {e}") from e
+
+    token = body.get("tenant_access_token")
+    if not token:
+        raise RuntimeError(
+            f"获取 tenant_access_token 失败: {body.get('msg') or body}")
+    return token
+
+
+def _request_feishu_json(method: str, path: str, token: str,
+                         payload: Optional[dict] = None,
+                         query: Optional[dict] = None) -> dict:
+    base_url = _pcfg("base_url")
+    query_string = urllib.parse.urlencode(query or {})
+    url = f"{base_url}/open-apis{path}"
+    if query_string:
+        url = f"{url}?{query_string}"
+
+    data = None
+    if payload is not None:
+        data = json.dumps(payload, ensure_ascii=False).encode()
+
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={
+            "Content-Type": "application/json; charset=utf-8",
+            "Authorization": f"Bearer {token}",
+        },
+        method=method,
+    )
+    ctx = ssl.create_default_context()
+    ctx.check_hostname = False
+    ctx.verify_mode = ssl.CERT_NONE
+
+    try:
+        with urllib.request.urlopen(req, context=ctx) as resp:
+            raw = resp.read().decode("utf-8")
+            return json.loads(raw or "{}")
+    except urllib.error.HTTPError as e:
+        try:
+            detail = e.read().decode("utf-8")
+        except Exception:
+            detail = str(e)
+        raise RuntimeError(f"{method} {path} HTTP {e.code}: {detail}") from e
+    except Exception as e:
+        raise RuntimeError(f"{method} {path} 失败: {e}") from e
+
+
+def _require_feishu_ok(action: str, body: dict) -> dict:
+    if body.get("code") == 0:
+        return body.get("data", {}) or {}
+    raise RuntimeError(f"{action} 失败: code={body.get('code')}, msg={body.get('msg')}")
+
+
+def _dedupe_keep_order(values: list[str]) -> list[str]:
+    seen = set()
+    result: list[str] = []
+    for value in values:
+        item = (value or "").strip()
+        if not item or item in seen:
+            continue
+        seen.add(item)
+        result.append(item)
+    return result
+
+
+TEAM_GROUP_BOT_PROPAGATION_WAIT_SECONDS = int(
+    os.environ.get("TNYMA_FEISHU_TEAM_GROUP_BOT_WAIT_SECONDS", "0") or "0")
+TEAM_GROUP_MEMBER_RETRY_DELAYS_SECONDS = [0, 5, 10, 20]
+TEAM_GROUP_CREATE_RETRY_DELAYS_SECONDS = [0, 3, 8, 15]
+
+
+def _is_retryable_feishu_team_group_error(error: Exception) -> bool:
+    message = str(error)
+    return (
+        "HTTP 500" in message
+        or "Internal Error" in message
+        or "code=2200" in message
+        or "Too Many Requests" in message
+        or "HTTP 429" in message
+    )
+
+
+def _join_feishu_chat(token: str, chat_id: str) -> None:
+    body = _request_feishu_json(
+        "PATCH",
+        f"/im/v1/chats/{chat_id}/members/me_join",
+        token,
+    )
+    _require_feishu_ok("协作机器人加入团队群", body)
+
+
+def _join_feishu_team_group_members_with_retry(
+        chat_id: str, member_app_ids: list[str],
+        app_secret_by_id: dict[str, str],
+        label_by_id: dict[str, str]) -> list[str]:
+    members = _dedupe_keep_order(member_app_ids)
+    if not members:
+        return []
+    pending = members[:]
+    last_errors: dict[str, Exception] = {}
+    member_errors: list[str] = []
+    joined_count = 0
+    for attempt, delay_seconds in enumerate(TEAM_GROUP_MEMBER_RETRY_DELAYS_SECONDS, start=1):
+        if delay_seconds > 0:
+            _emit("progress", "warn", "team_group/member_retry",
+                  f"{len(pending)} 个协作机器人暂未入群，{delay_seconds}s 后重试 "
+                  f"({attempt}/{len(TEAM_GROUP_MEMBER_RETRY_DELAYS_SECONDS)})")
+            time.sleep(delay_seconds)
+        next_pending: list[str] = []
+        for app_id in pending:
+            label = label_by_id.get(app_id) or app_id
+            app_secret = (app_secret_by_id.get(app_id) or "").strip()
+            if not app_secret:
+                member_errors.append(f"{label}: 缺少 app_secret，无法加入群")
+                continue
+            try:
+                member_token = _fetch_tenant_access_token(app_id, app_secret)
+                _join_feishu_chat(member_token, chat_id)
+                joined_count += 1
+                _emit("progress", "success", "team_group/member",
+                      f"已拉入协作机器人：{label}")
+            except Exception as e:
+                last_errors[app_id] = e
+                if _is_retryable_feishu_team_group_error(e):
+                    next_pending.append(app_id)
+                else:
+                    member_errors.append(f"{label}: 加入群失败: {e}")
+        pending = next_pending
+        if not pending:
+            break
+
+    for app_id in pending:
+        label = label_by_id.get(app_id) or app_id
+        member_errors.append(
+            f"{label}: 加入群失败: {last_errors.get(app_id)}")
+    if joined_count:
+        _emit("progress", "success", "team_group/members",
+              f"已拉入 {joined_count}/{len(members)} 个协作机器人")
+    return member_errors
+
+
+def _create_feishu_team_chat_with_retry(token: str, payload: dict,
+                                        query: dict) -> dict:
+    last_error: Exception | None = None
+    for attempt, delay_seconds in enumerate(TEAM_GROUP_CREATE_RETRY_DELAYS_SECONDS, start=1):
+        if delay_seconds > 0:
+            _emit("progress", "warn", "team_group/create_retry",
+                  f"飞书团队群创建暂未成功，{delay_seconds}s 后重试 "
+                  f"({attempt}/{len(TEAM_GROUP_CREATE_RETRY_DELAYS_SECONDS)})")
+            time.sleep(delay_seconds)
+        try:
+            body = _request_feishu_json(
+                "POST",
+                "/im/v1/chats",
+                token,
+                payload,
+                query,
+            )
+            return _require_feishu_ok("创建团队群", body)
+        except Exception as e:
+            last_error = e
+            if not _is_retryable_feishu_team_group_error(e):
+                break
+    raise RuntimeError(f"创建团队群失败: {last_error}") from last_error
+
+
+def _send_feishu_chat_message(token: str, chat_id: str, text: str) -> None:
+    body = _request_feishu_json(
+        "POST",
+        "/im/v1/messages",
+        token,
+        {
+            "receive_id": chat_id,
+            "msg_type": "text",
+            "content": json.dumps({"text": text}, ensure_ascii=False),
+            "uuid": str(uuid.uuid4()),
+        },
+        {"receive_id_type": "chat_id"},
+    )
+    _require_feishu_ok("发送群消息", body)
+
+
+def _create_team_group(all_results: list[dict]) -> Optional[dict]:
+    if len(all_results) <= 1:
+        return None
+
+    operator = all_results[0]
+    operator_app_id = (operator.get("app_id") or "").strip()
+    operator_app_secret = (operator.get("app_secret") or "").strip()
+    owner_open_id = next(
+        ((r.get("open_id") or "").strip() for r in all_results
+         if (r.get("open_id") or "").strip()),
+        "",
+    )
+    owner_name = next(
+        ((r.get("owner_name") or "").strip() for r in all_results
+         if (r.get("owner_name") or "").strip()),
+        "用户",
+    )
+    bot_names = _dedupe_keep_order([
+        (r.get("bot_name") or r.get("account_id") or "").strip()
+        for r in all_results
+    ])
+    bot_app_ids = _dedupe_keep_order([
+        (r.get("app_id") or "").strip() for r in all_results
+    ])
+    bot_name_by_app_id = {
+        (r.get("app_id") or "").strip():
+        (r.get("bot_name") or r.get("account_id") or "").strip()
+        for r in all_results
+        if (r.get("app_id") or "").strip()
+    }
+    bot_secret_by_app_id = {
+        (r.get("app_id") or "").strip(): (r.get("app_secret") or "").strip()
+        for r in all_results
+        if (r.get("app_id") or "").strip()
+    }
+
+    if not operator_app_id or not operator_app_secret:
+        raise RuntimeError("缺少团队主控机器人的 app_id/app_secret")
+    if not owner_open_id:
+        raise RuntimeError("缺少用户 open_id，无法把用户拉入团队群")
+
+    title = " + ".join([*bot_names, owner_name]).strip() or "Tnyma AI Team"
+    _emit("progress", "info", "team_group/start",
+          f"创建飞书团队群：{title}")
+
+    token = _fetch_tenant_access_token(operator_app_id, operator_app_secret)
+    invited_bot_app_ids = [
+        app_id for app_id in bot_app_ids if app_id != operator_app_id
+    ]
+    create_payload = {
+        "name": title,
+        "description": f"Tnyma AI 智能体团队：{title}",
+        "owner_id": owner_open_id,
+        "chat_mode": "group",
+        "chat_type": "public",
+        "external": False,
+        "join_message_visibility": "all_members",
+        "leave_message_visibility": "all_members",
+        "membership_approval": "no_approval_required",
+    }
+
+    data = _create_feishu_team_chat_with_retry(
+        token,
+        create_payload,
+        {
+            "user_id_type": "open_id",
+            "set_bot_manager": "true",
+            "uuid": str(uuid.uuid4()),
+        },
+    )
+    chat_id = (data.get("chat_id") or "").strip()
+    if not chat_id:
+        raise RuntimeError(f"创建团队群未返回 chat_id: {data}")
+
+    member_errors: list[str] = []
+    if invited_bot_app_ids:
+        if TEAM_GROUP_BOT_PROPAGATION_WAIT_SECONDS > 0:
+            _emit("progress", "info", "team_group/member_wait",
+                  "等待飞书发布结果同步后拉协作机器人入群",
+                  seconds=TEAM_GROUP_BOT_PROPAGATION_WAIT_SECONDS)
+            time.sleep(TEAM_GROUP_BOT_PROPAGATION_WAIT_SECONDS)
+        member_errors.extend(_join_feishu_team_group_members_with_retry(
+            chat_id,
+            invited_bot_app_ids,
+            bot_secret_by_app_id,
+            bot_name_by_app_id,
+        ))
+        for error in member_errors:
+            _log_warn("team_group", error)
+
+    if member_errors:
+        _emit("progress", "warn", "team_group/members",
+              f"飞书群已创建，但 {len(member_errors)} 个协作机器人未拉入群",
+              chat_id=chat_id, errors=member_errors)
+    else:
+        _emit("progress", "success", "team_group/members",
+              f"已配置 {len(invited_bot_app_ids)} 个协作机器人入群",
+              chat_id=chat_id)
+    message_error = ""
+    try:
+        _send_feishu_chat_message(token, chat_id, f"团队群已创建：{title}")
+    except Exception as e:
+        message_error = str(e)
+        _log_warn("team_group", f"团队群消息发送失败: {message_error}")
+        _emit("progress", "warn", "team_group/message",
+              f"团队群已创建，但群消息发送失败: {message_error}",
+              chat_id=chat_id)
+
+    level = "warn" if member_errors else "success"
+    _emit("progress", level, "team_group/done",
+          f"飞书团队群已创建：{title}", chat_id=chat_id,
+          errors=member_errors)
+    return {
+        "chat_id": chat_id,
+        "name": title,
+        "owner_open_id": owner_open_id,
+        "owner_name": owner_name,
+        "bot_app_ids": bot_app_ids,
+        "invited_bot_app_ids": invited_bot_app_ids,
+        "create_bot_app_ids": [],
+        "fallback_bot_app_ids": invited_bot_app_ids,
+        "member_errors": member_errors,
+        "message_error": message_error,
+    }
+
+
+def _kill_cdp_browser():
+    sf = _state_file()
+    if os.path.isfile(sf):
+        try:
+            with open(sf) as f:
+                data = json.load(f)
+            pid = data.get("chrome_pid")
+            if pid:
+                os.kill(int(pid), signal.SIGKILL)
+        except (json.JSONDecodeError, OSError, ProcessLookupError):
+            pass
+
+    try:
+        out = subprocess.check_output(
+            ["lsof", "-ti", f":{CDP_PORT}"], stderr=subprocess.DEVNULL
+        ).decode().strip()
+        if out:
+            for pid in out.split("\n"):
+                pid = pid.strip()
+                if pid:
+                    try:
+                        os.kill(int(pid), signal.SIGKILL)
+                    except (OSError, ProcessLookupError):
+                        pass
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        pass
+
+    profile_dir = os.path.join(STATE_DIR, _pcfg("profile_dir_name"))
+    for lock_file in ("SingletonLock", "SingletonSocket", "SingletonCookie"):
+        p = os.path.join(profile_dir, lock_file)
+        if os.path.exists(p):
+            try:
+                os.remove(p)
+            except OSError:
+                pass
+
+
+# ============================================================
+# BotCreator
+# ============================================================
+class FeishuBotCreator:
+
+    def __init__(self, page):
+        self.page = page
+        self.csrf_token: Optional[str] = None
+        self.app_id: Optional[str] = None
+        self.app_secret: Optional[str] = None
+        self.version_id: Optional[str] = None
+        self.owner_name = ""
+        self._base_url = _pcfg("base_url")
+        self._api_base = f"{self._base_url}/developers/v1"
+        self._app_page = f"{self._base_url}/app"
+        self._open_host = _pcfg("open_host")
+
+    def install_network_capture(self) -> None:
+        open_host = self._open_host
+
+        def _on_request(req):
+            if open_host not in req.url:
+                return
+            token = req.headers.get("x-csrf-token") or req.headers.get("X-CSRF-Token")
+            if token:
+                self.csrf_token = token
+
+        self.page.on("request", _on_request)
+
+    def _csrf(self) -> Optional[str]:
+        if self.csrf_token:
+            return self.csrf_token
+        try:
+            token = self.page.evaluate("window.csrfToken || ''")
+            if token:
+                self.csrf_token = token
+                return token
+        except Exception:
+            pass
+        try:
+            cookies = {c["name"]: c["value"]
+                       for c in self.page.context.cookies([self._base_url])}
+            token = (cookies.get("lark_oapi_csrf_token")
+                     or cookies.get("lgw_csrf_token")
+                     or cookies.get("swp_csrf_token"))
+            if token:
+                self.csrf_token = token
+            return token
+        except Exception:
+            return None
+
+    def _headers(self, *, with_body: bool = False) -> dict:
+        h = {"accept": "*/*", "x-timezone-offset": "-480"}
+        if with_body:
+            h.update({"content-type": "application/json",
+                      "origin": self._base_url, "referer": self._app_page})
+        csrf = self._csrf()
+        if csrf:
+            h["x-csrf-token"] = csrf
+        return h
+
+    def _post(self, url: str, payload: dict, *,
+              timeout_ms: int | None = None,
+              log_step: str = "") -> Optional[dict]:
+        try:
+            kwargs = {
+                "data": payload,
+                "headers": self._headers(with_body=True),
+            }
+            if timeout_ms is not None:
+                kwargs["timeout"] = timeout_ms
+            resp = self.page.request.post(url, **kwargs)
+            return resp.json()
+        except Exception as e:
+            if log_step:
+                message = str(e).splitlines()[0][:240]
+                _log_warn(log_step, f"请求失败: {type(e).__name__}: {message}")
+            return None
+
+    def _get(self, url: str) -> Optional[dict]:
+        try:
+            return self.page.request.get(url, headers=self._headers()).json()
+        except Exception:
+            return None
+
+    def _ok(self, body: Optional[dict], step: str, log_step: str = "") -> Optional[dict]:
+        if body is None:
+            return None
+        if body.get("code") != 0:
+            if log_step:
+                _log_error(log_step, f"{step}失败: code={body.get('code')}, msg={body.get('msg')}")
+            return None
+        return body
+
+    @staticmethod
+    def _build_multipart(fields: dict, files: dict):
+        boundary = f"----WebKitFormBoundary{uuid.uuid4().hex[:16]}"
+        parts = []
+        for key, value in fields.items():
+            parts.append(f"--{boundary}\r\n".encode())
+            parts.append(f'Content-Disposition: form-data; name="{key}"\r\n\r\n'.encode())
+            parts.append(f"{value}\r\n".encode())
+        for key, (filename, data, content_type) in files.items():
+            parts.append(f"--{boundary}\r\n".encode())
+            parts.append(f'Content-Disposition: form-data; name="{key}"; filename="{filename}"\r\n'.encode())
+            parts.append(f"Content-Type: {content_type}\r\n\r\n".encode())
+            parts.append(data)
+            parts.append(b"\r\n")
+        parts.append(f"--{boundary}--\r\n".encode())
+        return b"".join(parts), f"multipart/form-data; boundary={boundary}"
+
+    def _upload_avatar(self, avatar_path: str) -> Optional[str]:
+        with open(avatar_path, "rb") as f:
+            img_data = f.read()
+
+        csrf = self._csrf()
+        if not csrf:
+            return None
+
+        browser_cookies = self.page.context.cookies([self._base_url])
+        cookie_str = "; ".join(f"{c['name']}={c['value']}" for c in browser_cookies)
+
+        body, content_type = self._build_multipart(
+            fields={
+                "uploadType": "4",
+                "isIsv": "false",
+                "scale": '{"width":240,"height":240}',
+            },
+            files={
+                "file": (str(uuid.uuid4()), img_data, "image/png"),
+            },
+        )
+
+        headers = {
+            "Accept": "*/*",
+            "Content-Type": content_type,
+            "Cookie": cookie_str,
+            "Origin": self._base_url,
+            "Referer": self._app_page,
+            "User-Agent": ("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                           "AppleWebKit/537.36 (KHTML, like Gecko) "
+                           "Chrome/145.0.0.0 Safari/537.36"),
+            "x-csrf-token": csrf,
+            "x-timezone-offset": "-480",
+        }
+
+        ssl_ctx = ssl.create_default_context()
+        ssl_ctx.check_hostname = False
+        ssl_ctx.verify_mode = ssl.CERT_NONE
+
+        req = urllib.request.Request(
+            f"{self._api_base}/app/upload/image",
+            data=body, headers=headers, method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, context=ssl_ctx) as resp:
+                result = json.loads(resp.read())
+        except urllib.error.HTTPError as e:
+            e.read().decode()
+            return None
+        except Exception:
+            return None
+
+        if result.get("code") != 0:
+            return None
+
+        url = result["data"].get("url", "")
+        return url
+
+    def step1_create_app(self, name: str, desc: str, avatar_path: str) -> bool:
+        _log_info("create_app", f"创建企业自建应用: {name}")
+        if avatar_path and os.path.isfile(avatar_path):
+            _log_info("create_app", f"上传图标: {os.path.basename(avatar_path)}")
+            avatar_url = self._upload_avatar(avatar_path) or ""
+        else:
+            avatar_url = ""
+
+        lang = _pcfg("primary_lang")
+        body = self._post(f"{self._api_base}/app/create", {
+            "appSceneType": 0, "name": name, "desc": desc,
+            "avatar": avatar_url,
+            "i18n": {lang: {"name": name, "description": desc}},
+            "primaryLang": lang,
+        })
+        if not self._ok(body, "创建应用", "create_app"):
+            return False
+        self.app_id = body["data"]["ClientID"]
+        _log_success("create_app", "创建应用成功", app_id=self.app_id)
+        return True
+
+    def step2_get_credentials(self) -> bool:
+        _log_info("credential", "获取应用凭证")
+        body = self._get(f"{self._api_base}/secret/{self.app_id}")
+        if not self._ok(body, "获取 App Secret", "credential"):
+            return False
+        d = body.get("data", {})
+        self.app_secret = (d.get("appSecret") or d.get("app_secret")
+                           or d.get("secret") or d.get("AppSecret"))
+        if not self.app_secret:
+            _log_error("credential", f"未找到 App Secret, keys={list(d.keys())}")
+            return False
+        # NOTE: app_secret is logged here for the script's standalone debugging
+        # mode only. When invoked by bridge-node, the wrapper strips this from
+        # the SSE stream before it reaches the client.
+        _log_success("credential", "获取凭证成功",
+                     app_id=self.app_id, app_secret=self.app_secret)
+        return True
+
+    def step3_add_bot(self) -> bool:
+        _log_info("bot_ability", "添加机器人能力")
+        result = self._ok(
+            self._post(f"{self._api_base}/robot/switch/{self.app_id}", {"enable": True}),
+            "开启机器人能力", "bot_ability")
+        if result is not None:
+            _log_success("bot_ability", "开启机器人能力成功")
+            return True
+        return False
+
+    def step4_event_mode(self) -> bool:
+        _log_info("event_mode", "切换事件模式为长连接 (WebSocket)")
+        deadline = time.time() + WEBSOCKET_POLL_TIMEOUT
+        attempt = 0
+        total = WEBSOCKET_POLL_TIMEOUT // WEBSOCKET_POLL_INTERVAL
+        while time.time() < deadline:
+            attempt += 1
+            body = self._post(f"{self._api_base}/event/switch/{self.app_id}", {"eventMode": 4})
+            if body and body.get("code") == 10068:
+                _emit_progress("event_mode", "等待 WebSocket 连接...",
+                               current=attempt, total=total)
+                time.sleep(WEBSOCKET_POLL_INTERVAL)
+                continue
+            if self._ok(body, "切换事件模式 → WebSocket(4)", "event_mode") is not None:
+                _log_success("event_mode", "切换事件模式成功")
+                return True
+            return False
+        _log_error("event_mode", f"等待 WebSocket 连接超时 ({WEBSOCKET_POLL_TIMEOUT}s)")
+        return False
+
+    def step5_add_event(self) -> bool:
+        _log_info("event", "添加「接收消息」事件")
+        ev = self._get(f"{self._api_base}/event/{self.app_id}")
+        mode = ev.get("data", {}).get("eventMode", 1) if ev and ev.get("code") == 0 else 1
+        body = self._post(f"{self._api_base}/event/update/{self.app_id}", {
+            "operation": "add",
+            "events": ["im.message.receive_v1"],
+            "eventMode": mode,
+        })
+        if not self._ok(body, "添加 im.message.receive_v1", "event"):
+            return False
+        verify = self._get(f"{self._api_base}/event/{self.app_id}")
+        if verify and verify.get("code") == 0:
+            events = verify["data"].get("events", [])
+            if "im.message.receive_v1" in events:
+                _log_success("event", "添加 im.message.receive_v1 成功")
+            else:
+                _log_warn("event", f"事件列表中未找到 im.message.receive_v1: {events}")
+        return True
+
+    def step6_callback_mode(self) -> bool:
+        _log_info("callback", "配置长连接接收回调")
+        deadline = time.time() + WEBSOCKET_POLL_TIMEOUT
+        attempt = 0
+        total = WEBSOCKET_POLL_TIMEOUT // WEBSOCKET_POLL_INTERVAL
+        while time.time() < deadline:
+            attempt += 1
+            body = self._post(f"{self._api_base}/callback/switch/{self.app_id}", {"callbackMode": 4})
+            if body and body.get("code") == 10068:
+                _emit_progress("callback", "等待 WebSocket 连接...",
+                               current=attempt, total=total)
+                time.sleep(WEBSOCKET_POLL_INTERVAL)
+                continue
+            if self._ok(body, "切换回调模式 → 长连接(4)", "callback") is not None:
+                _log_success("callback", "切换回调模式成功")
+                return True
+            return False
+        _log_error("callback", f"等待 WebSocket 连接超时 ({WEBSOCKET_POLL_TIMEOUT}s)")
+        return False
+
+    def step7_permissions(self) -> bool:
+        _log_info("basic_perm", "批量导入权限")
+        body = self._get(f"{self._api_base}/scope/all/{self.app_id}")
+        if not self._ok(body, "获取权限列表", "basic_perm"):
+            return False
+        name_to_id = {}
+        for s in body.get("data", {}).get("scopes", []):
+            name = s.get("name") or s.get("scopeName", "")
+            sid = s.get("id", "")
+            if name and sid:
+                name_to_id[name] = str(sid)
+        ids = [name_to_id[n] for n in BOT_PERMISSIONS if n in name_to_id]
+        missing = [n for n in BOT_PERMISSIONS if n not in name_to_id]
+        _log_info("basic_perm", f"匹配 {len(ids)}/{len(BOT_PERMISSIONS)} 个权限")
+        if missing:
+            _log_warn("basic_perm",
+                      f"{len(missing)} 个权限未匹配: {json.dumps(missing, ensure_ascii=False)}")
+        if not ids:
+            _log_error("basic_perm", "无可用权限 ID")
+            return False
+        payload = {
+            "clientId": self.app_id,
+            "appScopeIDs": ids, "userScopeIDs": [], "scopeIds": [],
+            "operation": "add",
+        }
+        total_attempts = len(PERMISSION_UPDATE_RETRY_DELAYS_SECONDS)
+        for attempt, delay_seconds in enumerate(
+            PERMISSION_UPDATE_RETRY_DELAYS_SECONDS,
+            start=1,
+        ):
+            if delay_seconds > 0:
+                _emit(
+                    "progress",
+                    "warn",
+                    "basic_perm/retry",
+                    f"批量添加权限暂未成功，{delay_seconds}s 后重试 "
+                    f"({attempt}/{total_attempts})",
+                )
+                time.sleep(delay_seconds)
+            body = self._post(
+                f"{self._api_base}/scope/update/{self.app_id}",
+                payload,
+                timeout_ms=PERMISSION_UPDATE_TIMEOUT_MS,
+                log_step="basic_perm",
+            )
+            result = self._ok(
+                body,
+                f"批量添加权限 (第 {attempt}/{total_attempts} 次)",
+                "basic_perm",
+            )
+            if result is not None:
+                _log_success("basic_perm", "批量添加权限成功")
+                return True
+            if body is None:
+                _log_warn(
+                    "basic_perm",
+                    f"第 {attempt}/{total_attempts} 次批量添加权限无响应或超时",
+                )
+        _log_error("basic_perm", f"批量添加权限连续 {total_attempts} 次失败")
+        return False
+
+    def _get_scope_name_to_id(self) -> dict:
+        body = self._get(f"{self._api_base}/scope/all/{self.app_id}")
+        if not self._ok(body, "获取权限列表", "permission"):
+            return {}
+        name_to_id = {}
+        for s in body.get("data", {}).get("scopes", []):
+            name = s.get("name") or s.get("scopeName", "")
+            sid = s.get("id", "")
+            if name and sid:
+                name_to_id[name] = str(sid)
+        return name_to_id
+
+    def step_add_audit_permissions(self) -> dict:
+        result = {"added": False, "need_audit": False, "audit_url": None}
+
+        name_to_id = self._get_scope_name_to_id()
+        if not name_to_id:
+            _log_error("advanced_perm", "获取权限映射表失败")
+            return result
+        ids = [name_to_id[n] for n in BOT_PERMISSIONS_NEED_AUDIT if n in name_to_id]
+        missing = [n for n in BOT_PERMISSIONS_NEED_AUDIT if n not in name_to_id]
+        if missing:
+            _log_warn("advanced_perm", f"高级权限未匹配: {missing}")
+        if not ids:
+            result["added"] = True
+            return result
+
+        body = self._post(f"{self._api_base}/scope/update/{self.app_id}", {
+            "clientId": self.app_id,
+            "appScopeIDs": ids, "userScopeIDs": [], "scopeIds": [],
+            "operation": "add",
+        })
+        if not self._ok(body, "添加高级权限", "permission"):
+            return result
+        result["added"] = True
+
+        audit_url = _pcfg("admin_audit_url")
+
+        _log_info("advanced_perm", "正在发布高级权限...")
+        publish_ok = self.step8_publish(version="1.0.1", silent=True)
+
+        if not publish_ok:
+            _log_error("advanced_perm", "高级权限发布失败")
+            result["need_audit"] = True
+            result["audit_url"] = self.audit_url or audit_url
+            return result
+
+        time.sleep(2)
+
+        info = self._get(f"{self._api_base}/app/{self.app_id}")
+        if info and info.get("code") == 0:
+            data = info.get("data", {})
+            audit_version_id = data.get("auditVersionId")
+            audit_status = data.get("auditStatus")
+
+            is_new_version = (audit_version_id
+                              and str(audit_version_id) == str(self.version_id))
+
+            if is_new_version and audit_status == 100:
+                _log_success("advanced_perm", "高级权限发布成功")
+                result["need_audit"] = False
+            elif is_new_version and audit_status != 100:
+                _log_error("advanced_perm", "免审批发布高级权限失败")
+                result["need_audit"] = True
+                result["audit_url"] = audit_url
+            else:
+                _log_error("advanced_perm", "免审批发布高级权限失败")
+                result["need_audit"] = True
+                result["audit_url"] = audit_url
+        else:
+            _log_error("advanced_perm", "免审批发布高级权限失败")
+            result["need_audit"] = True
+            result["audit_url"] = audit_url
+
+        return result
+
+    def step8_publish(self, version: str = "1.0.0", silent: bool = False) -> bool:
+        self.publish_fail_reason = ""
+        self.audit_url = None
+        admin_audit_url = _pcfg("admin_audit_url")
+        changelog = "Initial version" if PLATFORM == "lark" else "初始版本"
+
+        if not silent:
+            _log_info("publish", "正在发布...")
+        body = self._post(f"{self._api_base}/app_version/create/{self.app_id}", {
+            "clientId": self.app_id, "appVersion": version,
+            "changeLog": changelog, "autoPublish": False,
+            "pcDefaultAbility": "bot", "mobileDefaultAbility": "bot",
+        })
+        if not self._ok(body, "创建版本", "publish"):
+            self.publish_fail_reason = f"创建版本失败: code={(body or {}).get('code')}, msg={(body or {}).get('msg')}"
+            return False
+        self.version_id = body.get("data", {}).get("versionId") or body["data"].get("version_id")
+        if not self.version_id:
+            _log_error("publish", "发布失败")
+            self.publish_fail_reason = "未获取到版本 ID"
+            return False
+
+        time.sleep(1)
+        body = self._post(f"{self._api_base}/publish/commit/{self.app_id}/{self.version_id}", {})
+        if not self._ok(body, "提交审核", "publish"):
+            self.publish_fail_reason = f"提交审核失败: code={(body or {}).get('code')}, msg={(body or {}).get('msg')}"
+            return False
+
+        time.sleep(1)
+        body = self._post(
+            f"{self._api_base}/publish/release/{self.app_id}/{self.version_id}",
+            {"clientId": self.app_id, "versionId": self.version_id})
+        release_code = (body or {}).get("code")
+
+        if release_code == 0:
+            if not silent:
+                _log_success("publish", "基础权限发布成功", version_id=self.version_id)
+            return True
+
+        if release_code == 10002:
+            time.sleep(1)
+            info = self._get(f"{self._api_base}/app/{self.app_id}")
+            if info and info.get("code") == 0:
+                app_status = info.get("data", {}).get("appStatus")
+                if app_status == 1:
+                    if not silent:
+                        _log_success("publish", "基础权限发布成功", version_id=self.version_id)
+                    return True
+                self.audit_url = admin_audit_url
+                _log_error("publish", "免审批发布基础权限失败")
+                self.publish_fail_reason = (
+                    f"需要管理员审批: appStatus={app_status}, "
+                    f"release code={release_code}, msg={body.get('msg')}")
+                return False
+            if not silent:
+                _log_success("publish", "基础权限发布成功", version_id=self.version_id)
+            return True
+
+        if release_code is None:
+            time.sleep(1)
+            info = self._get(f"{self._api_base}/app/{self.app_id}")
+            if info and info.get("code") == 0:
+                app_status = info.get("data", {}).get("appStatus")
+                if app_status == 1:
+                    if not silent:
+                        _log_success("publish", "基础权限发布成功", version_id=self.version_id)
+                    return True
+
+        fail_msg = (body or {}).get("msg", "未知错误")
+        _log_error("publish", f"发布失败: {fail_msg}")
+        self.publish_fail_reason = f"发布失败: code={release_code}, msg={fail_msg}"
+        return False
+
+    def step9_get_owner_open_id(self) -> Optional[str]:
+        _log_info("owner", "获取应用 Owner 的 open_id")
+        if not self.app_id or not self.app_secret:
+            _log_warn("owner", "缺少 app_id 或 app_secret，跳过")
+            return None
+
+        ctx = ssl.create_default_context()
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+
+        payload = json.dumps({
+            "app_id": self.app_id, "app_secret": self.app_secret,
+        }).encode()
+        req = urllib.request.Request(
+            f"{self._base_url}/open-apis/auth/v3/tenant_access_token/internal",
+            data=payload,
+            headers={"Content-Type": "application/json; charset=utf-8"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, context=ctx) as resp:
+                token_data = json.loads(resp.read())
+        except Exception:
+            _log_error("owner", "未获取到 tenant_access_token")
+            return None
+
+        token = token_data.get("tenant_access_token")
+        if not token:
+            _log_error("owner", "未获取到 tenant_access_token")
+            return None
+
+        req2 = urllib.request.Request(
+            f"{self._base_url}/open-apis/contact/v3/users?page_size=50&user_id_type=open_id",
+            headers={
+                "Content-Type": "application/json; charset=utf-8",
+                "Authorization": f"Bearer {token}",
+            },
+            method="GET",
+        )
+        try:
+            with urllib.request.urlopen(req2, context=ctx) as resp:
+                user_data = json.loads(resp.read())
+        except urllib.error.HTTPError:
+            _log_error("owner", "查询用户列表失败")
+            return None
+        except Exception:
+            _log_error("owner", "查询用户列表失败")
+            return None
+
+        items = user_data.get("data", {}).get("items", [])
+        if not items:
+            _log_error("owner", "用户列表为空")
+            return None
+
+        owner = items[0]
+        open_id = owner.get("open_id", "")
+        name = owner.get("name", "未知")
+        self.owner_name = name
+        _log_success("owner", f"用户: {name}, open_id: {open_id}")
+        return open_id
+
+
+# ============================================================
+# Chromium launcher (CDP)
+# ============================================================
+def _get_chromium_path() -> str:
+    from playwright.sync_api import sync_playwright
+    pw = sync_playwright().start()
+    path = pw.chromium.executable_path
+    pw.stop()
+    return path
+
+
+def _launch_detached_chromium() -> int:
+    chrome_path = _get_chromium_path()
+    if not os.path.isfile(chrome_path):
+        raise FileNotFoundError(f"Chromium 不存在: {chrome_path}")
+
+    user_data_dir = os.path.join(STATE_DIR, _pcfg("profile_dir_name"))
+    os.makedirs(user_data_dir, exist_ok=True)
+
+    args = [
+        chrome_path,
+        "--headless=new",
+        f"--remote-debugging-port={CDP_PORT}",
+        f"--user-data-dir={user_data_dir}",
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-gpu",
+        "--disable-extensions",
+        "--disable-background-networking",
+        "--no-sandbox",
+        "about:blank",
+    ]
+
+    proc = subprocess.Popen(
+        args,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True,
+    )
+    return proc.pid
+
+
+def _wait_for_cdp_ready(timeout: int = 15) -> bool:
+    import socket
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            s = socket.create_connection(("127.0.0.1", CDP_PORT), timeout=1)
+            s.close()
+            return True
+        except (ConnectionRefusedError, OSError):
+            time.sleep(0.5)
+    return False
+
+
+def cmd_init():
+    _log_info("init", "检查并安装依赖...")
+    _ensure_dependencies()
+    _log_success("init", "依赖就绪")
+    sys.exit(0)
+
+
+# ============================================================
+# cmd_create
+# ============================================================
+def cmd_create(avatar_url: str = "", greeting: str = "", bot_name_override: str = "",
+               bot_specs: list[dict] | None = None):
+    base_url = _pcfg("base_url")
+    login_url = _pcfg("login_url")
+    open_host = _pcfg("open_host")
+    accounts_host = _pcfg("accounts_host")
+    app_page = f"{base_url}/app"
+    admin_audit_url = _pcfg("admin_audit_url")
+    platform_label = "Lark" if PLATFORM == "lark" else "飞书"
+
+    _log_info("init", "检查并安装依赖...")
+    _ensure_dependencies()
+    _log_success("init", "依赖就绪")
+
+    _log_info("login", "启动浏览器，获取二维码...")
+
+    _kill_cdp_browser()
+    time.sleep(1)
+
+    import shutil
+    profile_dir = os.path.join(STATE_DIR, _pcfg("profile_dir_name"))
+    if os.path.isdir(profile_dir):
+        for _ in range(3):
+            try:
+                shutil.rmtree(profile_dir)
+                break
+            except OSError:
+                time.sleep(0.5)
+
+    chrome_pid = _launch_detached_chromium()
+
+    if not _wait_for_cdp_ready(timeout=20):
+        try:
+            os.kill(chrome_pid, signal.SIGKILL)
+        except OSError:
+            pass
+        _emit_error("login", "Chromium 启动超时")
+        sys.exit(1)
+
+    from playwright.sync_api import sync_playwright
+
+    pw = sync_playwright().start()
+    try:
+        browser = pw.chromium.connect_over_cdp(f"http://127.0.0.1:{CDP_PORT}")
+    except Exception as e:
+        pw.stop()
+        try:
+            os.kill(chrome_pid, signal.SIGKILL)
+        except OSError:
+            pass
+        _emit_error("login", f"连接 Chromium 失败: {e}")
+        sys.exit(1)
+
+    if PLATFORM == "lark":
+        ctx = browser.new_context(
+            user_agent=(
+                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/120.0.0.0 Safari/537.36"
+            ),
+            viewport={"width": 1280, "height": 800},
+        )
+        page = ctx.new_page()
+    else:
+        contexts = browser.contexts
+        if not contexts or not contexts[0].pages:
+            page = browser.new_context().new_page()
+        else:
+            page = contexts[0].pages[0]
+
+    state = {"qr_token": None}
+
+    def _on_response(resp):
+        try:
+            if "qrlogin/init" in resp.url:
+                body = resp.json()
+                if body.get("code") == 0:
+                    state["qr_token"] = body["data"]["step_info"]["token"]
+        except Exception:
+            pass
+
+    page.on("response", _on_response)
+
+    def _switch_to_qr_mode():
+        try:
+            page.wait_for_timeout(2000)
+            page.evaluate("""() => {
+                const el = document.querySelector('.switch-login-mode-box');
+                if (el) el.dispatchEvent(new MouseEvent('click', {bubbles: true, cancelable: true}));
+            }""")
+            page.wait_for_timeout(1500)
+        except Exception:
+            pass
+
+    def _fetch_qr_token() -> bool:
+        state["qr_token"] = None
+        try:
+            page.goto(login_url, wait_until="domcontentloaded", timeout=30000)
+        except Exception:
+            try:
+                page.goto(login_url, wait_until="commit", timeout=30000)
+            except Exception:
+                return False
+        if not _pcfg("qr_default"):
+            _switch_to_qr_mode()
+        for _ in range(25):
+            if state["qr_token"]:
+                return True
+            page.wait_for_timeout(100)
+        try:
+            page.reload(wait_until="domcontentloaded", timeout=30000)
+        except Exception:
+            try:
+                page.goto(login_url, wait_until="domcontentloaded", timeout=30000)
+            except Exception:
+                return False
+        if not _pcfg("qr_default"):
+            _switch_to_qr_mode()
+        for _ in range(25):
+            if state["qr_token"]:
+                return True
+            page.wait_for_timeout(200)
+        return False
+
+    def _poll_qr_login() -> bool:
+        login_state = {"login_ok": False, "scanned": False}
+
+        def _on_poll_response(resp):
+            try:
+                if "qrlogin/polling" in resp.url:
+                    body = resp.json()
+                    if body.get("code") != 0:
+                        return
+                    data = body.get("data", {})
+                    info = data.get("step_info", {})
+                    status = info.get("status")
+                    redirect_url = data.get("redirect_url", "")
+                    if status == 2 and not login_state["scanned"]:
+                        login_state["scanned"] = True
+                        _log_info("login", "已扫码，请在手机上点击确认")
+                    if redirect_url:
+                        login_state["login_ok"] = True
+            except Exception:
+                pass
+
+        page.on("response", _on_poll_response)
+
+        poll_deadline = time.time() + LOGIN_TIMEOUT
+        while time.time() < poll_deadline:
+            if login_state["login_ok"]:
+                break
+            if login_state["scanned"]:
+                try:
+                    current_url = page.url
+                    if open_host in current_url and accounts_host not in current_url:
+                        login_state["login_ok"] = True
+                        break
+                except Exception:
+                    pass
+            try:
+                page.wait_for_timeout(500)
+            except Exception:
+                pass
+
+        page.remove_listener("response", _on_poll_response)
+        return login_state["login_ok"]
+
+    for attempt in range(1, QR_MAX_RETRIES + 1):
+        if not _fetch_qr_token():
+            if attempt < QR_MAX_RETRIES:
+                _log_warn("login", f"未能获取二维码 token，正在重试 ({attempt}/{QR_MAX_RETRIES})")
+                time.sleep(2)
+                continue
+            pw.stop()
+            try:
+                os.kill(chrome_pid, signal.SIGKILL)
+            except OSError:
+                pass
+            _emit_error("login", "未能获取二维码 token")
+            sys.exit(1)
+
+        qr_content = {"qrlogin": {"token": state["qr_token"]}}
+
+        _save_state({
+            "phase": "create",
+            "qr_token": state["qr_token"],
+            "qr_content": json.dumps(qr_content),
+            "deadline": int(time.time()) + LOGIN_TIMEOUT,
+            "cdp_url": f"http://127.0.0.1:{CDP_PORT}",
+            "chrome_pid": chrome_pid,
+        })
+
+        _emit("show_qrcode", "info", "login", f"请扫码登录{platform_label}",
+              content=json.dumps(qr_content, ensure_ascii=False))
+
+        _emit_progress("login", "等待扫码登录...",
+                       current=attempt, total=QR_MAX_RETRIES)
+
+        if _poll_qr_login():
+            break
+
+        if attempt < QR_MAX_RETRIES:
+            _log_warn("login", f"二维码已过期，正在刷新 ({attempt}/{QR_MAX_RETRIES})")
+            try:
+                page.wait_for_load_state("domcontentloaded", timeout=5000)
+            except Exception:
+                pass
+            time.sleep(1)
+        else:
+            _kill_cdp_browser()
+            pw.stop()
+            _emit_error("login", f"{QR_MAX_RETRIES} 次超时未扫码，退出")
+            sys.exit(1)
+
+    _log_info("login", "页面已跳转到开放平台，登录成功")
+    jump_deadline = time.time() + 15
+    while time.time() < jump_deadline:
+        current_url = page.url
+        if open_host in current_url and accounts_host not in current_url:
+            break
+        page.wait_for_timeout(500)
+    else:
+        page.goto(app_page, wait_until="domcontentloaded", timeout=30000)
+
+    _log_success("login", "扫码登录成功!")
+    page.wait_for_timeout(2000)
+
+    # Normalize bot_specs. If the caller passed a single bot_name_override
+    # (legacy path) wrap it in a one-element spec list. Otherwise expect a
+    # list of {name?, account_id?} dicts and create them in order with the
+    # same login session.
+    if bot_specs:
+        specs = list(bot_specs)
+    else:
+        specs = [{"name": bot_name_override, "account_id": OPENCLAW_ACCOUNT_ID}]
+    if not specs:
+        _emit_error("config", "no bot specs provided")
+        sys.exit(1)
+
+    avatar_path = _download_avatar(avatar_url)
+    all_results: list[dict] = []
+    created_account_ids: list[str] = []
+    any_audit = False
+
+    for idx, spec in enumerate(specs, start=1):
+        spec_name = (spec.get("name") or "").strip() or _gen_bot_name()
+        spec_account_id = (spec.get("account_id") or "").strip() or f"agent-{idx}"
+        total = len(specs)
+
+        _emit_progress("bot", f"开始创建第 {idx}/{total} 个机器人：{spec_name}",
+                       current=idx, total=total)
+
+        result = _create_one_bot(
+            page=page,
+            base_url=base_url,
+            app_page=app_page,
+            admin_audit_url=admin_audit_url,
+            platform_label=platform_label,
+            avatar_path=avatar_path,
+            greeting=greeting,
+            bot_name=spec_name,
+            account_id=spec_account_id,
+        )
+        if result.get("status") != "ok":
+            _cleanup_openclaw_feishu_accounts(
+                [*created_account_ids, spec_account_id])
+            _kill_cdp_browser(); pw.stop()
+            err_step, err_msg = result.get("error", ("create_app", "创建失败"))
+            _emit_error(err_step, err_msg)
+            sys.exit(1)
+
+        all_results.append(result["bot"])
+        created_account_ids.append(result["bot"].get("account_id") or spec_account_id)
+        if result["bot"].get("audit_url"):
+            any_audit = True
+
+    _kill_cdp_browser()
+    pw.stop()
+
+    if len(all_results) == 1:
+        # Single-bot path keeps the old data shape so existing
+        # subscribers that read data.app_id / data.bot_name still work.
+        result = all_results[0]
+        finish_msg_lines = [
+            f"✅ 机器人「{result['bot_name']}」已创建并发布"
+            + ("，可正常使用。" if result.get("audit_url") else "，所有权限已生效。"),
+            f"管理地址：{result.get('manage_url', '')}",
+        ]
+        if any_audit:
+            finish_msg_lines += [
+                "",
+                "⚠️ 以下高级权限无法免审批发布，已自动为您提交申请：",
+                "   · 查看、评论和下载云空间中所有文件",
+                "   · 查看、评论、编辑和管理云空间中所有文件",
+                f"如需启用，请联系管理员前往审批：{result.get('audit_url', '')}",
+            ]
+        _save_state({"phase": "done", **result})
+        _emit_finish("\n".join(finish_msg_lines), result)
+        return
+
+    team_group = None
+    try:
+        team_group = _create_team_group(all_results)
+    except Exception as e:
+        _log_warn("team_group", f"飞书团队群创建失败: {e}")
+        _emit("progress", "warn", "team_group/error",
+              f"飞书团队群创建失败: {e}")
+
+    # Multi-bot (team) path: aggregate.
+    team_data = {
+        "bots": all_results,
+        "team_group": team_group,
+        # Convenience fields: pin the first bot (controller) at the top
+        # level so older readers still see *something* useful — they'll
+        # treat the team as a single bot keyed on the controller.
+        "app_id": all_results[0].get("app_id"),
+        "app_secret": all_results[0].get("app_secret"),
+        "bot_name": all_results[0].get("bot_name"),
+        "open_id": all_results[0].get("open_id"),
+        "account_id": all_results[0].get("account_id"),
+        "manage_url": all_results[0].get("manage_url"),
+    }
+    summary_lines = [
+        f"✅ 团队 {len(all_results)} 个机器人已创建并发布：",
+    ]
+    for r in all_results:
+        summary_lines.append(
+            f"   · 「{r.get('bot_name')}」(account={r.get('account_id')}, app_id={r.get('app_id')})"
+        )
+    if team_group:
+        summary_lines.append(
+            f"   · 飞书群「{team_group.get('name')}」(chat_id={team_group.get('chat_id')})"
+        )
+        member_errors = team_group.get("member_errors") or []
+        if member_errors:
+            summary_lines += [
+                "",
+                f"⚠️ 飞书群已创建，但 {len(member_errors)} 个协作机器人未拉入群：",
+                *[f"   · {item}" for item in member_errors],
+            ]
+    if any_audit:
+        summary_lines += [
+            "",
+            "⚠️ 部分高级权限需审批，详见各机器人审批地址。",
+        ]
+    if not team_group:
+        summary_lines += [
+            "",
+            "⚠️ 飞书团队群未创建成功，请查看上方 team_group 日志。",
+        ]
+    _save_state({"phase": "done", **team_data})
+    _emit_finish("\n".join(summary_lines), team_data)
+
+
+def _create_one_bot(*, page, base_url: str, app_page: str, admin_audit_url: str,
+                    platform_label: str, avatar_path: str, greeting: str,
+                    bot_name: str, account_id: str) -> dict:
+    """Run the per-bot pipeline (step1..step9) using a logged-in page.
+    Returns either {"status": "ok", "bot": {...}} or
+    {"status": "error", "error": (step, message)}.
+    """
+    bot_desc = bot_name
+    creator = FeishuBotCreator(page)
+    creator.install_network_capture()
+
+    page.goto(app_page, wait_until="domcontentloaded", timeout=30000)
+    page.wait_for_timeout(2000)
+    csrf = creator._csrf()
+    _log_info("create_app", f"CSRF token: {'获取成功' if csrf else '未获取，继续尝试'}")
+
+    if not creator.step1_create_app(bot_name, bot_desc, avatar_path):
+        return {"status": "error", "error": ("create_app", "创建应用失败")}
+
+    if not creator.step2_get_credentials():
+        return {"status": "error", "error": ("credential", "获取凭证失败")}
+
+    _emit("write_config", "info", "config", "写入 openclaw.json，等待服务建立长连接",
+          path=OPENCLAW_CONFIG, account_id=account_id)
+    if not _write_openclaw_config(creator.app_id, creator.app_secret, account_id):
+        return {"status": "error", "error": ("config", "写入 openclaw 配置失败")}
+
+    _log_info("config", "等待服务读取配置...")
+    time.sleep(2)
+
+    _step_error_messages = {
+        "step3_add_bot": ("bot_ability", "开启机器人能力失败"),
+        "step4_event_mode": ("event_mode", "建立长链接失败，请检查 gateway 是否启动"),
+        "step5_add_event": ("event", "添加「接收消息」事件失败"),
+        "step6_callback_mode": ("callback", "配置长连接回调失败，请检查 gateway 是否启动"),
+        "step7_permissions": ("basic_perm", "批量导入权限失败"),
+    }
+    for fn in [
+        creator.step3_add_bot,
+        creator.step4_event_mode,
+        creator.step5_add_event,
+        creator.step6_callback_mode,
+        creator.step7_permissions,
+    ]:
+        if not fn():
+            step_name = fn.__name__
+            err_step, err_msg = _step_error_messages.get(
+                step_name, (step_name, f"{step_name} 失败")
+            )
+            return {"status": "error", "error": (err_step, err_msg)}
+
+    manage_url = f"{base_url}/app/{creator.app_id}"
+    publish_ok = creator.step8_publish()
+    if not publish_ok:
+        fail_reason = getattr(creator, 'publish_fail_reason', '') or '发布失败'
+        audit_url = getattr(creator, 'audit_url', None) or admin_audit_url
+        return {
+            "status": "error",
+            "error": (
+                "publish",
+                (
+                    f"当前用户权限无法免审批发布{platform_label}机器人「{bot_name}」，"
+                    f"请联系管理员审批后再用。审批地址：{audit_url}"
+                ),
+            ),
+        }
+
+    _log_info("advanced_perm", "正在添加高级权限...")
+    audit_result = creator.step_add_audit_permissions()
+
+    open_id = creator.step9_get_owner_open_id()
+    if open_id:
+        _write_allow_from(open_id, account_id)
+        _send_greeting(creator.app_id, creator.app_secret, open_id, greeting)
+    else:
+        _log_warn("owner", "未获取到 open_id，跳过 allowFrom 写入")
+
+    bot_result = {
+        "app_id": creator.app_id,
+        "app_secret": creator.app_secret,
+        "bot_name": bot_name,
+        "version_id": creator.version_id,
+        "open_id": open_id,
+        "owner_name": creator.owner_name,
+        "account_id": account_id,
+        "manage_url": manage_url,
+    }
+    if audit_result.get("need_audit"):
+        bot_result["audit_url"] = audit_result.get("audit_url") or admin_audit_url
+        bot_result["audit_permissions"] = BOT_PERMISSIONS_NEED_AUDIT
+
+    return {"status": "ok", "bot": bot_result}
+
+
+def cmd_cleanup():
+    _kill_cdp_browser()
+    sf = _state_file()
+    if os.path.isfile(sf):
+        os.remove(sf)
+    _log_success("cleanup", "已清理")
+
+
+def main():
+    global PLATFORM
+
+    if len(sys.argv) < 2 or sys.argv[1] in ("-h", "--help", "help"):
+        sys.exit(0)
+
+    cmd = sys.argv[1]
+
+    if cmd == "init":
+        cmd_init()
+    elif cmd == "create":
+        avatar_url = ""
+        greeting = ""
+        bot_name_override = ""
+        bot_specs: list[dict] | None = None
+        args = sys.argv[2:]
+        i = 0
+        while i < len(args):
+            if args[i] == "--avatar-url" and i + 1 < len(args):
+                avatar_url = args[i + 1]
+                i += 2
+            elif args[i] == "--greeting" and i + 1 < len(args):
+                greeting = args[i + 1]
+                i += 2
+            elif args[i] == "--bot-name" and i + 1 < len(args):
+                bot_name_override = args[i + 1]
+                i += 2
+            elif args[i] == "--bots-json" and i + 1 < len(args):
+                try:
+                    parsed = json.loads(args[i + 1])
+                except json.JSONDecodeError as e:
+                    _emit_error("main", f"--bots-json 解析失败: {e}")
+                    sys.exit(1)
+                if not isinstance(parsed, list) or not parsed:
+                    _emit_error("main", "--bots-json 必须是非空数组")
+                    sys.exit(1)
+                bot_specs = parsed
+                i += 2
+            elif args[i] == "--platform" and i + 1 < len(args):
+                p = args[i + 1].lower()
+                if p not in ("feishu", "lark"):
+                    _emit_error("main", f"不支持的平台: {p}，请使用 feishu 或 lark")
+                    sys.exit(1)
+                PLATFORM = p
+                i += 2
+            else:
+                i += 1
+        cmd_create(avatar_url=avatar_url, greeting=greeting,
+                   bot_name_override=bot_name_override,
+                   bot_specs=bot_specs)
+    elif cmd == "cleanup":
+        args = sys.argv[2:]
+        i = 0
+        while i < len(args):
+            if args[i] == "--platform" and i + 1 < len(args):
+                p = args[i + 1].lower()
+                if p in ("feishu", "lark"):
+                    PLATFORM = p
+                i += 2
+            else:
+                i += 1
+        cmd_cleanup()
+    else:
+        _emit_error("main", f"未知命令: {cmd}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()