@genduo/desk 0.4.0 → 0.5.0

package/README.md

@@ -1,12 +1,12 @@
 # 店铺采集 Agent（CLI）
 
-**状态** 门店 CLI 登录授权已落地；**采集循环已落地**（`run.py` 0.4.0）｜ **下一店** 5RT2 ｜ **中心** `https://dataanalyst.jp` ｜ **POC** 7RT2 已绿
+**状态** 门店 CLI 登录授权已落地；**采集循环已落地**（`run.py` 0.5.0）｜ **凭据** 与销量计算系统一致｜ **下一店** 5RT2 ｜ **中心** `https://dataanalyst.jp` ｜ **POC** 7RT2 已绿
 
 ## 目标 UX
 
-1. **超管先备齐**：每店 Agent token + R-Login 两组密码。
-2. **门店只拿到本 CLI**：运行 `login` 完成登录授权（写入 Keychain、心跳、可选装 LaunchAgent）。
-3. 不再以「每店手写 plist / 手工 security 命令」作为主路径。
+1. **超管先备齐**：中心签发每店 Agent token；店机维护 `JDY_MCP`（与销量系统相同）；RMS 用 env-file。
+2. **门店只拿到本 CLI**：运行 `login`（token 进环境 / bootstrap）、心跳、可选装 LaunchAgent。
+3. 不再以「手工 `security` 写 dataanalyst/*」作为主路径。
 
 ### 安装（门店主路径：npm）
 
@@ -19,8 +19,8 @@ genduo-desk login --shop 5RT2 --verify-rms --install-service
 genduo-desk status
 ```
 
-包名 `@genduo/desk`（全局命令 `genduo-desk`）；版本见 `package.json` / `local_config.VERSION`（0.4.0）。  
-**Keychain service 名未改**（仍为 `dataanalyst-agent-token` / `dataanalyst/rms/...`），换包名不影响已写入的凭据。
+包名 `@genduo/desk`（全局命令 `genduo-desk`）；版本见 `package.json` / `local_config.VERSION`（0.5.0）。  
+**0.5.0**：凭据获取与销量计算系统一致（`JDY_MCP` → MCP → 密码表 API Key）；旧 `dataanalyst-agent-token` / `dataanalyst/rms/...` 已废弃。
 
 ### 开发 / monorepo 路径（次要）
 
@@ -37,15 +37,16 @@ genduo-desk status
 
 | 命令 | 谁用 | 作用 |
 |---|---|---|
-| `login` | 门店 | 粘贴 token + 输入 R-Login 两组 → Keychain；可选心跳 / RMS 校验 / LaunchAgent |
-| `status` | 门店 | Keychain 是否齐全、LaunchAgent、打一次心跳 |
+| `login` | 门店 | Agent token → 环境；可选心跳 / RMS 校验 / LaunchAgent |
+| `status` | 门店 | JDY_MCP / token 环境 / LaunchAgent / 心跳 |
 | `heartbeat` | 门店 / 调试 | `POST /api/agent/heartbeat` + 拉 jobs |
 | `install-service` | 门店 | 装 Agent + **caffeinate** LaunchAgent（默认） |
 | `prevent-sleep` | 门店 / 超管 | 只装 `jp.dataanalyst.caffeinate`（`caffeinate -dims`），并打印 `pmset` 说明 |
 | `uninstall-service` | 门店 | 卸 Agent **与** caffeinate LaunchAgent |
-| `admin checklist` | 超管 | 打印某店开店清单（含签发 token 命令） |
-| `admin set-rms` | 超管 | 交互写入本机 `dataanalyst/rms/<SHOP>-rlogin` / `-ai` |
-| `admin write-bootstrap` | 超管 | 把 token 写成 600 一次性 JSON，供门店 `login --bootstrap` |
+| `admin checklist` | 超管 | 开店清单（与销量系统凭据说明） |
+| `admin verify-secrets` | 超管 | 探测 `JDY_MCP` → API Key（不打印） |
+| `admin set-rms` | 超管 | **已废弃**（勿写 dataanalyst/rms/*） |
+| `admin write-bootstrap` | 超管 | 600 一次性 JSON 给门店 `login --bootstrap` |
 
 常驻进程入口是 `run.py`（LaunchAgent 调用）：进程内 sleep 循环，心跳 + 日次访问 + 月度 RPP → ingest。
 
@@ -106,15 +107,20 @@ genduo-desk install-service --skip-caffeinate
 合盖笔记本另议；常开台式 + 登录用户是推荐形态。
 
 
-## Keychain 约定（勿改名）
+## 凭据（与销量计算系统一致）
 
-| 用途 | service | account |
+本机 Keychain **只**用于 MCP URL（店机维护；本开发机可以没有）：
+
+| service | account | 覆盖 |
 |---|---|---|
-| Agent token | `dataanalyst-agent-token` | `$USER` |
-| R-Login 第一组 | `dataanalyst/rms/<SHOP>-rlogin` | R-Login ID |
-| Rakuten SSO 第二组 | `dataanalyst/rms/<SHOP>-ai` | 邮箱 |
+| `JDY_MCP` | `服务器URL` | 环境变量 `JDY_MCP_URL` 优先 |
+
+JDY API Key：经 MCP `member_data_list` 查密码表，Title 精确匹配 **`api key 精细化运营`**（同销量系统 `config.JDY_API_KEY_TITLE`）。不硬编码、不打印。
+
+Agent token（中心 `da_…`）：环境变量 `DATAANALYST_AGENT_TOKEN`，或 `login --bootstrap`。**不写** `dataanalyst-agent-token` Keychain。
+
+RMS 两组：`RMS_<SHOP>_LOGIN_ID` / `PASSWORD` / `SHOP_USER` / `SHOP_PASSWORD`，或 `rms_browser_login --env-file`。**不写** `dataanalyst/rms/*` Keychain。
 
-与包内 vendored `rms_browser_login.py --from-keychain`（源真相仍是 monorepo `tools/rms_browser_login.py`）、7RT2 POC 一致。  
 本机非机密配置：`~/.config/dataanalyst-agent/config.json`（仅 `shop` / `base`）。
 
 ## 中心契约
@@ -136,33 +142,27 @@ genduo-desk install-service --skip-caffeinate
 # 1) 看清单
 genduo-desk admin checklist --shop 5RT2
 
-# 2) 中心签发 token（Web 或 VPS python -m app.tokens …）；明文不要进 git/聊天
-# 3) 可选：在店里 Mac 上预写 RMS
-genduo-desk admin set-rms --shop 5RT2
+# 2) 中心签发 token（明文勿进 git/聊天）→ 门店 DATAANALYST_AGENT_TOKEN 或 bootstrap
+# 3) 店机维护 JDY_MCP（与销量系统相同；开发机可无）
+genduo-desk admin verify-secrets --shop 5RT2
 
-# 4) 可选：做一次性 bootstrap 交给门店
+# 4) 可选 bootstrap
 genduo-desk admin write-bootstrap --shop 5RT2 --out /tmp/5RT2.boot.json
 ```
 
 ## 门店流程（后）
 
 ```bash
-# 交互粘贴 token + 输入两组密码
 genduo-desk login --shop 5RT2 --verify-rms --install-service
 
-# 或用超管 bootstrap（读完可删）
-genduo-desk login --shop 5RT2 \
-  --bootstrap /tmp/5RT2.boot.json --consume-bootstrap \
-  --keep-rms --verify-rms --install-service
-
 genduo-desk status
 ```
 
-`--keep-token` / `--keep-rms`：Keychain 已有则跳过对应提示（7RT2 POC 复用时有用）。
+`--keep-token` / `--keep-rms`：沿用已有环境变量，不重复交互。
 
 ## 5RT2 下一店清单
 
-1. 超管：签发 `agent-5RT2`（scopes/shops 如上）；备齐 R-Login 两组。
+1. 超管：签发 `agent-5RT2`；门店 Mac 维护 `JDY_MCP`（与销量系统一致）；备齐 RMS env-file。
 2. 门店 Mac：装 Playwright Chromium（若要 `--verify-rms`）。
 3. 门店：`login --shop 5RT2 --verify-rms --install-service`。
 4. 先只推最近 7 天 `rms_access`；连续 7 天正常后再接 RPP。
@@ -173,7 +173,8 @@ genduo-desk status
 
 ## 安全
 
-- 不打印 token / 密码；bootstrap 文件 mode 600，`--consume-bootstrap` 用后删除。
+- 不打印 token / 密码；JDY 侧与销量计算系统一致（Keychain 仅 MCP URL → 密码表 API Key）。
+- Agent token / RMS 用环境变量或 bootstrap / env-file，不写 dataanalyst/* Keychain。
 - 中心**不保存** R-Login 密码；只收出站 HTTPS ingest / 心跳。
 - RMS 登录阶段禁止 accessibility snapshot / 把密码写入日志；需要人工 2FA 时本机接管。
 - 本 CLI **不会**自行向生产签发新 token。

package/cli.py

@@ -4,13 +4,13 @@
 
 主 UX（门店）：
   genduo-desk login --shop 5RT2
-    交互写入 Agent token + R-Login 两组凭据到 Keychain，
+    本机 Keychain 只需已有 JDY_MCP / 服务器URL；
+    Agent token 与 R-Login 两组从简道云密码表经 MCP 读取，
     可选验证 RMS 登录、注册心跳、安装 LaunchAgent + caffeinate 防休眠。
 
-超管侧（先备齐凭据 / 签发 token）：
+超管侧（先备齐简道云 Title + 签发 token 写入密码表）：
   genduo-desk admin checklist --shop 5RT2
-  genduo-desk admin set-rms --shop 5RT2
-  genduo-desk admin write-bootstrap --shop 5RT2   # token 从 stdin，600 文件
+  genduo-desk admin verify-secrets --shop 5RT2
 
 不打印 token / 密码；不向生产库签发新 token（签发走中心 Web 或
 `python -m app.tokens`，见 admin checklist）。
@@ -82,13 +82,13 @@ def _resolve_base(explicit: str | None) -> str:
 # ---------------------------------------------------------------------------
 
 def cmd_login(a: argparse.Namespace) -> None:
-    """门店首次授权：token + R-Login → Keychain，可选心跳 / RMS 校验 / LaunchAgent。"""
+    """门店授权：Agent token → 环境（及可选写入 LaunchAgent）；不写 dataanalyst Keychain。"""
     shop = _resolve_shop(a.shop)
     base = _resolve_base(a.base)
     print(f"店铺 {shop}  · 中心 {base}")
-    print("凭据只写入本机 Keychain，不会打印、不会上传到中心。")
+    print("与销量计算系统一致：Keychain 仅 JDY_MCP（本机可无）；"
+          "不写 dataanalyst-agent-token / dataanalyst/rms/*。")
 
-    # --- Agent token ---
     token: str | None = None
     if a.bootstrap:
         boot = Path(a.bootstrap).expanduser()
@@ -107,43 +107,48 @@ def cmd_login(a: argparse.Namespace) -> None:
                 print("已删除 bootstrap 文件（一次性）")
             except OSError as exc:
                 print(f"警告: 未能删除 bootstrap: {exc}", file=sys.stderr)
-    elif a.token_env:
-        token = os.environ.get("DATAANALYST_AGENT_TOKEN", "").strip()
-        if not token:
+    elif a.token_env or a.keep_token:
+        token = os.environ.get("DATAANALYST_AGENT_TOKEN", "").strip() or None
+        if a.token_env and not token:
             _die("DATAANALYST_AGENT_TOKEN 为空")
-    elif a.keep_token and kc.has_generic(kc.AGENT_TOKEN_SERVICE):
-        print("保留现有 Keychain Agent token")
-    else:
+        if token:
+            print("使用环境变量 DATAANALYST_AGENT_TOKEN")
+    if token is None and not a.keep_token:
         print("请粘贴超管签发的 Agent token（da_…，输入时不回显）")
         token = _prompt_secret("Agent token")
 
     if token:
-        try:
-            kc.set_agent_token(token)
-        except ValueError as exc:
-            _die(str(exc))
-        print(f"✓ Agent token → Keychain service={kc.AGENT_TOKEN_SERVICE}")
-        # 尽快丢掉明文引用
+        if not token.startswith("da_"):
+            _die("Agent token 应以 da_ 开头")
+        os.environ["DATAANALYST_AGENT_TOKEN"] = token
+        print("✓ Agent token → 本进程环境 DATAANALYST_AGENT_TOKEN（不写 Keychain）")
         token = None
 
-    # --- R-Login 两组 ---
-    present = kc.rms_creds_present(shop)
-    if a.keep_rms and present["rlogin"] and present["ai"]:
-        print(f"保留现有 Keychain RMS 凭据 "
-              f"({kc.rms_rlogin_service(shop)}, {kc.rms_ai_service(shop)})")
+    # JDY_MCP：与销量系统相同；本机没有属正常，仅提示
+    if kc.has_generic(kc.JDY_MCP_SERVICE):
+        print(f"✓ JDY_MCP 钥匙串可见（或已设 JDY_MCP_URL）")
+        if not a.skip_secret_check:
+            try:
+                _ = kc.get_api_key()
+                _ = None
+                print(f"✓ JDY API Key ← 密码表 Title={kc.JDY_API_KEY_TITLE}")
+            except RuntimeError as exc:
+                print(f"警告: 未能经 MCP 读取 API Key: {exc}", file=sys.stderr)
     else:
-        print("R-Login 第一组（glogin ID / 密码）")
-        rlogin_id = _prompt("R-Login ID")
-        rlogin_pw = _prompt_secret("R-Login 密码")
-        print("Rakuten 会员第二组（SSO 邮箱 / 密码）")
-        sso_user = _prompt("SSO 邮箱 / 用户名")
-        sso_pw = _prompt_secret("SSO 密码")
-        kc.set_rms_creds(shop, rlogin_id=rlogin_id, rlogin_password=rlogin_pw,
-                         sso_user=sso_user, sso_password=sso_pw)
-        # 清引用
-        rlogin_pw = sso_pw = ""  # noqa: F841
-        print(f"✓ R-Login → {kc.rms_rlogin_service(shop)}")
-        print(f"✓ SSO     → {kc.rms_ai_service(shop)}")
+        print("（本机无 JDY_MCP / JDY_MCP_URL — 开发机可如此；店机请维护钥匙串）")
+
+    # RMS：可选交互写入环境变量供本进程 verify-rms（不写 Keychain）
+    if a.verify_rms and not a.keep_rms:
+        present = kc.rms_creds_present(shop)
+        if not (present["rlogin"] and present["ai"]):
+            print("R-Login 第一组（写入本进程环境，不写 Keychain）")
+            p = kc.rms_env_prefix(shop)
+            os.environ[p + "LOGIN_ID"] = _prompt("R-Login ID")
+            os.environ[p + "PASSWORD"] = _prompt_secret("R-Login 密码")
+            print("Rakuten 会员第二组")
+            os.environ[p + "SHOP_USER"] = _prompt("SSO 邮箱 / 用户名")
+            os.environ[p + "SHOP_PASSWORD"] = _prompt_secret("SSO 密码")
+            print(f"✓ RMS 凭据 → 环境变量 {p}*")
 
     path = cfg.save(shop, base)
     print(f"✓ 本机配置 → {path}（无密钥）")
@@ -164,8 +169,8 @@ def cmd_login(a: argparse.Namespace) -> None:
     print("login 完成。常用后续：")
     print(f"  {sys.argv[0]} status")
     print(f"  {sys.argv[0]} heartbeat")
-    print(f"  {sys.argv[0]} install-service   # Agent + caffeinate LaunchAgent")
-    print(f"  {sys.argv[0]} prevent-sleep     # 仅装 caffeinate；pmset 需 sudo 另做")
+    print(f"  {sys.argv[0]} install-service")
+
 
 
 def cmd_status(a: argparse.Namespace) -> None:
@@ -176,16 +181,20 @@ def cmd_status(a: argparse.Namespace) -> None:
     print(f"shop          {shop}")
     print(f"base          {base}")
     print(f"version       {cfg.VERSION}")
-    print(f"agent_token   {'有' if present['agent_token'] else '缺'}  ({kc.AGENT_TOKEN_SERVICE})")
-    print(f"rms_rlogin    {'有' if present['rlogin'] else '缺'}  ({kc.rms_rlogin_service(shop)})")
-    print(f"rms_ai        {'有' if present['ai'] else '缺'}  ({kc.rms_ai_service(shop)})")
+    print(f"jdy_mcp       {'有' if present.get('mcp_url') else '无（可预期）'}  "
+          f"({kc.JDY_MCP_SERVICE}/{kc.JDY_MCP_ACCOUNT} 或 JDY_MCP_URL)")
+    print(f"agent_token   {'有' if present['agent_token'] else '缺'}  "
+          f"(env DATAANALYST_AGENT_TOKEN)")
+    print(f"rms_env       rlogin={'有' if present['rlogin'] else '缺'}  "
+          f"ai={'有' if present['ai'] else '缺'}  ({kc.rms_env_prefix(shop)}*)")
     print(f"launchagent   {'已装' if PLIST_PATH.is_file() else '未装'}  ({PLIST_PATH})")
     print(f"caffeinate    {'已装' if CAFFEINATE_PATH.is_file() else '未装'}  ({CAFFEINATE_PATH})")
     caf_alive = _caffeinate_running()
-    print(f"caffeinate_ps {'运行中' if caf_alive else '未运行'}  ({CAFFEINATE_BIN} {' '.join(CAFFEINATE_ARGS)})")
+    print(f"caffeinate_ps {'运行中' if caf_alive else '未运行'}  "
+          f"({CAFFEINATE_BIN} {' '.join(CAFFEINATE_ARGS)})")
     if present["agent_token"] and not a.offline:
         try:
-            tok = kc.get_agent_token()
+            tok = kc.get_agent_token(shop)
             hb = api_client.heartbeat(base, tok, shop, cfg.VERSION)
             agent = (hb or {}).get("agent") or {}
             print(f"heartbeat     ok  last_seen={agent.get('last_seen_at')}")
@@ -193,6 +202,7 @@ def cmd_status(a: argparse.Namespace) -> None:
             print(f"heartbeat     失败: {exc}")
 
 
+
 def cmd_heartbeat(a: argparse.Namespace) -> None:
     conf = cfg.load()
     shop = _resolve_shop(a.shop or conf.get("shop"))
@@ -239,77 +249,60 @@ def cmd_admin_checklist(a: argparse.Namespace) -> None:
     print(textwrap.dedent(f"""
     ======== 超管 · {shop} 开店清单 ========
 
-    目标 UX：超管先备齐本店全部凭据；门店只拿到本 CLI，运行
-      genduo-desk login --shop {shop}
-    完成登录授权（Keychain + 心跳），不必手写 LaunchAgent。
+    凭据逻辑与「销量计算系统」一致：
+      · 店机 Keychain：仅 JDY_MCP / 服务器URL（开发机可无）
+      · 或环境变量 JDY_MCP_URL
+      · JDY API Key：MCP 密码表 Title={kc.JDY_API_KEY_TITLE}
+      · 不再使用 dataanalyst-agent-token / dataanalyst/rms/* Keychain
 
     A. 中心签发 Agent token（只显示一次明文）
-       · Web：超管 → API Token
-           name    = {name}
-           scopes  = collect:view,collect:edit
-           shops   = {shop}
-           days    = 365（建议）
-       · 或 VPS：
-           cd /opt/dataanalyst && sudo -u postgres env \\
-             DATAANALYST_DSN=dbname=dataanalyst DATAANALYST_SCHEMA=prod \\
-             venv/bin/python -m app.tokens --env prod create \\
-             --name {name} --scopes collect:view,collect:edit \\
-             --shops {shop} --days 365
-       · 明文立刻交给门店（或写入一次性 bootstrap），不要进 git / 聊天记录。
-
-    B. 备齐 RMS 两组密码（中心不存；只给人/Keychain）
-       · 第一组 R-Login ID/密码  → Keychain {kc.rms_rlogin_service(shop)}
-       · 第二组 Rakuten SSO     → Keychain {kc.rms_ai_service(shop)}
-       · 超管可在本机预先写入：
-           genduo-desk admin set-rms --shop {shop}
-         或让门店在 login 时自己输入。
-
-    C. 交给门店的材料
-       1. 本仓库 tools/collector-agent/（或 npm 包 @genduo/desk（命令 genduo-desk））
-       2. 店号 {shop}
-       3. Agent token（口头 / 密封通道 / bootstrap 文件）
-       4.（可选）R-Login 两组，若尚未写入该 Mac Keychain
+       · Web / VPS python -m app.tokens …
+           name={name}  scopes=collect:view,collect:edit  shops={shop}
+       · 门店用环境变量 DATAANALYST_AGENT_TOKEN，或 login --bootstrap
+
+    B. RMS 两组
+       · 环境变量 {kc.rms_env_prefix(shop)}LOGIN_ID / PASSWORD / SHOP_USER / SHOP_PASSWORD
+       · 或 rms_browser_login --env-file
+       · login --verify-rms 时可交互写入「本进程环境」（不写 Keychain）
+
+    C. 店机 Keychain（用户维护；与销量系统相同）
+       · service=JDY_MCP  account=服务器URL
+       · 本开发机没有该条目是正常的
 
     D. 门店执行
-           python3 tools/collector-agent/cli.py login --shop {shop} --verify-rms --install-service
-         或：
-           genduo-desk admin write-bootstrap --shop {shop} --out /tmp/{shop}.boot.json
-           # 门店：
-           genduo-desk login --shop {shop} --bootstrap /tmp/{shop}.boot.json \\
-             --consume-bootstrap --verify-rms --install-service
-
-    E. 防休眠（install-service 默认会装 caffeinate）
-       · 用户级：LaunchAgent jp.dataanalyst.caffeinate → caffeinate -dims
-         （login --install-service / install-service / prevent-sleep）
-       · 系统级需管理员（CLI 不静默 sudo）：
-           sudo pmset -a sleep 0 disksleep 0 displaysleep 0
-           sudo systemsetup -setrestartpowerfailure on
-
-    F. 验收
+           genduo-desk login --shop {shop} --verify-rms --install-service
+
+    E. 验收
            genduo-desk status
-           # 应见 caffeinate=已装 且 caffeinate_ps=运行中
-           # 中心 /sources 或 GET /api/agent/status 可见 {shop} online
     """).strip())
 
 
-def cmd_admin_set_rms(a: argparse.Namespace) -> None:
-    """超管在本机（或店里 Mac）写入 RMS Keychain，不涉及 Agent token。"""
+def cmd_admin_verify_secrets(a: argparse.Namespace) -> None:
+    """探测 JDY_MCP → get_api_key（与销量系统相同）；不打印 Key。"""
     shop = _resolve_shop(a.shop)
-    print(f"为 {shop} 写入 RMS Keychain（不打印密码）")
-    rlogin_id = _prompt("R-Login ID")
-    rlogin_pw = _prompt_secret("R-Login 密码")
-    sso_user = _prompt("SSO 邮箱 / 用户名")
-    sso_pw = _prompt_secret("SSO 密码")
-    kc.set_rms_creds(shop, rlogin_id=rlogin_id, rlogin_password=rlogin_pw,
-                     sso_user=sso_user, sso_password=sso_pw)
-    print(f"✓ {kc.rms_rlogin_service(shop)}")
-    print(f"✓ {kc.rms_ai_service(shop)}")
+    print(f"校验 JDY MCP / API Key（shop={shop} 仅作上下文；不打印 secret）")
+    if not kc.has_generic(kc.JDY_MCP_SERVICE):
+        print("本机无 JDY_MCP / JDY_MCP_URL（开发机可预期；店机请维护）")
+        raise SystemExit(0)
+    try:
+        _ = kc.get_api_key()
+        _ = None
+        print(f"✓ API Key 可读  Title={kc.JDY_API_KEY_TITLE}")
+    except RuntimeError as exc:
+        _die(str(exc))
     if a.verify_rms:
         _do_verify_rms(shop, headed=a.headed)
 
 
+def cmd_admin_set_rms(a: argparse.Namespace) -> None:
+    print("admin set-rms 已废弃：不再写入 dataanalyst/rms/* Keychain。")
+    print(f"请设置环境变量 {kc.rms_env_prefix(_resolve_shop(a.shop))}* "
+          "或使用 --env-file。")
+    raise SystemExit(2)
+
+
 def cmd_admin_write_bootstrap(a: argparse.Namespace) -> None:
-    """把超管刚签发的 token 写成 600 的一次性文件；不进仓库。"""
+    """把 token 写成 600 一次性文件；不进仓库、不写 Keychain。"""
     shop = _resolve_shop(a.shop)
     out = Path(a.out).expanduser() if a.out else Path(f"/tmp/dataanalyst-{shop}-bootstrap.json")
     print("粘贴 Agent token（不回显）；将写入仅含 shop+token 的 600 文件")
@@ -331,13 +324,14 @@ def cmd_admin_write_bootstrap(a: argparse.Namespace) -> None:
           f"--bootstrap {out} --consume-bootstrap")
 
 
+
 # ---------------------------------------------------------------------------
 # helpers
 # ---------------------------------------------------------------------------
 
 def _do_heartbeat(shop: str, base: str, *, show_jobs: bool = True) -> None:
     try:
-        tok = kc.get_agent_token()
+        tok = kc.get_agent_token(shop)
     except RuntimeError as exc:
         _die(str(exc))
     try:
@@ -367,12 +361,36 @@ def _do_verify_rms(shop: str, *, headed: bool = False) -> None:
         _die("找不到 rms_browser_login.py（包内 vendored 或 monorepo tools/）")
     out = HERE / "state" / f"{shop}.json"
     out.parent.mkdir(parents=True, exist_ok=True)
-    cmd = [sys.executable, str(script), "--shop", shop, "--from-keychain",
-           "--out", str(out)]
+    # 把本进程 RMS_* 环境写成 600 临时 env-file（不进 Keychain、用后删）
+    try:
+        creds = kc.get_rms_creds(shop)
+    except RuntimeError as exc:
+        _die(str(exc))
+    pfx = kc.rms_env_prefix(shop)
+    env_path = HERE / "state" / f".{shop}.rms.env"
+    lines = [
+        f"{pfx}LOGIN_ID={creds['rlogin_id']}",
+        f"{pfx}PASSWORD={creds['rlogin_password']}",
+        f"{pfx}SHOP_USER={creds['sso_user']}",
+        f"{pfx}SHOP_PASSWORD={creds['sso_password']}",
+        "",
+    ]
+    env_path.write_text("\n".join(lines), encoding="utf-8")
+    os.chmod(env_path, 0o600)
+    # 清内存引用
+    creds = None  # noqa: F841
+    cmd = [sys.executable, str(script), "--shop", shop,
+           "--env-file", str(env_path), "--out", str(out)]
     if headed:
         cmd.append("--headed")
     print("验证 RMS 登录（Playwright；登录阶段不截密码）…")
-    r = subprocess.run(cmd)
+    try:
+        r = subprocess.run(cmd)
+    finally:
+        try:
+            env_path.unlink()
+        except OSError:
+            pass
     if r.returncode != 0:
         _die("RMS 登录验证失败", r.returncode)
     try:
@@ -486,6 +504,14 @@ def _do_install_service(shop: str, base: str, *, force: bool = False,
     **不是**短任务轮询——切勿把 run.py 改回「跑完即退」否则会狂刷心跳。
     """
     cfg.save(shop, base)
+    def _plist_esc(s: str) -> str:
+        return (s.replace("&", "&amp;").replace("<", "&lt;")
+                 .replace(">", "&gt;").replace('"', "&quot;"))
+    tok_env = (os.environ.get("DATAANALYST_AGENT_TOKEN") or "").strip()
+    tok_xml = (
+        f"    <key>DATAANALYST_AGENT_TOKEN</key><string>{_plist_esc(tok_env)}</string>\n"
+        if tok_env else ""
+    )
     python = _pick_agent_python()
     run_py = HERE / "run.py"
     logs = HERE / "logs"
@@ -511,6 +537,7 @@ def _do_install_service(shop: str, base: str, *, force: bool = False,
             "  <dict>\n"
             f"    <key>DATAANALYST_SHOP</key><string>{shop}</string>\n"
             f"    <key>DATAANALYST_BASE</key><string>{base}</string>\n"
+            f"{tok_xml}"
             "  </dict>\n"
             "  <key>RunAtLoad</key><true/>\n"
             "  <key>KeepAlive</key><true/>\n"
@@ -554,16 +581,18 @@ def build_parser() -> argparse.ArgumentParser:
     sub = ap.add_subparsers(dest="cmd", required=True)
 
     p = sub.add_parser("login", parents=[common],
-                       help="门店登录授权：token + R-Login → Keychain")
-    p.add_argument("--bootstrap", help="超管生成的一次性 JSON（含 agent_token）")
+                       help="门店登录授权：Agent token 环境 + 可选 RMS 校验")
+    p.add_argument("--bootstrap", help="紧急：一次性 JSON（含 agent_token）→ 仅本进程环境")
     p.add_argument("--consume-bootstrap", action="store_true",
                    help="login 成功后删除 bootstrap 文件")
     p.add_argument("--token-env", action="store_true",
-                   help="从 DATAANALYST_AGENT_TOKEN 读 token")
+                   help="要求已设置 DATAANALYST_AGENT_TOKEN（覆盖密码表）")
     p.add_argument("--keep-token", action="store_true",
-                   help="Keychain 已有 token 则不覆盖")
+                   help="沿用已有 DATAANALYST_AGENT_TOKEN，不交互粘贴")
     p.add_argument("--keep-rms", action="store_true",
-                   help="Keychain 已有 RMS 凭据则不覆盖")
+                   help="沿用已有 RMS_<SHOP>_* 环境变量")
+    p.add_argument("--skip-secret-check", action="store_true",
+                   help="跳过密码表拉取校验（不推荐）")
     p.add_argument("--skip-heartbeat", action="store_true")
     p.add_argument("--verify-rms", action="store_true",
                    help="用 Playwright 验证 R-Login 并写 state/<shop>.json")
@@ -575,7 +604,7 @@ def build_parser() -> argparse.ArgumentParser:
     p.set_defaults(func=cmd_login)
 
     p = sub.add_parser("status", parents=[common],
-                       help="查看 Keychain / LaunchAgent / caffeinate / 心跳")
+                       help="查看 JDY_MCP / token 环境 / LaunchAgent / 心跳")
     p.add_argument("--offline", action="store_true", help="不打中心心跳")
     p.set_defaults(func=cmd_status)
 
@@ -600,21 +629,27 @@ def build_parser() -> argparse.ArgumentParser:
                        help="移除 Agent 与 caffeinate LaunchAgent")
     p.set_defaults(func=cmd_uninstall_service)
 
-    adm = sub.add_parser("admin", help="超管：备齐凭据 / 清单 / bootstrap")
+    adm = sub.add_parser("admin", help="超管：清单 / 校验密码表 / 紧急 bootstrap")
     adm_sub = adm.add_subparsers(dest="admin_cmd", required=True)
 
     p = adm_sub.add_parser("checklist", parents=[common],
-                           help="打印某店开店清单（含签发 token 命令）")
+                           help="打印某店开店清单（与销量计算系统凭据说明）")
     p.set_defaults(func=cmd_admin_checklist)
 
+    p = adm_sub.add_parser("verify-secrets", parents=[common],
+                           help="探测 JDY_MCP → API Key（与销量系统相同；不打印）")
+    p.add_argument("--verify-rms", action="store_true")
+    p.add_argument("--headed", action="store_true")
+    p.set_defaults(func=cmd_admin_verify_secrets)
+
     p = adm_sub.add_parser("set-rms", parents=[common],
-                           help="交互写入本店 RMS Keychain")
+                           help="已废弃：等同 verify-secrets")
     p.add_argument("--verify-rms", action="store_true")
     p.add_argument("--headed", action="store_true")
     p.set_defaults(func=cmd_admin_set_rms)
 
     p = adm_sub.add_parser("write-bootstrap", parents=[common],
-                           help="把 token 写成 600 一次性文件给门店 login 用")
+                           help="紧急：把 token 写成 600 文件（正式请写简道云）")
     p.add_argument("--out", help="输出路径（默认 /tmp/dataanalyst-<SHOP>-bootstrap.json）")
     p.set_defaults(func=cmd_admin_write_bootstrap)
 

package/jdy_secrets.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""简道云密码 / MCP —— 与「销量计算系统」jdy_api.py + config.py 一致。
+
+本机钥匙串只存一件（店机由用户维护；本开发机可以没有）：
+  service = JDY_MCP
+  account = 服务器URL
+
+环境变量优先：JDY_MCP_URL
+
+API Key：MCP member_data_list 查【密码PASSWORDパスワード】，
+Title 精确匹配 JDY_API_KEY_TITLE（= config 中「api key 精细化运营」）。
+不硬编码 Key；不打印 secret。
+
+实现说明：逻辑与 zip 内 jdy_api 相同。若未安装 mcp/keyring，
+则用等价的 urllib JSON-RPC / security CLI 完成同一调用（filter / fields / Title）。
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import re
+import subprocess
+import time
+from typing import Any, Optional
+from urllib.error import URLError
+from urllib.request import Request, urlopen
+
+log = logging.getLogger("jdy")
+
+# ── 与销量计算系统 config.py 同名常量 ─────────────────────
+JDY_PWD_APP_ID = "5a6f241ae24fd5382436f985"
+JDY_PWD_ENTRY_ID = "67188a2824e6cc898a1d7d7f"
+JDY_PWD_F_TITLE = "_widget_1729661480436"       # Title (text)
+JDY_PWD_F_PASSWORD = "_widget_1729661480439"    # Password (text)
+JDY_API_KEY_TITLE = "api key 精细化运营"
+JDY_MCP_KEYRING_SERVICE = "JDY_MCP"
+JDY_MCP_KEYRING_ACCOUNT = "服务器URL"
+
+# 别名（旧调用方）
+JDY_MCP_SERVICE = JDY_MCP_KEYRING_SERVICE
+JDY_MCP_ACCOUNT = JDY_MCP_KEYRING_ACCOUNT
+
+_API_KEY: Optional[str] = None
+
+
+def _get_mcp_url() -> str:
+    """MCP URL 优先级：环境变量 > 钥匙串（与销量计算系统 jdy_api 一致）"""
+    env = os.environ.get("JDY_MCP_URL")
+    if env:
+        return env
+    try:
+        import keyring
+        v = keyring.get_password(JDY_MCP_KEYRING_SERVICE,
+                                 JDY_MCP_KEYRING_ACCOUNT)
+        if v:
+            return v
+    except Exception:
+        pass
+    # keyring 未装或读失败时：同条目的 security CLI（仍是 JDY_MCP/服务器URL）
+    try:
+        r = subprocess.run(
+            ["security", "find-generic-password",
+             "-s", JDY_MCP_KEYRING_SERVICE,
+             "-a", JDY_MCP_KEYRING_ACCOUNT, "-w"],
+            capture_output=True, text=True,
+        )
+        if r.returncode == 0 and (r.stdout or "").strip():
+            return (r.stdout or "").rstrip("\n")
+    except Exception:
+        pass
+    raise RuntimeError(
+        "未找到 JDY MCP URL：请设置环境变量 JDY_MCP_URL "
+        "或钥匙串条目 JDY_MCP/服务器URL"
+    )
+
+
+def get_mcp_url() -> str:
+    return _get_mcp_url()
+
+
+def mcp_url_present() -> bool:
+    try:
+        _get_mcp_url()
+        return True
+    except RuntimeError:
+        return False
+
+
+async def _fetch_api_key_async() -> str:
+    """MCP member_data_list 查询密码表单，按 Title 精确匹配取 Password 字段。"""
+    # 优先与销量系统相同的 mcp SDK
+    try:
+        from mcp import ClientSession
+        from mcp.client.streamable_http import streamable_http_client
+    except ImportError:
+        return _fetch_api_key_urllib()
+
+    async with streamable_http_client(_get_mcp_url()) as (read, write):
+        async with ClientSession(read, write) as session:
+            await session.initialize()
+            await asyncio.sleep(1)  # JDY MCP 限流 3 次/秒
+            res = await session.call_tool("member_data_list", {
+                "app_id": JDY_PWD_APP_ID,
+                "entry_id": JDY_PWD_ENTRY_ID,
+                "limit": 20,
+                "fields": [JDY_PWD_F_TITLE, JDY_PWD_F_PASSWORD],
+                "filter": {"rel": "and", "cond": [
+                    {"field": JDY_PWD_F_TITLE, "type": "text",
+                     "method": "like", "value": ["api key"]},
+                ]},
+            })
+            if res.is_error:
+                raise RuntimeError(f"MCP member_data_list 失败: {res.content}")
+            for block in res.content:
+                if getattr(block, "type", None) != "text":
+                    continue
+                rows = json.loads(block.text).get("data", [])
+                for row in rows:
+                    if row.get(JDY_PWD_F_TITLE) == JDY_API_KEY_TITLE:
+                        key = row.get(JDY_PWD_F_PASSWORD)
+                        if key:
+                            log.info("JDY API Key 已从密码表单读取: %s",
+                                     JDY_API_KEY_TITLE)
+                            return key
+    raise RuntimeError(
+        f"密码表单中未找到 Title={JDY_API_KEY_TITLE!r} 的 API Key"
+    )
+
+
+def _rpc(url: str, method: str, params: dict) -> dict:
+    body = json.dumps(
+        {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
+    ).encode()
+    req = Request(
+        url, data=body, method="POST",
+        headers={"Content-Type": "application/json",
+                 "Accept": "application/json, text/event-stream"},
+    )
+    last_err: Exception | None = None
+    for attempt in range(3):
+        try:
+            with urlopen(req, timeout=40) as resp:
+                raw = resp.read().decode("utf-8", "replace")
+            break
+        except (URLError, TimeoutError, ConnectionError) as exc:
+            last_err = exc
+            time.sleep(1.5 * (attempt + 1))
+    else:
+        raise RuntimeError(f"JDY MCP 网络失败: {type(last_err).__name__}")
+    m = re.search(r"data:\s*(\{.*\})", raw, re.S)
+    data = json.loads(m.group(1) if m else raw)
+    if "error" in data:
+        err = data["error"]
+        msg = err.get("message", err) if isinstance(err, dict) else err
+        raise RuntimeError(f"JDY MCP {method} 失败: {msg}")
+    return data.get("result", {})
+
+
+def _fetch_api_key_urllib() -> str:
+    """无 mcp 包时：同一 member_data_list 参数，经 JSON-RPC 调用。"""
+    url = _get_mcp_url()
+    time.sleep(1)
+    res = _rpc(url, "tools/call", {
+        "name": "member_data_list",
+        "arguments": {
+            "app_id": JDY_PWD_APP_ID,
+            "entry_id": JDY_PWD_ENTRY_ID,
+            "limit": 20,
+            "fields": [JDY_PWD_F_TITLE, JDY_PWD_F_PASSWORD],
+            "filter": {"rel": "and", "cond": [
+                {"field": JDY_PWD_F_TITLE, "type": "text",
+                 "method": "like", "value": ["api key"]},
+            ]},
+        },
+    })
+    text = ""
+    for c in res.get("content", []) or []:
+        if c.get("type") == "text":
+            text = c.get("text") or ""
+            break
+    if not text:
+        raise RuntimeError("MCP member_data_list 无 text 内容")
+    if text.strip().startswith("API error"):
+        raise RuntimeError(f"MCP member_data_list 失败: {text.strip()[:200]}")
+    body: Any = json.loads(text)
+    rows = body.get("data") if isinstance(body, dict) else body
+    for row in rows or []:
+        if not isinstance(row, dict):
+            continue
+        if row.get(JDY_PWD_F_TITLE) == JDY_API_KEY_TITLE:
+            key = row.get(JDY_PWD_F_PASSWORD)
+            if key:
+                log.info("JDY API Key 已从密码表单读取: %s", JDY_API_KEY_TITLE)
+                return key
+    raise RuntimeError(
+        f"密码表单中未找到 Title={JDY_API_KEY_TITLE!r} 的 API Key"
+    )
+
+
+def get_api_key() -> str:
+    """同步接口：动态读取 JDY API Key（不落盘、不硬编码、不打印）。"""
+    global _API_KEY
+    if _API_KEY:
+        return _API_KEY
+    try:
+        # mcp SDK 路径
+        import mcp  # noqa: F401
+        key = asyncio.run(_fetch_api_key_async())
+    except ImportError:
+        key = _fetch_api_key_urllib()
+    except Exception:
+        # SDK 可用但失败时，再试 urllib 等价路径
+        try:
+            key = _fetch_api_key_urllib()
+        except Exception as exc:
+            raise RuntimeError(
+                f"读取 JDY API Key 失败: {type(exc).__name__}"
+            ) from exc
+    _API_KEY = key
+    return key
+
+
+def clear_cache() -> None:
+    global _API_KEY
+    _API_KEY = None

package/keychain_util.py

@@ -1,115 +1,108 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""macOS Keychain 读写（不打印 secret）。
+"""凭据入口（兼容旧 import 名 keychain_util）。
 
-与现有约定对齐：
-  · Agent token  service = dataanalyst-agent-token  account = $USER
-  · R-Login 第一组  service = dataanalyst/rms/<SHOP>-rlogin  account = R-Login ID
-  · Rakuten SSO 第二组  service = dataanalyst/rms/<SHOP>-ai  account = 邮箱
+与「销量计算系统」一致：
+  · 本机 Keychain 只用于 JDY_MCP / 服务器URL（店机维护；本开发机可无）
+  · JDY API Key 经 MCP 密码表读取（Title = api key 精细化运营）
+
+已废弃（不再读写）：
+  · dataanalyst-agent-token
+  · dataanalyst/rms/<SHOP>-rlogin / -ai
+
+Agent token：环境变量 DATAANALYST_AGENT_TOKEN（或 login --bootstrap 注入本进程）。
+RMS 登录：env-file / 环境变量 RMS_<SHOP>_*，见 rms_browser_login。
 """
 from __future__ import annotations
 
 import os
-import re
-import subprocess
 from typing import Optional
 
-AGENT_TOKEN_SERVICE = "dataanalyst-agent-token"
+import jdy_secrets as jdy
 
+AGENT_TOKEN_SERVICE = "DEPRECATED:dataanalyst-agent-token"
+JDY_MCP_SERVICE = jdy.JDY_MCP_KEYRING_SERVICE
+JDY_MCP_ACCOUNT = jdy.JDY_MCP_KEYRING_ACCOUNT
+JDY_API_KEY_TITLE = jdy.JDY_API_KEY_TITLE
 
-def rms_rlogin_service(shop: str) -> str:
-    return f"dataanalyst/rms/{shop.upper()}-rlogin"
 
+def get_mcp_url() -> str:
+    return jdy.get_mcp_url()
 
-def rms_ai_service(shop: str) -> str:
-    return f"dataanalyst/rms/{shop.upper()}-ai"
 
+def get_api_key() -> str:
+    """与销量计算系统 jdy_api.get_api_key 相同。勿打印返回值。"""
+    return jdy.get_api_key()
 
-def _run(cmd: list[str], *, check: bool = True) -> subprocess.CompletedProcess:
-    return subprocess.run(cmd, capture_output=True, text=True, check=check)
 
-
-def has_generic(service: str, account: Optional[str] = None) -> bool:
-    cmd = ["security", "find-generic-password", "-s", service]
-    if account:
-        cmd += ["-a", account]
-    r = _run(cmd, check=False)
-    return r.returncode == 0
-
-
-def get_password(service: str, account: Optional[str] = None) -> str:
-    """读取密码；失败抛 RuntimeError。调用方不得打印返回值。"""
-    cmd = ["security", "find-generic-password", "-s", service, "-w"]
-    if account:
-        cmd += ["-a", account]
-    r = _run(cmd, check=False)
-    if r.returncode != 0:
-        raise RuntimeError(f"Keychain 缺少条目: {service}")
-    return (r.stdout or "").rstrip("\n")
-
-
-def get_account(service: str) -> str:
-    r = _run(["security", "find-generic-password", "-s", service], check=False)
-    if r.returncode != 0:
-        raise RuntimeError(f"Keychain 缺少条目: {service}")
-    m = re.search(r'"acct"<blob>="([^"]*)"', r.stdout or "")
-    if not m:
-        raise RuntimeError(f"Keychain 缺 account: {service}")
-    return m.group(1)
-
-
-def set_generic(service: str, account: str, secret: str, *,
-                label: str = "") -> None:
-    """写入/覆盖 generic password；secret 不进日志。"""
-    if not secret:
-        raise ValueError(f"拒绝写入空 secret: {service}")
-    cmd = ["security", "add-generic-password", "-U",
-           "-s", service, "-a", account, "-w", secret]
-    if label:
-        cmd += ["-l", label]
-    r = _run(cmd, check=False)
-    if r.returncode != 0:
-        err = (r.stderr or r.stdout or "").strip() or f"exit {r.returncode}"
-        # 不回显可能含参数的完整命令
-        raise RuntimeError(f"Keychain 写入失败 ({service}): {err[:200]}")
-
-
-def set_agent_token(token: str, *, account: Optional[str] = None) -> None:
-    acct = account or os.environ.get("USER", "")
-    if not acct:
-        raise RuntimeError("无法确定 Keychain account（$USER 为空）")
-    if not token.startswith("da_"):
-        raise ValueError("Agent token 应以 da_ 开头")
-    set_generic(AGENT_TOKEN_SERVICE, acct, token,
-                label="dataanalyst agent token")
-
-
-def get_agent_token() -> str:
-    env = os.environ.get("DATAANALYST_AGENT_TOKEN", "").strip()
+def get_agent_token(shop: Optional[str] = None) -> str:
+    """中心 Agent token：只从环境变量读（不再走 dataanalyst Keychain / 自创 JDY Title）。"""
+    env = (os.environ.get("DATAANALYST_AGENT_TOKEN") or "").strip()
     if env:
         return env
-    acct = os.environ.get("USER", "")
-    try:
-        return get_password(AGENT_TOKEN_SERVICE, acct or None)
-    except RuntimeError:
-        # 兼容早期未指定 -a 的写法
-        return get_password(AGENT_TOKEN_SERVICE)
+    raise RuntimeError(
+        "未设置 DATAANALYST_AGENT_TOKEN。"
+        "请 export、或 genduo-desk login --bootstrap / --token-env"
+    )
 
 
-def set_rms_creds(shop: str, *, rlogin_id: str, rlogin_password: str,
-                  sso_user: str, sso_password: str) -> None:
-    shop_u = shop.upper()
-    set_generic(rms_rlogin_service(shop_u), rlogin_id, rlogin_password,
-                label=f"{shop_u} R-Login")
-    set_generic(rms_ai_service(shop_u), sso_user, sso_password,
-                label=f"{shop_u} Rakuten SSO")
+def rms_env_prefix(shop: str) -> str:
+    return f"RMS_{shop.upper()}_"
+
+
+def get_rms_creds(shop: str) -> dict[str, str]:
+    """从环境变量读 RMS 两组。勿打印。"""
+    p = rms_env_prefix(shop)
+    out = {
+        "rlogin_id": (os.environ.get(p + "LOGIN_ID") or "").strip(),
+        "rlogin_password": (os.environ.get(p + "PASSWORD") or "").strip(),
+        "sso_user": (os.environ.get(p + "SHOP_USER") or "").strip(),
+        "sso_password": (os.environ.get(p + "SHOP_PASSWORD") or "").strip(),
+    }
+    missing = [k for k, v in out.items() if not v]
+    if missing:
+        raise RuntimeError(
+            f"{shop.upper()} 缺少环境变量 {p}*（缺: {', '.join(missing)}）；"
+            "见 rms_browser_login --env-file"
+        )
+    return out
 
 
 def rms_creds_present(shop: str) -> dict:
-    """只返回是否存在，不读出密码。"""
-    shop_u = shop.upper()
+    """布尔：mcp_url / api_key 不在此探测网络；agent_token / rlogin / ai 看环境变量。"""
+    p = rms_env_prefix(shop)
     return {
-        "rlogin": has_generic(rms_rlogin_service(shop_u)),
-        "ai": has_generic(rms_ai_service(shop_u)),
-        "agent_token": has_generic(AGENT_TOKEN_SERVICE),
+        "mcp_url": jdy.mcp_url_present(),
+        "agent_token": bool((os.environ.get("DATAANALYST_AGENT_TOKEN") or "").strip()),
+        "rlogin": bool((os.environ.get(p + "LOGIN_ID") or "").strip()
+                       and (os.environ.get(p + "PASSWORD") or "").strip()),
+        "ai": bool((os.environ.get(p + "SHOP_USER") or "").strip()
+                   and (os.environ.get(p + "SHOP_PASSWORD") or "").strip()),
     }
+
+
+def has_generic(service: str, account: Optional[str] = None) -> bool:
+    if service == JDY_MCP_SERVICE:
+        return jdy.mcp_url_present()
+    return False
+
+
+def set_generic(*_a, **_k) -> None:
+    raise RuntimeError(
+        "已废弃：不再写入 dataanalyst/* Keychain。"
+        "与销量计算系统一致，本机只维护 JDY_MCP / 服务器URL。"
+    )
+
+
+def set_agent_token(*_a, **_k) -> None:
+    raise RuntimeError(
+        "已废弃：不再写入 dataanalyst-agent-token。"
+        "请使用环境变量 DATAANALYST_AGENT_TOKEN 或 login --bootstrap。"
+    )
+
+
+def set_rms_creds(*_a, **_k) -> None:
+    raise RuntimeError(
+        "已废弃：不再写入 dataanalyst/rms/* Keychain。"
+        "请使用 RMS_<SHOP>_* 环境变量或 rms_browser_login --env-file。"
+    )

package/local_config.py

@@ -9,7 +9,7 @@ from pathlib import Path
 
 SHOPS = ["0RT1", "3RT1", "5RT1", "3RT2", "5RT2", "7RT2"]
 DEFAULT_BASE = "https://dataanalyst.jp"
-VERSION = "0.4.0"
+VERSION = "0.5.0"
 HERE = Path(__file__).resolve().parent
 # 优先用户级配置，其次包内 state（POC 兼容）
 USER_CFG = Path.home() / ".config" / "dataanalyst-agent" / "config.json"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@genduo/desk",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Local Mac desk agent CLI for genduo",
   "bin": {
     "genduo-desk": "bin/genduo-desk.js"
@@ -11,6 +11,7 @@
     "cli.py",
     "api_client.py",
     "keychain_util.py",
+    "jdy_secrets.py",
     "local_config.py",
     "run.py",
     "rms_browser_login.py",

package/rms_browser_login.py

@@ -5,14 +5,16 @@
 NOTE (npm / shop CLI):
   源真相仍是 monorepo `tools/rms_browser_login.py`（VPS 路径也用那份）。
   本文件是 collector-agent 的 vendored 副本，供 `npm i -g dataanalyst-agent`
-  后门店机无 monorepo 也能跑 `--verify-rms`。打包前若源文件有变，请同步拷贝。
+  后门店机无 monorepo 也能跑 `--verify-rms`。打包前若源文件有变，请同步拷贝；
+  勿再读 dataanalyst/rms/* Keychain；JDY_MCP 见 jdy_secrets.py（与销量系统一致）。
 
 Rakuten 已把 R-Login 切到 Rakuten 会员 SSO：
   1. glogin 填 R-Login ID / 密码（第一组）；
   2. Rakuten 会员填邮箱 / 密码（第二组）；
   3. R-Login 提示页「次へ」→ RMS 主菜单「RMSを利用します」。
 
-凭据从 env 文件或 macOS Keychain 读，不打印。会话保存为 600 的 storage_state。
+凭据从 env 文件读，不打印。会话保存为 600 的 storage_state。
+简道云 JDY_MCP / API Key 逻辑见 collector-agent/jdy_secrets.py（与销量计算系统一致）。
 
 用法：
     # VPS / env 文件
@@ -21,16 +23,14 @@ Rakuten 已把 R-Login 切到 Rakuten 会员 SSO：
       --env-file /etc/dataanalyst/rms.env \\
       --out /etc/dataanalyst/rms_session/7RT2.json
 
-    # 本机 Keychain（service: dataanalyst/rms/<shop>-rlogin 与 -ai）
-    python tools/rms_browser_login.py --shop 7RT2 --from-keychain \\
+    # 本机：Keychain 仅 JDY_MCP；RMS 凭据从简道云密码表取
+    python tools/rms_browser_login.py --shop 7RT2 --from-jdy \\
       --out tools/collector-agent/state/7RT2.json
 """
 from __future__ import annotations
 
 import argparse
 import os
-import re
-import subprocess
 import sys
 from pathlib import Path
 
@@ -53,36 +53,16 @@ def load_env(path: str) -> dict:
     return out
 
 
-def keychain_get(service: str) -> tuple[str, str]:
-    """Return (account, password) from macOS Keychain. Never prints password."""
-    meta = subprocess.check_output(
-        ["security", "find-generic-password", "-s", service],
-        stderr=subprocess.DEVNULL,
-    ).decode("utf-8", errors="replace")
-    m = re.search(r'"acct"<blob>="([^"]*)"', meta)
-    if not m:
-        raise SystemExit(f"Keychain 缺 account: {service}")
-    account = m.group(1)
-    password = subprocess.check_output(
-        ["security", "find-generic-password", "-s", service, "-w"],
-        stderr=subprocess.DEVNULL,
-    ).decode("utf-8", errors="replace").rstrip("\n")
-    if not password:
-        raise SystemExit(f"Keychain 缺 password: {service}")
-    return account, password
 
 
 def load_from_keychain(shop: str) -> dict:
-    shop_u = shop.upper()
-    login_id, password = keychain_get(f"dataanalyst/rms/{shop_u}-rlogin")
-    sso_user, sso_pass = keychain_get(f"dataanalyst/rms/{shop_u}-ai")
-    prefix = f"RMS_{shop_u}_"
-    return {
-        prefix + "LOGIN_ID": login_id,
-        prefix + "PASSWORD": password,
-        prefix + "SHOP_USER": sso_user,
-        prefix + "SHOP_PASSWORD": sso_pass,
-    }
+    """已废弃：不再读 dataanalyst/rms/* Keychain。请用 --env-file 或环境变量。"""
+    raise SystemExit(
+        "已废弃 --from-keychain（dataanalyst/rms/*）。"
+        "请使用 --env-file 或环境变量 RMS_<SHOP>_LOGIN_ID/PASSWORD/SHOP_USER/SHOP_PASSWORD。"
+    )
+
+
 
 
 def _try_click(page, role: str, name: str, timeout: int = 4000) -> bool:
@@ -185,7 +165,7 @@ def main() -> int:
     ap.add_argument("--shop", required=True)
     ap.add_argument("--env-file", default="/etc/dataanalyst/rms.env")
     ap.add_argument("--from-keychain", action="store_true",
-                    help="从 macOS Keychain 读 dataanalyst/rms/<SHOP>-rlogin 与 -ai")
+                    help="已废弃（原 dataanalyst/rms/* Keychain）")
     ap.add_argument("--out", help="默认 tools/collector-agent/state/<shop>.json（本机）")
     ap.add_argument("--screenshot", help="可选截图路径（不含密钥）")
     ap.add_argument("--headed", action="store_true")
@@ -193,7 +173,6 @@ def main() -> int:
     out = a.out or f"tools/collector-agent/state/{a.shop.upper()}.json"
     try:
         if a.from_keychain:
-            print("cred_source", "keychain")
             env = load_from_keychain(a.shop)
             # Confirm accounts only (no passwords)
             prefix = f"RMS_{a.shop.upper()}_"

package/run.py

@@ -244,7 +244,7 @@ def main(argv: list[str] | None = None) -> int:
         return 2
     base = conf.get("base") or cfg.DEFAULT_BASE
     try:
-        token = kc.get_agent_token()
+        token = kc.get_agent_token(shop)
     except RuntimeError as exc:
         log.error("%s", exc)
         return 2