@mrrisega/dsh-remote 0.7.12-beta.4 → 0.7.12-beta.6

package/packages/dsh-remote-web/lib/index.js

@@ -7802,7 +7802,7 @@ function imBotsView(relayDir) {
       sdkVersion: feishuCfgOf(bots).sdkVersion,
     },
     status: Object.assign({}, wecomStatusOf(stFile), {
-      dingtalk: imPlatformStatusOf(stFile, "dingtalk"),
+      dingtalk: Object.assign(imPlatformStatusOf(stFile, "dingtalk"), { auth: imDingtalkAuthStatusOf(relayDir) }),
       feishu: imPlatformStatusOf(stFile, "feishu"),
       deps: { feishu: feishuDepsInfo(relayDir) },
     }),
@@ -8095,211 +8095,61 @@ function startFeishuInstall(relayDir, opts = {}) {
   return { ok: true, started: true, taskId, deps: { feishu: feishuDepsInfo(relayDir) } };
 }
 
-// ── 钉钉「扫码一键创建机器人」（2026-11-08，官方 connector 同款 device-flow）─────────────
-// 流程（服务端代跑，device_code 只存内存、不下发浏览器）：
-//   POST .../app/registration/init  {source:"DING_DWS_CLAW"} → {nonce}
-//   POST .../app/registration/begin {nonce}                 → {device_code, verification_uri_complete, interval, expires_in}
-//   POST .../app/registration/poll  {device_code}           → {status:"WAITING"|"SUCCESS", client_id, client_secret}
-//
-// ★ 2026-11-08 生产实测修正（业主）：**轮询必须在节点半后台跑**，面板只查状态。
-//   原实现让面板每 2s 轮询、还把 TTL 设成 2 分钟 —— 但钉钉 device-flow 的 expires_in 是 7200 秒，
-//   用户「点按钮→手机扫码→页面加载→点一键创建」很容易超过 2 分钟 → 被误判过期。
-//   现在：begin 即启动 setInterval(~3s) 后台轮询，关闭面板/刷新页面都不影响；TTL 按钉钉 expires_in。
-const DINGTALK_REG_BASE = "https://oapi.dingtalk.com/app/registration";
-const DINGTALK_AUTH_TTL_MS = 7200 * 1000;          // 兜底上限：钉钉 device-flow 的 expires_in（7200s）
-const DINGTALK_AUTH_POLL_MS = 3000;                // 后台轮询间隔（测试可用 config.imAuthPollMs 覆盖）
-const dingtalkAuthSessions = new Map();            // authId → session（含后台 timer，绝不落盘）
-const dingtalkAuthSuperseded = new Map();          // 被新授权作废的 authId → at（查询时回 cancelled）
-
-/** 面向用户的中文人话（错误里**绝不出现裸 code / 裸 ok**）。 */
+// ── 钉钉「扫码一键创建机器人」：**委托桥侧持久化授权**（2026-11-08 架构修正）────────────
+// 生产踩坑：授权会话曾经存在插件进程内存里 —— 宿主重启/面板关掉就丢，用户遇到
+// 「钉钉说连接成功、我们没接住」。现在插件**不碰钉钉接口、不存内存会话**：
+//   · 插件写命令文件 <relayDir>/im-dingtalk-auth-cmd.json {action:"begin"|"cancel", at}
+//   · 桥（clients/dsh-remote/dingtalk-auth.mjs）持久化 device_code 并断点续轮询，处理完删命令文件
+//   · 桥把进度写进 im-bot-status.json 的 dingtalk.auth = {state,url,expiresAt,remainingSec,clientIdTail,message}
+//   · 成功后桥**自己**写 im-bots.json 的 dingtalk 段并连上 —— 插件只读状态
+const IM_DINGTALK_AUTH_CMD_FILE = "im-dingtalk-auth-cmd.json";
+
+/** 面向用户的中文人话（错误里**绝不出现裸 code / 裸 ok / errcode**）。 */
 const DINGTALK_AUTH_MSG = {
   network_error: "连不上钉钉接口，请检查网络后重试",
   dingtalk_api_rejected: "钉钉拒绝了请求，请稍后重试",
   expired: "授权已过期，请点「重试扫码」生成新的授权链接",
-  cancelled: "这次授权已被新的授权取代，请用最新链接完成确认",
+  cancelled: "这次授权已取消，请重新发起",
   write_failed: "拿到的凭据保存失败（磁盘/权限问题），请检查后重试"
 };
 function dingTalkHumanMessage(code, fallbackMessage) {
   const c = String(code || "");
   const msg = String(fallbackMessage || "").trim();
-  // 只接受"看起来是人话"的 message：含中文、且不是裸 code/ok/JSON 片段
   const looksHuman = /[\u4e00-\u9fa5]/.test(msg) && !/^\s*[{[]/.test(msg);
   if (looksHuman) return msg;
   if (DINGTALK_AUTH_MSG[c]) return DINGTALK_AUTH_MSG[c];
   return "操作失败，请稍后重试";
 }
 
-function jsonPostForAuth(fetchImpl, url, payload) {
-  return fetchImpl(url, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(payload || {}),
-    signal: AbortSignal.timeout(8000),
-  }).then(async (r) => {
-    let body = null;
-    try { body = await r.json(); } catch { body = null; }
-    return { ok: !!r.ok, status: r.status, body: body || {} };
-  });
-}
-
-/** 后台轮询一次（同一 session 不并发；成功后写盘并停表）。 */
-async function dingtalkAuthPollOnce(authId, opts = {}) {
-  const sess = dingtalkAuthSessions.get(String(authId || ""));
-  if (!sess || sess.inFlight) return sess;
-  if (sess.state !== "waiting") return sess;
-  if (Date.now() > sess.expiresAt) {
-    sess.state = "expired";
-    sess.message = dingTalkHumanMessage("expired");
-    stopDingAuthTimer(sess);
-    return sess;
-  }
-  const fetchImpl = typeof opts.imAuthFetch === "function" ? opts.imAuthFetch : fetch;
-  sess.inFlight = true;
-  try {
-    const r = await jsonPostForAuth(fetchImpl, `${DINGTALK_REG_BASE}/poll`, { device_code: sess.deviceCode });
-    const b = r.body || {};
-    const st = String(b.status || "").toUpperCase();
-    if (st === "WAITING" || st === "PENDING") return sess;
-    if (st === "SUCCESS" || (b.client_id && b.client_secret)) {
-      const saved = saveDingtalkScannedCredentials(sess.relayDir, b.client_id, b.client_secret);
-      if (!saved.ok) {
-        sess.state = "failed";
-        sess.message = dingTalkHumanMessage(saved.code, saved.message);
-      } else {
-        const cid = String(b.client_id || "");
-        sess.state = "success";
-        sess.clientIdTail = cid.length > 4 ? cid.slice(-4) : cid;
-        sess.credentialSource = "scan";
-      }
-      stopDingAuthTimer(sess);
-      return sess;
-    }
-    // 钉钉明确拒绝（创建被取消/参数过期等）：用中文人话，绝不把 errmsg 裸值直接渲染
-    sess.state = "failed";
-    sess.message = dingTalkHumanMessage("dingtalk_api_rejected", b.message || b.errmsg);
-    stopDingAuthTimer(sess);
-    return sess;
-  } catch (e) {
-    // 网络抖动**不作废授权**（后台继续轮询直到 expires_in）—— 只有明确拒绝/过期才终止。
-    return sess;
-  } finally {
-    sess.inFlight = false;
-  }
-}
-
-function stopDingAuthTimer(sess) {
-  if (!sess) return;
-  try { if (sess.timer) clearInterval(sess.timer); } catch { /* 忽略 */ }
-  sess.timer = null;
-}
-
-/**
- * 开始一次钉钉扫码授权（POST /dsh-remote/im-dingtalk-auth/begin）。
- * 同一 relayDir 同时只保留一个会话：begin 时把旧的作废（旧 authId 后续查询回 cancelled）。
- * TTL 按钉钉返回的 expires_in（生产实测 7200s），后台 setInterval 轮询，关闭面板不影响。
- */
-async function beginDingtalkAuth(relayDir, opts = {}) {
-  const fetchImpl = typeof opts.imAuthFetch === "function" ? opts.imAuthFetch : fetch;
-  // 作废旧会话（同时停掉它们的后台轮询表）
-  for (const [id, sess] of dingtalkAuthSessions) {
-    if (sess.relayDir === relayDir) {
-      stopDingAuthTimer(sess);
-      dingtalkAuthSessions.delete(id);
-      dingtalkAuthSuperseded.set(id, Date.now());
-    }
-  }
-  while (dingtalkAuthSuperseded.size > 20) {
-    const first = dingtalkAuthSuperseded.keys().next().value;
-    dingtalkAuthSuperseded.delete(first);
-  }
-  let init;
-  try {
-    init = await jsonPostForAuth(fetchImpl, `${DINGTALK_REG_BASE}/init`, { source: "DING_DWS_CLAW" });
-  } catch {
-    return { ok: false, code: "network_error", message: dingTalkHumanMessage("network_error") };
-  }
-  const nonce = init.ok && init.body && typeof init.body.nonce === "string" ? init.body.nonce : "";
-  if (!nonce) return { ok: false, code: "dingtalk_api_rejected", message: dingTalkHumanMessage("dingtalk_api_rejected") };
-  let begin;
-  try {
-    begin = await jsonPostForAuth(fetchImpl, `${DINGTALK_REG_BASE}/begin`, { nonce });
-  } catch {
-    return { ok: false, code: "network_error", message: dingTalkHumanMessage("network_error") };
-  }
-  const b = begin.body || {};
-  const deviceCode = typeof b.device_code === "string" ? b.device_code : "";
-  const url = typeof b.verification_uri_complete === "string" ? b.verification_uri_complete : "";
-  if (!begin.ok || !deviceCode || !url) {
-    return { ok: false, code: "dingtalk_api_rejected", message: dingTalkHumanMessage("dingtalk_api_rejected") };
-  }
-  const authId = `ding-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  const interval = Math.max(1, Math.min(10, Number(b.interval) || 3));
-  // ★ TTL 用钉钉的 expires_in（生产 7200s），不再用以前写死的 2 分钟
-  const expiresIn = Math.max(60, Math.min(7200, Number(b.expires_in) || 7200));
-  const now = Date.now();
-  const sess = {
-    relayDir, deviceCode, url, interval,
-    createdAt: now,
-    expiresAt: Math.min(now + expiresIn * 1000, now + DINGTALK_AUTH_TTL_MS),
-    state: "waiting", message: "", inFlight: false, timer: null, clientIdTail: "", credentialSource: ""
-  };
-  // 启动后台轮询：面板关掉/刷新都不影响，用户 2 小时内确认都能成功
-  const pollMs = Math.max(10, Number(opts.imAuthPollMs) || DINGTALK_AUTH_POLL_MS);
-  try {
-    sess.timer = setInterval(() => { void dingtalkAuthPollOnce(authId, opts); }, pollMs);
-    sess.timer.unref?.();
-  } catch { sess.timer = null; }
-  dingtalkAuthSessions.set(authId, sess);
-  return { ok: true, authId, url, interval, expiresIn };
+/** 原子写命令文件（0600；桥是另一个进程，tmp+rename 防半写）。 */
+function writeDingtalkAuthCmd(relayDir, action) {
+  const file = join(relayDir, IM_DINGTALK_AUTH_CMD_FILE);
+  const tmp = `${file}.tmp`;
+  mkdirSync(relayDir, { recursive: true });
+  writeFileSync(tmp, JSON.stringify({ action, at: Date.now() }) + "\n", { mode: 0o600 });
+  try { chmodSync(tmp, 0o600); } catch { /* 非 POSIX */ }
+  renameSync(tmp, file);
+  try { chmodSync(file, 0o600); } catch { /* 忽略 */ }
+  return { ok: true };
 }
 
-/** 把扫码拿到的凭据写进 im-bots.json 的 dingtalk 段（0600 原子写；保留其它字段，自动 enabled）。 */
-function saveDingtalkScannedCredentials(relayDir, clientId, clientSecret) {
-  const bots = readImBots(relayDir);
-  const cur = dingtalkCfgOf(bots);
-  const next = {
-    ...cur,
-    enabled: true,
-    clientId: String(clientId || "").trim(),
-    clientSecret: String(clientSecret || "").trim(),
-    // 扫码流程只给 client_id/client_secret；robotCode 由桥连上后自动补齐/发现
-    credentialSource: "scan",
+/** 读桥写的授权进度（im-bot-status.json 的 dingtalk.auth；白名单 + 人话兜底）。 */
+function imDingtalkAuthStatusOf(relayDir) {
+  const st = readImBotStatus(relayDir);
+  const d = st && st.dingtalk && typeof st.dingtalk === "object" ? st.dingtalk : {};
+  const a = d.auth && typeof d.auth === "object" ? d.auth : {};
+  const states = ["idle", "waiting", "success", "failed", "expired"];
+  const state = states.includes(strOf(a.state)) ? strOf(a.state) : "idle";
+  const url = strOf(a.url);
+  return {
+    state,
+    // 只透出 https 链接（防止状态文件里塞 javascript:/data: 之类被面板当链接渲染）
+    url: /^https:\/\/[^\s]+$/i.test(url) ? url.slice(0, 2000) : "",
+    expiresAt: numOf(a.expiresAt),
+    remainingSec: numOf(a.remainingSec) || numOf(a.remainingSeconds),
+    clientIdTail: strOf(a.clientIdTail).slice(0, 20),
+    message: state === "idle" ? "" : dingTalkHumanMessage(state === "success" ? "" : state, a.message)
   };
-  try {
-    writeImBots(relayDir, { ...bots, version: 1, dingtalk: next });
-    return { ok: true };
-  } catch (e) {
-    return { ok: false, code: "write_failed", message: dingTalkHumanMessage("write_failed", `保存扫码凭据失败：${e?.message || e}`) };
-  }
-}
-
-/**
- * 查询扫码授权状态（GET /dsh-remote/im-dingtalk-auth/status?id=...&check=1）。
- * 默认只读后台轮询的结论；check=1（面板「我已完成授权，检查一下」）会**立刻补轮一次**再返回。
- * success 时凭据已经写盘，响应只回脱敏信息（绝不回 secret）。
- */
-async function dingtalkAuthStatus(authId, opts = {}) {
-  const key = String(authId || "");
-  const sess = dingtalkAuthSessions.get(key);
-  if (!sess) {
-    if (dingtalkAuthSuperseded.has(key)) {
-      dingtalkAuthSuperseded.delete(key);
-      return { ok: false, status: "failed", code: "cancelled", message: dingTalkHumanMessage("cancelled") };
-    }
-    return { ok: false, status: "expired", code: "expired", message: dingTalkHumanMessage("expired") };
-  }
-  if (opts.check === true && sess.state === "waiting") {
-    await dingtalkAuthPollOnce(key, opts);
-  }
-  if (sess.state === "waiting") return { ok: true, status: "waiting" };
-  if (sess.state === "success") {
-    return {
-      ok: true, status: "success", credentialSource: "scan",
-      clientIdTail: sess.clientIdTail || "", hasSecret: true
-    };
-  }
-  if (sess.state === "expired") return { ok: false, status: "expired", code: "expired", message: dingTalkHumanMessage("expired", sess.message) };
-  return { ok: false, status: "failed", code: "dingtalk_api_rejected", message: dingTalkHumanMessage("dingtalk_api_rejected", sess.message) };
 }
 
 /** 保存 dingtalk 配置（空 secret = 不修改；凭据完整性在返回里说清）。 */
@@ -9296,25 +9146,38 @@ function registerRoutes(ctx, relayDir, opts = {}) {
       },
     },
     {
-      // 钉钉扫码一键创建机器人：开始授权（返回授权链接；device_code 只存服务端内存）
+      // 钉钉扫码一键创建：**只写命令文件**（桥持久化 device_code 并断点续轮询）。
+      // 不返回 URL —— URL 由桥跑完写进状态文件，面板轮询 GET status 拿。
       method: "POST",
       path: "/dsh-remote/im-dingtalk-auth/begin",
       handler: async (_req, res) => {
-        const r = await beginDingtalkAuth(relayDir, { imAuthFetch: opts.imAuthFetch, imAuthPollMs: opts.imAuthPollMs });
-        sendJson(res, r.ok ? 200 : 502, r);
+        try {
+          writeDingtalkAuthCmd(relayDir, "begin");
+          sendJson(res, 200, { ok: true });
+        } catch (e) {
+          sendJson(res, 500, { ok: false, code: "write_failed", message: dingTalkHumanMessage("write_failed", `写入授权命令失败：${e?.message || e}`) });
+        }
       },
     },
     {
-      // 轮询授权状态：waiting / success（已写盘，只回脱敏结果）/ failed / expired
+      // 取消授权：写 cancel 命令（桥停轮询 + 删 auth 持久文件）
+      method: "POST",
+      path: "/dsh-remote/im-dingtalk-auth/cancel",
+      handler: async (_req, res) => {
+        try {
+          writeDingtalkAuthCmd(relayDir, "cancel");
+          sendJson(res, 200, { ok: true });
+        } catch (e) {
+          sendJson(res, 500, { ok: false, code: "write_failed", message: dingTalkHumanMessage("write_failed", `写入取消命令失败：${e?.message || e}`) });
+        }
+      },
+    },
+    {
+      // 授权进度：**直接读状态文件**（不自己 poll 钉钉）→ idle/waiting/success/failed/expired
       method: "GET",
       path: "/dsh-remote/im-dingtalk-auth/status",
-      handler: async (req, res) => {
-        const url = new URL(req.url ?? "/", "http://x");
-        const r = await dingtalkAuthStatus(url.searchParams.get("id") || "", {
-          imAuthFetch: opts.imAuthFetch,
-          check: url.searchParams.get("check") === "1"
-        });
-        sendJson(res, 200, r);
+      handler: async (_req, res) => {
+        sendJson(res, 200, { ok: true, ...imDingtalkAuthStatusOf(relayDir) });
       },
     },
     {
@@ -9705,9 +9568,6 @@ export function apply(ctx, config = {}) {
     imBotsWaitMs: Number(config.imBotsWaitMs) || undefined,
     // 测试钩子：飞书 SDK 安装的 npm spawn（用例注入假实现，**绝不真的联网装包**）。
     imDepsSpawn: typeof config.imDepsSpawn === "function" ? config.imDepsSpawn : undefined,
-    // 测试钩子：钉钉扫码授权的 fetch（用例注入假实现，**绝不真的打钉钉接口**）+ 后台轮询间隔。
-    imAuthFetch: typeof config.imAuthFetch === "function" ? config.imAuthFetch : undefined,
-    imAuthPollMs: Number(config.imAuthPollMs) || undefined,
   }), "dsh-remote-web: /dsh-remote routes");
   // 0.1.2-rc.1+ 浏览器会话代持：换取 Harness 会话 Cookie 供 bridge 上游携带（手机点设备不再 401 白页）
   ctx.effect(() => scheduleHarnessMint(ctx, relayDir), "dsh-remote-web: harness browser-session mint");

package/packages/dsh-remote-web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-web",
-  "version": "0.7.12-beta.4",
+  "version": "0.7.12-beta.6",
   "description": "公网远程控制 DeepSeek Harness（dsh web）：安装即得专属加密地址，人在外面也能用手机访问电脑上的 dsh——无需同一局域网/WiFi、无需公网 IP 与内网穿透，全程加密；手机端 100% 还原电脑体验（对话/工具/审批/设置）。技术用户可选自建服务，流量走自己的服务器。Remote control DeepSeek Harness (dsh web) from anywhere over the public internet — install, get an encrypted URL, use it from your phone on any network (dual-half cordis plugin: Settings panel + same-origin /dsh-remote routes). (2026-09 由 dsh-remote-ui 更名 / renamed from dsh-remote-ui; dsh-remote 的 dsh web 插件半，不是纯 UI/皮肤插件)",
   "type": "module",
   "main": "lib/index.js",