import sys import json import logging import os import re import sqlite3 from logging.handlers import TimedRotatingFileHandler from urllib.parse import urlparse import shutil import subprocess import tempfile import time from datetime import datetime from typing import Optional # Windows GBK 编码兼容修复 if sys.platform == "win32": import io sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace") sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace") BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) SKILL_SLUG = "account-manager" # 与其它 OpenClaw 技能对齐：openclaw.skill. LOG_LOGGER_NAME = "openclaw.skill.account_manager" # --------------------------------------------------------------------------- # 本地 CLI 调试：直接运行 python main.py 时，若未设置 JIANGCHANG_*，可自动注入下面默认值。 # - 仅当 __main__ 里调用了 _apply_cli_local_dev_env() 时生效；被其它脚本 import 不会改 os.environ。 # - 不会覆盖宿主/终端已设置的 JIANGCHANG_DATA_ROOT、JIANGCHANG_USER_ID。 # - 开启方式（二选一）： # 1) 将 _ACCOUNT_MANAGER_CLI_LOCAL_DEV 改为 True； # 2) 或设置环境变量 JIANGCHANG_ACCOUNT_CLI_LOCAL_DEV=1（无需改代码）。 # 合并/发版前请关闭开关，避免把个人机器路径带进生产制品。 # --------------------------------------------------------------------------- _ACCOUNT_MANAGER_CLI_LOCAL_DEV = True _ACCOUNT_MANAGER_CLI_LOCAL_DATA_ROOT = r"D:\jiangchang-data" _ACCOUNT_MANAGER_CLI_LOCAL_USER_ID = "10032" def _apply_cli_local_dev_env() -> None: enabled = _ACCOUNT_MANAGER_CLI_LOCAL_DEV if not enabled: v = (os.getenv("JIANGCHANG_ACCOUNT_CLI_LOCAL_DEV") or "").strip().lower() enabled = v in ("1", "true", "yes", "on") if not enabled: return if not (os.getenv("JIANGCHANG_DATA_ROOT") or "").strip(): os.environ["JIANGCHANG_DATA_ROOT"] = _ACCOUNT_MANAGER_CLI_LOCAL_DATA_ROOT.strip() if not (os.getenv("JIANGCHANG_USER_ID") or "").strip(): os.environ["JIANGCHANG_USER_ID"] = _ACCOUNT_MANAGER_CLI_LOCAL_USER_ID.strip() # SQLite 无独立 DATETIME 类型：时间统一存 INTEGER Unix 秒（UTC），查询/JSON 再转 ISO8601。 # 下列 DDL 含注释，会原样写入 sqlite_master，便于 Navicat / DBeaver 等查看建表语句。 ACCOUNTS_TABLE_SQL = """ /* 多平台账号表：与本地 Chromium/Edge 用户数据目录（profile）绑定，供发布类技能读取登录态 */ CREATE TABLE accounts ( id INTEGER PRIMARY KEY AUTOINCREMENT, -- 账号主键（自增） name TEXT NOT NULL, -- 展示名称，如「搜狐1号」 platform TEXT NOT NULL, -- 平台标识，与内置 PLATFORMS 键一致，如 sohu phone TEXT, -- 可选绑定手机号 profile_dir TEXT, -- Playwright 用户数据目录（绝对路径）；默认可读结构 profiles/<平台展示名>/<手机号>/ url TEXT, -- 平台入口或登录页 URL login_status INTEGER NOT NULL DEFAULT 0, -- 是否已登录：0 否 1 是（由脚本校验后写入） last_login_at INTEGER, -- 最近一次登录成功时间，Unix 秒 UTC；未登录过为 NULL extra_json TEXT, -- 扩展字段 JSON created_at INTEGER NOT NULL, -- 记录创建时间，Unix 秒 UTC updated_at INTEGER NOT NULL -- 记录最后更新时间，Unix 秒 UTC ); """ def _now_unix() -> int: return int(time.time()) def _unix_to_iso_local(ts: Optional[int]) -> Optional[str]: """对外 JSON：本地时区 ISO8601 字符串，便于人读。""" if ts is None: return None try: return datetime.fromtimestamp(int(ts)).isoformat(timespec="seconds") except (ValueError, OSError, OverflowError): return None # 平台唯一配置表：只改这里即可。键 = 入库的 platform；label = 帮助/提示里的展示名； # prefix = 默认账号名「{prefix}{序号}号」，省略时等于 label； # aliases = 额外 CLI 称呼（英文键与 label 已自动参与解析，不必重复写）。 # 登录检测：仅看页面 DOM。匹配 anchor 的标签页上出现「未登录」选择器则未登录；否则视为已登录。 # - _LOGIN_LOGGED_OUT_DOM_GENERIC_SELECTORS：通用「登录」按钮/链接等（可被 login_skip_generic_logged_out_dom 关闭）。 # - login_logged_out_selectors：按平台追加；误判时也可用 login_skip_generic_logged_out_dom + 仅平台自选。 PLATFORMS = { "sohu": { "url": "https://mp.sohu.com", "label": "搜狐号", "prefix": "搜狐", "aliases": ["搜狐"], }, "toutiao": { "url": "https://mp.toutiao.com/", "label": "头条号", "prefix": "头条", "aliases": ["头条"], }, "zhihu": { "url": "https://www.zhihu.com", "label": "知乎", "aliases": ["知乎号"], }, "wechat": { "url": "https://mp.weixin.qq.com", "label": "微信公众号", "prefix": "微信", "aliases": ["公众号", "微信"], }, "kimi": { "url": "https://kimi.moonshot.cn", "label": "Kimi", "aliases": ["月之暗面"], }, "deepseek": { "url": "https://chat.deepseek.com", "label": "DeepSeek", }, "doubao": { "url": "https://www.doubao.com", "label": "豆包", }, "qianwen": { "url": "https://tongyi.aliyun.com", "label": "通义千问", "prefix": "通义", "aliases": ["通义", "千问"], }, "yiyan": { "url": "https://yiyan.baidu.com", "label": "文心一言", "prefix": "文心", "aliases": ["文心", "一言"], }, "yuanbao": { "url": "https://yuanbao.tencent.com", "label": "腾讯元宝", "prefix": "元宝", "aliases": ["元宝"], }, } # 未登录页共性：主行动点含「登录」——submit 按钮、Element 主按钮、Semi 文案、标题、通栏主按钮等，Playwright :has-text 可覆盖多数站点。 _LOGIN_LOGGED_OUT_DOM_GENERIC_SELECTORS = ( 'button:has-text("登录")', 'role=button[name="登录"]', 'a:has-text("登录")', 'h4:has-text("登录")', 'span.semi-button-content:has-text("登录")', ) def _build_platform_derived(): urls = {} name_prefix = {} primary_cn = {} alias_to_key = {} def _register_alias(alias: str, key: str) -> None: if not alias or not str(alias).strip(): return a = str(alias).strip() if a not in alias_to_key: alias_to_key[a] = key lo = a.lower() if lo not in alias_to_key: alias_to_key[lo] = key for key, spec in PLATFORMS.items(): urls[key] = spec["url"] primary_cn[key] = spec["label"] name_prefix[key] = (spec.get("prefix") or spec["label"]).strip() or key _register_alias(key, key) _register_alias(spec["label"], key) for a in spec.get("aliases") or []: _register_alias(a, key) return urls, name_prefix, primary_cn, alias_to_key PLATFORM_URLS, _PLATFORM_NAME_CN, _PLATFORM_PRIMARY_CN, _PLATFORM_ALIAS_TO_KEY = _build_platform_derived() def resolve_platform_key(name: str): """将用户输入解析为内部 platform 键；无法识别返回 None。""" if name is None: return None s = str(name).strip() if not s: return None sl = s.lower() if sl in PLATFORM_URLS: return sl return _PLATFORM_ALIAS_TO_KEY.get(s) def _normalize_phone_digits(phone: str) -> str: """从输入中提取数字串，供号段规则校验与入库去重（不对外承诺可随意夹杂符号）。""" d = re.sub(r"\D", "", (phone or "").strip()) if d.startswith("86") and len(d) >= 13: d = d[2:] return d def _is_valid_cn_mobile11(digits: str) -> bool: """中国大陆 11 位手机号：1 开头，第二位 3–9，共 11 位数字。""" return bool(re.fullmatch(r"1[3-9]\d{9}", digits or "")) def _platform_list_cn_for_help() -> str: """帮助文案：一行中文展示名（不重复内部键）。""" parts = [] for k in sorted(PLATFORM_URLS.keys()): parts.append(_PLATFORM_PRIMARY_CN.get(k, k)) return "、".join(parts) def get_data_root(): env = (os.getenv("JIANGCHANG_DATA_ROOT") or "").strip() if env: return env if sys.platform == "win32": return r"D:\jiangchang-data" return os.path.join(os.path.expanduser("~"), ".jiangchang-data") def get_user_id(): uid = (os.getenv("JIANGCHANG_USER_ID") or "").strip() return uid or "_anon" def get_skill_data_dir(): path = os.path.join(get_data_root(), get_user_id(), SKILL_SLUG) os.makedirs(path, exist_ok=True) return path def get_skill_logs_dir() -> str: """{DATA_ROOT}/{USER_ID}/account-manager/logs/""" path = os.path.join(get_skill_data_dir(), "logs") os.makedirs(path, exist_ok=True) return path def get_skill_log_file_path() -> str: """主日志文件绝对路径（与 get_skill_logger 写入文件一致）。""" return _skill_log_file_path() def _skill_log_file_path() -> str: """主日志文件路径；可由 JIANGCHANG_ACCOUNT_MANAGER_LOG_FILE 覆盖为绝对路径。""" override = (os.getenv("JIANGCHANG_ACCOUNT_MANAGER_LOG_FILE") or "").strip() if override: parent = os.path.dirname(os.path.abspath(override)) if parent: os.makedirs(parent, exist_ok=True) return os.path.abspath(override) return os.path.join(get_skill_logs_dir(), f"{SKILL_SLUG}.log") def _log_level_from_env() -> int: v = (os.getenv("JIANGCHANG_LOG_LEVEL") or "INFO").strip().upper() return getattr(logging, v, None) or logging.INFO def get_skill_logger() -> logging.Logger: """ 技能级日志：单文件按日切分（TimedRotatingFileHandler midnight），UTF-8。 环境变量：JIANGCHANG_LOG_LEVEL（默认 INFO）、JIANGCHANG_LOG_TO_STDERR=1 时 WARNING+ 同步 stderr、 JIANGCHANG_ACCOUNT_MANAGER_LOG_FILE 覆盖日志文件路径。 """ log = logging.getLogger(LOG_LOGGER_NAME) if log.handlers: return log log.setLevel(_log_level_from_env()) path = _skill_log_file_path() fh = TimedRotatingFileHandler( path, when="midnight", interval=1, backupCount=30, encoding="utf-8", delay=True, ) fh.setFormatter( logging.Formatter( "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s", datefmt="%Y-%m-%dT%H:%M:%S", ) ) log.addHandler(fh) if (os.getenv("JIANGCHANG_LOG_TO_STDERR") or "").strip().lower() in ( "1", "true", "yes", "on", ): sh = logging.StreamHandler(sys.stderr) sh.setLevel(logging.WARNING) sh.setFormatter(fh.formatter) log.addHandler(sh) log.propagate = False return log def get_db_path(): return os.path.join(get_skill_data_dir(), "account-manager.db") def _runtime_paths_debug_text(): """供排查「为何 list 没数据」：终端未注入环境变量时会落到 _anon 等默认目录，与网关里用的库不是同一个文件。""" env_root = (os.getenv("JIANGCHANG_DATA_ROOT") or "").strip() or "(未设置)" env_uid = (os.getenv("JIANGCHANG_USER_ID") or "").strip() or "(未设置→使用 _anon)" return ( "[account-manager] " f"JIANGCHANG_DATA_ROOT={env_root} | " f"JIANGCHANG_USER_ID={env_uid} | " f"实际数据根={get_data_root()} | " f"实际用户目录={get_user_id()} | " f"数据库文件={get_db_path()}" ) def _maybe_print_paths_debug_cli(): """设置 JIANGCHANG_ACCOUNT_DEBUG_PATHS=1 时，每次执行子命令前在 stderr 打印路径。""" v = (os.getenv("JIANGCHANG_ACCOUNT_DEBUG_PATHS") or "").strip().lower() if v in ("1", "true", "yes", "on"): print(_runtime_paths_debug_text(), file=sys.stderr) _WIN_FS_FORBIDDEN = re.compile(r'[<>:"/\\|?*\x00-\x1f]') _WIN_RESERVED_NAMES = frozenset( ["CON", "PRN", "AUX", "NUL"] + [f"COM{i}" for i in range(1, 10)] + [f"LPT{i}" for i in range(1, 10)] ) def _fs_safe_segment(name: str, fallback: str) -> str: """单级目录名：去掉 Windows 非法字符，避免末尾点/空格；空则用 fallback。""" t = _WIN_FS_FORBIDDEN.sub("_", (name or "").strip()) t = t.rstrip(" .") if not t: t = fallback if t.upper() in _WIN_RESERVED_NAMES: t = f"_{t}" return t def get_default_profile_dir( platform_key: str, phone: Optional[str], account_id: Optional[int] = None ) -> str: """ 默认可读路径：profiles/<平台展示名>/<手机号>/（便于在资源管理器中辨认）。 无手机号时退化为 profiles/<平台展示名>/no_phone_/。 """ label = _PLATFORM_PRIMARY_CN.get(platform_key, platform_key or "account") label_seg = _fs_safe_segment(label, _fs_safe_segment(platform_key or "", "platform")) ph = (phone or "").strip() if ph: phone_seg = _fs_safe_segment(ph, f"id_{account_id}" if account_id is not None else "phone") else: phone_seg = _fs_safe_segment( "", f"no_phone_{account_id}" if account_id is not None else "no_phone" ) path = os.path.join(get_skill_data_dir(), "profiles", label_seg, phone_seg) os.makedirs(path, exist_ok=True) return path def get_conn(): return sqlite3.connect(get_db_path()) def init_db(): conn = get_conn() try: cur = conn.cursor() cur.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='accounts'") if not cur.fetchone(): cur.executescript(ACCOUNTS_TABLE_SQL) conn.commit() finally: conn.close() def _normalize_account_id(account_id): if account_id is None: return None s = str(account_id).strip() if s.isdigit(): return int(s) return s def get_account_by_id(account_id): init_db() aid = _normalize_account_id(account_id) conn = get_conn() try: cur = conn.cursor() cur.execute( """ SELECT id, name, platform, phone, profile_dir, url, login_status, last_login_at, extra_json, created_at, updated_at FROM accounts WHERE id = ? """, (aid,), ) row = cur.fetchone() if not row: return None acc = { "id": row[0], "name": row[1], "platform": row[2], "phone": row[3] or "", "profile_dir": (row[4] or "").strip(), "url": row[5] or PLATFORM_URLS.get(row[2], ""), "login_status": int(row[6] or 0), "last_login_at": _unix_to_iso_local(row[7]), "created_at": _unix_to_iso_local(row[9]), "updated_at": _unix_to_iso_local(row[10]), } if row[8]: try: extra = json.loads(row[8]) if isinstance(extra, dict): acc.update(extra) except Exception: pass return acc finally: conn.close() def _default_name_for_platform(platform: str, index: int) -> str: cn = _PLATFORM_NAME_CN.get(platform) if cn: return f"{cn}{index}号" return f"{platform}_{index}" # list 表头：与 accounts 表列顺序、列名一致（便于对照库结构） _LIST_TABLE_COLUMNS = ( "id", "name", "platform", "phone", "profile_dir", "url", "login_status", "last_login_at", "extra_json", "created_at", "updated_at", ) def _list_row_to_cells(row: tuple) -> list: """将 SELECT 整行转为展示用字符串列表（与 _LIST_TABLE_COLUMNS 顺序一致）。""" rid, name, plat, phone, pdir, url, lstat, lla, exj, cat, uat = row return [ str(rid) if rid is not None else "", name if name is not None else "", plat if plat is not None else "", phone if phone is not None else "", pdir if pdir is not None else "", url if url is not None else "", str(int(lstat)) if lstat is not None else "", str(int(lla)) if lla is not None else "", (exj or "").replace("\n", "\\n").replace("\r", ""), str(int(cat)) if cat is not None else "", str(int(uat)) if uat is not None else "", ] def _print_accounts_table(rows: list) -> None: """表头 + 分隔线 + 每账号一行；列宽按内容对齐（终端等宽字体）。""" headers = list(_LIST_TABLE_COLUMNS) body = [_list_row_to_cells(r) for r in rows] n = len(headers) widths = [len(headers[j]) for j in range(n)] for cells in body: for j in range(n): widths[j] = max(widths[j], len(cells[j])) sep = " | " def fmt(cells): return sep.join(cells[j].ljust(widths[j]) for j in range(n)) print(fmt(headers)) print(sep.join("-" * widths[j] for j in range(n))) for cells in body: print(fmt(cells)) def cmd_list(platform="all", limit: int = 10): get_skill_logger().info("list filter=%r", platform) init_db() raw = (platform or "all").strip() if not raw or raw.lower() == "all" or raw == "全部": key = "all" else: key = resolve_platform_key(raw) if not key: get_skill_logger().warning("list_invalid_platform raw=%r", raw) print(f"ERROR:INVALID_PLATFORM_LIST 无法识别的平台「{raw}」") print("支持：" + _platform_list_cn_for_help()) return if limit <= 0: limit = 10 conn = get_conn() try: cur = conn.cursor() sql = ( "SELECT id, name, platform, phone, profile_dir, url, login_status, " "last_login_at, extra_json, created_at, updated_at FROM accounts " ) if key == "all": cur.execute(sql + "ORDER BY created_at DESC, id DESC LIMIT ?", (int(limit),)) else: cur.execute( sql + "WHERE platform = ? ORDER BY created_at DESC, id DESC LIMIT ?", (key, int(limit)), ) rows = cur.fetchall() finally: conn.close() found = bool(rows) if found: get_skill_logger().info("list_ok rows=%s key=%s", len(rows), key) sep_line = "_" * 39 for idx, row in enumerate(rows): ( aid, name, plat, phone, profile_dir, url, login_status, last_login_at, extra_json, created_at, updated_at, ) = row print(f"id：{aid}") print(f"name：{name or ''}") print(f"platform：{plat or ''}") print(f"phone：{phone or ''}") print(f"profile_dir：{profile_dir or ''}") print(f"url：{url or ''}") print(f"login_status：{int(login_status) if login_status is not None else ''}") print(f"last_login_at：{int(last_login_at) if last_login_at is not None else ''}") print(f"extra_json：{extra_json or ''}") print(f"created_at：{int(created_at) if created_at is not None else ''}") print(f"updated_at：{int(updated_at) if updated_at is not None else ''}") if idx != len(rows) - 1: print(sep_line) print() if not found: print("ERROR:NO_ACCOUNTS_FOUND") print(_runtime_paths_debug_text(), file=sys.stderr) def cmd_get(account_id): get_skill_logger().info("get account_id=%r", account_id) acc = get_account_by_id(account_id) if acc: print(json.dumps(acc, ensure_ascii=False)) return get_skill_logger().warning("get_not_found account_id=%r", account_id) print("ERROR:ACCOUNT_NOT_FOUND") print(_runtime_paths_debug_text(), file=sys.stderr) def cmd_pick_logged_in(platform_input: str): """ 机器可读跨技能接口：查询指定平台下「已登录」的一条账号（login_status=1，按 last_login_at 优先）。 成功：stdout 仅输出一行 JSON，结构与 get 子命令一致。 失败：stdout 首行以 ERROR: 开头（由调用方判断，勿解析为 JSON）。 """ get_skill_logger().info("pick_logged_in platform_input=%r", platform_input) key = resolve_platform_key((platform_input or "").strip()) if not key: print("ERROR:INVALID_PLATFORM 无法识别的平台名称。") print("支持：" + _platform_list_cn_for_help()) return init_db() conn = get_conn() try: cur = conn.cursor() cur.execute( """ SELECT id FROM accounts WHERE platform = ? AND login_status = 1 ORDER BY (last_login_at IS NULL), last_login_at DESC LIMIT 1 """, (key,), ) row = cur.fetchone() finally: conn.close() if not row: print("ERROR:NO_LOGGED_IN_ACCOUNT 该平台暂无已登录账号（login_status=1）。") print("请先 list 查看账号 id，再执行：python main.py login ") return acc = get_account_by_id(row[0]) if not acc: print("ERROR:ACCOUNT_NOT_FOUND") print(_runtime_paths_debug_text(), file=sys.stderr) return print(json.dumps(acc, ensure_ascii=False)) def cmd_add(platform_input: str, phone: str): """添加账号：platform 可为中文展示名或英文键；手机号必填；同平台下同手机号不可重复。""" log = get_skill_logger() log.info("add_attempt platform_input=%r", platform_input) init_db() key = resolve_platform_key((platform_input or "").strip()) if not key: log.warning("add_invalid_platform input=%r", platform_input) print("ERROR:INVALID_PLATFORM 无法识别的平台名称。") print("支持：" + _platform_list_cn_for_help()) return phone_raw = (phone or "").strip() if not phone_raw: log.warning("add_phone_missing") print("ERROR:PHONE_REQUIRED 手机号为必填。") return phone_norm = _normalize_phone_digits(phone_raw) if not _is_valid_cn_mobile11(phone_norm): log.warning("add_phone_invalid digits_len=%s", len(phone_norm or "")) print( "ERROR:PHONE_INVALID 手机号格式不正确：须为中国大陆 11 位号码，" "以 1 开头、第二位为 3～9（示例 13800138000）。" ) return url = PLATFORM_URLS[key] now = _now_unix() phone_store = phone_norm conn = get_conn() try: cur = conn.cursor() cur.execute( "SELECT id FROM accounts WHERE platform = ? AND phone = ?", (key, phone_store), ) if cur.fetchone(): log.warning("add_duplicate platform=%s phone_suffix=%s", key, phone_store[-4:]) print( f"ERROR:DUPLICATE_PHONE_PLATFORM 该平台下已存在手机号 {phone_store}，请勿重复添加。" ) return cur.execute("SELECT COUNT(*) FROM accounts WHERE platform = ?", (key,)) next_idx = cur.fetchone()[0] + 1 name = _default_name_for_platform(key, next_idx) profile_dir = get_default_profile_dir(key, phone_store, None) cur.execute( """ INSERT INTO accounts (name, platform, phone, profile_dir, url, login_status, last_login_at, extra_json, created_at, updated_at) VALUES (?, ?, ?, ?, ?, 0, NULL, NULL, ?, ?) """, (name, key, phone_store, profile_dir, url, now, now), ) new_id = cur.lastrowid conn.commit() finally: conn.close() print( f"✅ 已保存账号：ID {new_id} | {name} | {_PLATFORM_PRIMARY_CN.get(key, key)} | 手机 {phone_store}" ) print(f"ℹ️ 登录请执行：python main.py login {new_id}") log.info( "add_success id=%s platform=%s profile_dir=%s", new_id, key, profile_dir, ) def _remove_profile_dir(path: str) -> None: p = (path or "").strip() if not p or not os.path.isdir(p): return try: shutil.rmtree(p) except OSError as e: print(f"⚠️ 未能删除用户数据目录（可手工删）：{p}\n {e}", file=sys.stderr) def cmd_delete_by_id(account_id) -> None: log = get_skill_logger() log.info("delete_by_id account_id=%r", account_id) init_db() aid = _normalize_account_id(account_id) if aid is None or (isinstance(aid, str) and not str(aid).isdigit()): log.warning("delete_invalid_id") print("ERROR:DELETE_INVALID_ID 账号 id 须为正整数。") return conn = get_conn() try: cur = conn.cursor() cur.execute( "SELECT id, name, platform, phone, profile_dir FROM accounts WHERE id = ?", (int(aid),), ) row = cur.fetchone() if not row: log.warning("delete_by_id_not_found id=%s", aid) print("ERROR:ACCOUNT_NOT_FOUND") print(_runtime_paths_debug_text(), file=sys.stderr) return rid, name, plat, phone, profile_dir = row cur.execute("DELETE FROM accounts WHERE id = ?", (rid,)) conn.commit() finally: conn.close() _remove_profile_dir(profile_dir) print( f"✅ 已删除账号：ID {rid} | {name} | {_PLATFORM_PRIMARY_CN.get(plat, plat)} | 手机 {phone or '(无)'}" ) log.info("delete_by_id_done id=%s platform=%s", rid, plat) def cmd_delete_by_platform(platform_input: str) -> None: log = get_skill_logger() log.info("delete_by_platform platform_input=%r", platform_input) init_db() key = resolve_platform_key((platform_input or "").strip()) if not key: log.warning("delete_by_platform_invalid_platform") print("ERROR:INVALID_PLATFORM 无法识别的平台名称。") print("支持：" + _platform_list_cn_for_help()) return conn = get_conn() try: cur = conn.cursor() cur.execute( "SELECT id, profile_dir FROM accounts WHERE platform = ?", (key,), ) rows = cur.fetchall() if not rows: log.warning("delete_by_platform_empty platform=%s", key) print("ERROR:NO_ACCOUNTS_FOUND 该平台下没有账号记录。") return cur.execute("DELETE FROM accounts WHERE platform = ?", (key,)) conn.commit() finally: conn.close() for _rid, pdir in rows: _remove_profile_dir(pdir) print( f"✅ 已删除 {_PLATFORM_PRIMARY_CN.get(key, key)} 下共 {len(rows)} 条账号及对应用户数据目录。" ) log.info("delete_by_platform_done platform=%s count=%s", key, len(rows)) def cmd_delete_by_platform_phone(platform_input: str, phone: str) -> None: log = get_skill_logger() log.info("delete_by_platform_phone platform_input=%r", platform_input) init_db() key = resolve_platform_key((platform_input or "").strip()) if not key: print("ERROR:INVALID_PLATFORM 无法识别的平台名称。") print("支持：" + _platform_list_cn_for_help()) return phone_raw = (phone or "").strip() if not phone_raw: print("ERROR:PHONE_REQUIRED 手机号为必填。") return phone_norm = _normalize_phone_digits(phone_raw) if not _is_valid_cn_mobile11(phone_norm): print( "ERROR:PHONE_INVALID 手机号格式不正确：须为中国大陆 11 位号码，" "以 1 开头、第二位为 3～9。" ) return conn = get_conn() try: cur = conn.cursor() cur.execute( "SELECT id, name, profile_dir FROM accounts WHERE platform = ? AND phone = ?", (key, phone_norm), ) row = cur.fetchone() if not row: print("ERROR:ACCOUNT_NOT_FOUND 该平台下无此手机号。") return rid, name, profile_dir = row cur.execute( "DELETE FROM accounts WHERE platform = ? AND phone = ?", (key, phone_norm), ) conn.commit() finally: conn.close() _remove_profile_dir(profile_dir) print( f"✅ 已删除账号：ID {rid} | {name} | {_PLATFORM_PRIMARY_CN.get(key, key)} | 手机 {phone_norm}" ) log.info("delete_by_platform_phone_done id=%s platform=%s", rid, key) def _win_find_exe(candidates): for p in candidates: if p and os.path.isfile(p): return p return None def resolve_chromium_channel(): """ Playwright channel: 'chrome' | 'msedge' | None Windows 优先 Chrome，其次 Edge；其它系统默认 chrome（由 Playwright 解析 PATH）。 """ if sys.platform != "win32": return "chrome" pf = os.environ.get("ProgramFiles", r"C:\Program Files") pfx86 = os.environ.get("ProgramFiles(x86)", r"C:\Program Files (x86)") local = os.environ.get("LocalAppData", "") chrome = _win_find_exe( [ os.path.join(pf, "Google", "Chrome", "Application", "chrome.exe"), os.path.join(pfx86, "Google", "Chrome", "Application", "chrome.exe"), os.path.join(local, "Google", "Chrome", "Application", "chrome.exe") if local else "", ] ) if chrome: return "chrome" edge = _win_find_exe( [ os.path.join(pfx86, "Microsoft", "Edge", "Application", "msedge.exe"), os.path.join(pf, "Microsoft", "Edge", "Application", "msedge.exe"), os.path.join(local, "Microsoft", "Edge", "Application", "msedge.exe") if local else "", ] ) if edge: return "msedge" return None def _print_browser_install_hint(): print("❌ 未检测到 Google Chrome 或 Microsoft Edge，请先安装后再登录：") print(" • Chrome: https://www.google.com/chrome/") print(" • Edge: https://www.microsoft.com/zh-cn/edge") def _login_timeout_seconds(): try: return max(60, int((os.getenv("JIANGCHANG_LOGIN_TIMEOUT_SECONDS") or "300").strip())) except ValueError: return 300 def _login_poll_interval_seconds(): """轮询间隔，默认 1.5s。""" try: v = float((os.getenv("JIANGCHANG_LOGIN_POLL_INTERVAL_SECONDS") or "1.5").strip()) return max(0.5, min(v, 10.0)) except ValueError: return 1.5 def _login_dom_grace_seconds() -> float: """goto 后等待再开始 DOM 判定，减轻跳转中途误判。默认 4s，JIANGCHANG_LOGIN_DOM_GRACE_SECONDS。""" try: v = float((os.getenv("JIANGCHANG_LOGIN_DOM_GRACE_SECONDS") or "4").strip()) return max(0.0, min(v, 60.0)) except ValueError: return 4.0 def _login_out_bundle_for(platform_key: str) -> dict: """传给子进程：anchor + 未登录可见的选择器列表。""" spec = PLATFORMS.get(platform_key, {}) if platform_key else {} anchor = (urlparse(PLATFORM_URLS.get(platform_key, "") or "").netloc or "").lower() spec_lo_dom = [ str(s).strip() for s in (spec.get("login_logged_out_selectors") or []) if s is not None and str(s).strip() ] if bool(spec.get("login_skip_generic_logged_out_dom")): logged_out_dom_selectors = list(spec_lo_dom) else: logged_out_dom_selectors = list(_LOGIN_LOGGED_OUT_DOM_GENERIC_SELECTORS) + spec_lo_dom return { "logged_out_dom_selectors": logged_out_dom_selectors, "anchor_host": anchor, } def cmd_login(account_id): log = get_skill_logger() log.info("login_command account_id=%r", account_id) target = get_account_by_id(account_id) if not target: log.warning("login_aborted account_not_found account_id=%r", account_id) print("ERROR:ACCOUNT_NOT_FOUND") return channel = resolve_chromium_channel() if not channel: log.warning("login_aborted no_chromium_channel") _print_browser_install_hint() return try: import playwright # noqa: F401 except ImportError: log.error("login_aborted playwright_missing") print("ERROR:需要 playwright：pip install playwright && playwright install chromium") return profile_dir = (target.get("profile_dir") or "").strip() if not profile_dir: log.warning("login_aborted profile_dir_empty account_id=%s", target.get("id")) print("ERROR:PROFILE_DIR_MISSING 库中 profile_dir 为空。") return os.makedirs(profile_dir, exist_ok=True) url = (target.get("url") or "").strip() or PLATFORM_URLS.get(target["platform"], "https://www.google.com") platform = (target.get("platform") or "").strip().lower() timeout_sec = _login_timeout_seconds() poll_sec = _login_poll_interval_seconds() dom_grace_sec = _login_dom_grace_seconds() browser_name = "Google Chrome" if channel == "chrome" else "Microsoft Edge" print(f"正在为账号 [{target['name']}] 打开 {browser_name} …") print(f"访问地址：{url}") print( "请在窗口内完成登录。系统根据页面是否仍出现「登录」等未登录控件判断；" "成功后自动关闭窗口并写入状态（无需手动关浏览器）。" ) print( f"页面加载后先等待约 {dom_grace_sec:g} 秒再开始检测（减轻跳转误判，可用 JIANGCHANG_LOGIN_DOM_GRACE_SECONDS 调整）。" ) print(f"轮询间隔约 {poll_sec} 秒；全程最长 {timeout_sec} 秒。") # 子进程：login_detect_bundle + 多 tab DOM；日志与主进程同一文件（追加）。 log_file = _skill_log_file_path() log.info( "login_browser_start account_id=%s platform=%s channel=%s timeout_sec=%s poll_sec=%s " "dom_grace_sec=%s profile_dir=%s start_url=%s log_file=%s", target.get("id"), platform, channel, timeout_sec, poll_sec, dom_grace_sec, profile_dir, url, log_file, ) runner = r"""import json, logging, sys, time from urllib.parse import urlparse from playwright.sync_api import sync_playwright def page_location_href(p): # Prefer location.href over page.url for SPA (e.g. Sohu shell path lag). try: href = p.evaluate("() => location.href") if href and str(href).strip(): return str(href).strip() except Exception: pass try: return (p.url or "").strip() except Exception: return "" def host_matches_anchor(netloc, anchor): h = (netloc or "").lower().strip() a = (anchor or "").lower().strip() if not a: return True if not h: return False return h == a or h.endswith("." + a) or a.endswith("." + h) def loc_first_visible(pg, selectors): for sel in selectors: s = str(sel).strip() if not s: continue try: loc = pg.locator(s).first if loc.is_visible(timeout=500): return True, s except Exception: pass return False, None def list_pages_on_anchor(ctx, main_page, bundle): anchor = (bundle.get("anchor_host") or "").strip().lower() seen_ids = set() pages = [] for pg in list(ctx.pages or []): try: i = id(pg) if i not in seen_ids: seen_ids.add(i) pages.append(pg) except Exception: pages.append(pg) if main_page is not None: try: i = id(main_page) if i not in seen_ids: seen_ids.add(i) pages.append(main_page) except Exception: pages.append(main_page) out = [] for pg in pages: try: href = page_location_href(pg) except Exception: continue if not href or str(href).lower().startswith("about:"): continue try: host = urlparse(href).netloc.lower() except Exception: continue if anchor and not host_matches_anchor(host, anchor): continue out.append(pg) return out def evaluate_logged_out_dom(ctx, main_page, bundle): selectors = [ str(x).strip() for x in (bundle.get("logged_out_dom_selectors") or []) if x is not None and str(x).strip() ] if not selectors: return True, "no_logged_out_dom_selectors_configured" for pg in list_pages_on_anchor(ctx, main_page, bundle): try: href = page_location_href(pg) except Exception: href = "" hit, which = loc_first_visible(pg, selectors) if hit: return True, "logged_out_dom=%r url=%r" % (which, href) return False, "" with open(sys.argv[1], encoding="utf-8") as f: c = json.load(f) bundle = c.get("login_detect_bundle") or {} poll = float(c.get("poll_interval", 1.5)) try: dom_grace = float(c.get("dom_grace_sec", 4.0)) except (TypeError, ValueError): dom_grace = 4.0 if dom_grace < 0: dom_grace = 0.0 t0 = time.time() deadline = t0 + float(c["timeout_sec"]) interactive_ok = False result_path = c.get("result_path") or "" log_path = (c.get("log_file") or "").strip() lg = logging.getLogger("openclaw.skill.account_manager.login_child") if log_path: lg.handlers.clear() lg.setLevel(logging.DEBUG) _fh = logging.FileHandler(log_path, encoding="utf-8") _fh.setFormatter( logging.Formatter( "%(asctime)s | %(levelname)-8s | %(name)s | %(message)s", datefmt="%Y-%m-%dT%H:%M:%S", ) ) lg.addHandler(_fh) lg.propagate = False last_eval_detail = "" with sync_playwright() as p: ctx = p.chromium.launch_persistent_context( user_data_dir=c["profile_dir"], headless=False, channel=c["channel"], no_viewport=True, args=["--start-maximized"], ) try: page = ctx.pages[0] if ctx.pages else ctx.new_page() page.goto(c["url"], wait_until="domcontentloaded", timeout=60000) if dom_grace > 0: time.sleep(dom_grace) if lg.handlers: lg.info( "goto_done initial_pages=%s poll_interval_sec=%s dom_grace_sec=%s", len(ctx.pages or []), poll, dom_grace, ) while time.time() < deadline: iter_start = time.time() try: still_logged_out, detail = evaluate_logged_out_dom(ctx, page, bundle) ok = not still_logged_out last_eval_detail = detail if lg.handlers: parts = [] for tab in list(ctx.pages or []): try: href = page_location_href(tab) pu = (tab.url or "").strip() parts.append("href=%r playwright_url=%r" % (href, pu)) except Exception: parts.append("(tab_read_error)") lg.debug( "poll iter_start_elapsed=%.1fs deadline_in=%.1fs tabs=%s poll_interval_sec=%s logged_out=%s ok=%s detail=%s | %s", iter_start - t0, deadline - iter_start, len(ctx.pages or []), poll, still_logged_out, ok, detail, " ; ".join(parts) if parts else "no_tabs", ) if ok: interactive_ok = True if lg.handlers: lg.info("login_detected_ok %s", detail) break except Exception as ex: if lg.handlers: lg.warning("poll_exception err=%s", ex, exc_info=True) spent = time.time() - iter_start time.sleep(max(0.0, poll - spent)) if not interactive_ok: if lg.handlers: lg.warning("login_poll_exhausted detail=%s", last_eval_detail) rem = max(0.0, deadline - time.time()) if rem > 0: try: ctx.wait_for_event("close", timeout=rem * 1000) except Exception: pass else: if lg.handlers: lg.info("login_success_closing_browser_immediately") except Exception as e: if lg.handlers: lg.exception("login_runner_fatal err=%s", e) print(e, file=sys.stderr) raise finally: if result_path: try: with open(result_path, "w", encoding="utf-8") as rf: json.dump({"interactive_ok": interactive_ok}, rf, ensure_ascii=False) except Exception: pass try: ctx.close() except Exception: pass """ cfg = { "channel": channel, "profile_dir": profile_dir, "url": url, "timeout_sec": timeout_sec, "poll_interval": poll_sec, "dom_grace_sec": dom_grace_sec, "login_detect_bundle": _login_out_bundle_for(platform), "log_file": log_file, } with tempfile.NamedTemporaryFile( mode="w", suffix=".json", delete=False, encoding="utf-8" ) as rf: result_path = rf.name cfg["result_path"] = result_path with tempfile.NamedTemporaryFile( mode="w", suffix=".json", delete=False, encoding="utf-8" ) as jf: json.dump(cfg, jf, ensure_ascii=False) cfg_path = jf.name with tempfile.NamedTemporaryFile( mode="w", suffix=".py", delete=False, encoding="utf-8" ) as pf: pf.write(runner) py_path = pf.name proc_rc = None try: r = subprocess.run( [sys.executable, py_path, cfg_path], timeout=timeout_sec + 180, ) proc_rc = r.returncode if proc_rc != 0: print("⚠️ 浏览器进程异常退出，将仅根据已写入的检测结果更新状态") log.warning("login_subprocess_nonzero_return code=%s", proc_rc) except subprocess.TimeoutExpired as ex: print("⚠️ 等待浏览器超时，将仅根据已写入的检测结果更新状态") log.warning("login_subprocess_timeout err=%s", ex) finally: try: os.unlink(cfg_path) except OSError: pass try: os.unlink(py_path) except OSError: pass interactive_ok = False try: with open(result_path, encoding="utf-8") as rf: interactive_ok = bool(json.load(rf).get("interactive_ok")) except Exception: pass try: os.unlink(result_path) except OSError: pass time.sleep(0.5) ok = interactive_ok log.info( "login_finished account_id=%s interactive_ok=%s subprocess_rc=%s marking_db=%s", target.get("id"), interactive_ok, proc_rc, ok, ) _mark_login_status(target["id"], ok) if ok: print("✅ 已判定登录成功，状态已写入数据库") else: log.warning( "login_not_detected account_id=%s platform=%s see_log=%s", target.get("id"), platform, log_file, ) print("⚠️ 未检测到有效登录，状态为未登录。请关闭其他占用该用户目录的浏览器后重试，或延长 JIANGCHANG_LOGIN_TIMEOUT_SECONDS 后再登录。") print(f"ℹ️ 详细轮询日志见：{log_file}（可将 JIANGCHANG_LOG_LEVEL=DEBUG 打开更细粒度）") def cmd_open(account_id): """打开该账号的持久化浏览器，仅用于肉眼确认是否已登录；不写数据库。""" get_skill_logger().info("open account_id=%r", account_id) target = get_account_by_id(account_id) if not target: get_skill_logger().warning("open_not_found account_id=%r", account_id) print("ERROR:ACCOUNT_NOT_FOUND") return channel = resolve_chromium_channel() if not channel: _print_browser_install_hint() return try: import playwright # noqa: F401 except ImportError: print("ERROR:需要 playwright：pip install playwright && playwright install chromium") return profile_dir = (target.get("profile_dir") or "").strip() if not profile_dir: print("ERROR:PROFILE_DIR_MISSING 库中 profile_dir 为空。") return os.makedirs(profile_dir, exist_ok=True) url = (target.get("url") or "").strip() or PLATFORM_URLS.get( target["platform"], "https://www.google.com" ) browser_name = "Google Chrome" if channel == "chrome" else "Microsoft Edge" print(f"正在打开 [{target['name']}] 的 {browser_name}（仅查看，不写入数据库）") print(f"地址：{url}") print("请在本窗口中自行确认登录态。关闭浏览器后命令结束。") print("需要自动检测并写入数据库时，请执行：python main.py login ") runner_open = r"""import json, sys from playwright.sync_api import sync_playwright with open(sys.argv[1], encoding="utf-8") as f: c = json.load(f) with sync_playwright() as p: ctx = p.chromium.launch_persistent_context( user_data_dir=c["profile_dir"], headless=False, channel=c["channel"], no_viewport=True, args=["--start-maximized"], ) try: page = ctx.pages[0] if ctx.pages else ctx.new_page() page.goto(c["url"], wait_until="domcontentloaded", timeout=60000) ctx.wait_for_event("close", timeout=86400000) except Exception as e: print(e, file=sys.stderr) raise finally: try: ctx.close() except Exception: pass """ cfg = {"channel": channel, "profile_dir": profile_dir, "url": url} with tempfile.NamedTemporaryFile( mode="w", suffix=".json", delete=False, encoding="utf-8" ) as jf: json.dump(cfg, jf, ensure_ascii=False) cfg_path = jf.name with tempfile.NamedTemporaryFile( mode="w", suffix=".py", delete=False, encoding="utf-8" ) as pf: pf.write(runner_open) py_path = pf.name try: subprocess.run([sys.executable, py_path, cfg_path]) finally: try: os.unlink(cfg_path) except OSError: pass try: os.unlink(py_path) except OSError: pass def _mark_login_status(account_id, success: bool): now = _now_unix() conn = get_conn() try: cur = conn.cursor() if success: cur.execute( "UPDATE accounts SET login_status = 1, last_login_at = ?, updated_at = ? WHERE id = ?", (now, now, account_id), ) else: cur.execute( "UPDATE accounts SET login_status = 0, updated_at = ? WHERE id = ?", (now, account_id), ) conn.commit() finally: conn.close() def _cli_print_full_usage() -> None: """总览（未带子命令或需要完整说明时）。""" print("用法概览（将 main.py 换为你的路径）：") print(" python main.py add <平台中文名> <手机号>") print(" python main.py list [平台|all|全部]") print(" python main.py pick-logged-in <平台> # 跨技能用：输出一行 JSON 或 ERROR") print(" python main.py get ") print(" python main.py open ") print(" python main.py login ") print(" python main.py delete id ") print(" python main.py delete platform <平台>") print(" python main.py delete platform <平台> <手机号>") print(" python main.py <平台> # 等价于只列该平台") print(" python main.py <平台> list # 同上") print() print("支持的平台（可用下列中文称呼，亦支持英文键如 sohu）：") print(" " + _platform_list_cn_for_help()) def _cli_fail_add() -> None: print("ERROR:CLI_ADD_MISSING_ARGS") print() print("【add 添加账号】参数不足。") print(" 必填：平台名称（中文即可，如 搜狐号、知乎、微信公众号）") print(" 必填：中国大陆 11 位手机号（1 开头，第二位 3～9），同平台下不可重复") print() print("示例：") print(" python main.py add 搜狐号 13800138000") print(" python main.py add 知乎 13900001111") print() print("支持的平台：" + _platform_list_cn_for_help()) def _cli_fail_need_account_id(subcmd: str) -> None: print(f"ERROR:CLI_{subcmd.upper()}_MISSING_ID") print() print(f"【{subcmd}】缺少必填参数：账号 id（数据库自增整数，可先 list 查看）。") print("示例：") print(f" python main.py {subcmd} 1") def _cli_fail_delete() -> None: print("ERROR:CLI_DELETE_MISSING_ARGS") print() print("【delete 删除账号】参数不足。支持三种方式：") print(" 按 id：python main.py delete id ") print(" 按平台（删该平台下全部）：python main.py delete platform <平台中文名或英文键>") print(" 按平台+手机号：python main.py delete platform <平台> <手机号>") print() print("示例：") print(" python main.py delete id 3") print(" python main.py delete platform 搜狐号") print(" python main.py delete platform 头条号 18925203701") print() print("说明：会同时删除数据库记录与 profile 用户数据目录（若存在）。") if __name__ == "__main__": if len(sys.argv) < 2: _cli_print_full_usage() sys.exit(1) _apply_cli_local_dev_env() get_skill_logger().info("cli_start argv=%s", sys.argv) cmd = sys.argv[1] _maybe_print_paths_debug_cli() plat_from_first = resolve_platform_key(cmd) if len(sys.argv) >= 3 and sys.argv[2] == "list" and plat_from_first: cmd_list(plat_from_first) elif plat_from_first and len(sys.argv) == 2: cmd_list(plat_from_first) elif cmd == "add": if len(sys.argv) < 4: _cli_fail_add() sys.exit(1) cmd_add(sys.argv[2], sys.argv[3]) elif cmd == "list": cmd_list(sys.argv[2] if len(sys.argv) >= 3 else "all") elif cmd == "get": if len(sys.argv) < 3: _cli_fail_need_account_id("get") sys.exit(1) cmd_get(sys.argv[2]) elif cmd == "pick-logged-in": if len(sys.argv) < 3: print("ERROR:CLI_PICK_LOGGED_IN_MISSING_ARGS") print("用法：python main.py pick-logged-in <平台中文名或英文键>") print("说明：供 llm-manager 等技能查询该平台已登录账号；成功时 stdout 仅一行 JSON。") sys.exit(1) cmd_pick_logged_in(sys.argv[2]) elif cmd == "open": if len(sys.argv) < 3: _cli_fail_need_account_id("open") sys.exit(1) cmd_open(sys.argv[2]) elif cmd == "login": if len(sys.argv) < 3: _cli_fail_need_account_id("login") sys.exit(1) cmd_login(sys.argv[2]) elif cmd == "delete": if len(sys.argv) < 4: _cli_fail_delete() sys.exit(1) mode = (sys.argv[2] or "").strip().lower() if mode == "id": cmd_delete_by_id(sys.argv[3]) elif mode == "platform": if len(sys.argv) >= 5: cmd_delete_by_platform_phone(sys.argv[3], sys.argv[4]) else: cmd_delete_by_platform(sys.argv[3]) else: print(f"ERROR:CLI_DELETE_BAD_MODE 不支持的删除方式「{sys.argv[2]}」，请使用 id 或 platform。") _cli_fail_delete() sys.exit(1) else: print(f"ERROR:CLI_UNKNOWN_OR_BAD_ARGS 子命令「{cmd}」无法识别，或参数组合不合法。") print() _cli_print_full_usage() print() print("说明：list 的筛选可为 all/全部，或上面列出的任一平台中文名。") sys.exit(1)