cortico-world-mosey 2.0.0 → 2.0.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # 更新日志
 
+## 2.0.1
+
+**修两个问题：私信被发到群里、列表里看得见却发不出去（都是群友报的）。**
+
+### 群名是「几个人的昵称拼起来」时，私信会发到群里
+
+抖音拉群时群名默认是成员昵称拼的（`海底月、小月月、大萌神`），而群名匹配允许「她写的是群名的一部分」，于是 `target=海底月` 被判成「发到那个群」——**私信内容直接公开在群里**。
+
+- 私信和发表情都改成**先认人、再认群**：命中「给她发过消息的陌生人」就不再做群匹配。想发到这种群，把完整群名写出来。
+- 反过来也修了：主列表差集不再把「海底月」当成群「海底月、小月月」——以前那个人的私信会被整条排除，**永远发现不了**。
+- 新增 `stroll target ambiguous` 日志：一个名字同时像人又像群时，写明最后按哪个发的。
+
+### 列表里明明看得见，发的时候说找不到会话
+
+- 会话标题黏着时间（`海底月 昨天`、`海底月 00:30`）时，精确匹配永远不成立，只能退到「包含」；而群名也可能是成员昵称拼的（`测试1、海底月`），一包含就命中两条 → 判成「歧义」直接放弃。现在先剥掉尾部时间再比。
+- 会话被新消息刷到列表很下面时，抖音的**虚拟滚动**根本不渲染那一行，`querySelectorAll` 看不到。现在找不到会先滚回顶部，再一屏一屏往下找（最多 10 屏）。
+- 顺手：target 就是她自己登录的抖音号时，直接说「抖音不能给自己发私信」，不再报「找不到会话」让她猜。
+
 ## 2.0.0
 
 **第一个大版本：陌生人私信能回了，面板多了「私信 / 群聊」两张额度卡，安全也收紧了一轮。**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cortico-world-mosey",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "type": "module",
   "description": "摸鱼（Mosey）：让 Coopanion 的桌宠自己去抖音和 B站逛一圈。评论和私信都能收能回；能一起看视频（B站带字幕弹幕，抖音可自动连刷）；关注流、周报、本地书库；按额度点赞、评论、关注、发动态。默认人审，三把工具、少 token。\n\nQQ 交流群：745879632",
   "license": "MIT",

package/src/douyin.js

@@ -6207,7 +6207,19 @@ export class DouyinBrowser {
           const titleOf = (el) => {
             const t = el.querySelector('[class*="ConversationItemtitle"]');
             const line = String((el.innerText || '').split('\n')[0] || '');
-            return norm(t?.innerText || line);
+            const raw = norm(t?.innerText || line);
+            /**
+             * 列表标题常黏着时间（`海底月 刚刚`、`海底月 10:55`）。
+             * 不剥的话 exact 永远不成立，只能落到「包含」；而群名也可能含这个人名
+             * （`测试1、海底月`），包含就会同时命中两条 → 判成歧义 → 直接返回 false，
+             * 表现就是「列表里明明看得见，发的时候说找不到」。
+             */
+            return raw
+              .replace(
+                /\s+(刚刚|\d{1,2}:\d{2}|昨天|前天|星期[一二三四五六日]|\d+\s*(?:秒|分钟|小时|天)前|\d{1,2}-\d{1,2})$/,
+                '',
+              )
+              .trim();
           };
           let hit = null;
           if (cid) hit = items.find((el) => el.getAttribute('data-stroll-cid') === cid) ?? null;
@@ -6230,11 +6242,100 @@ export class DouyinBrowser {
         { target: base, nth, cid },
       )
       .catch(() => null);
-    if (!box) return false;
-    await page.mouse.click(box.x, box.y).catch(() => {});
+    if (box) {
+      await page.mouse.click(box.x, box.y).catch(() => {});
+      return true;
+    }
+    /**
+     * 还没找到：会话可能在列表很下面（昨晚的消息，中间刷了十几个小时）。
+     * 抖音的会话列表是**虚拟滚动**，屏幕外的行根本不在 DOM 里，`querySelectorAll`
+     * 看不到——所以先滚到顶，再一屏一屏往下找。
+     */
+    const found = await this.scrollConversationList(page, async () =>
+      page
+        .evaluate(
+          ({ target, nth, cid }) => {
+            const norm = (s) => String(s ?? '').replace(/\s+/g, ' ').trim();
+            const items = Array.from(document.querySelectorAll('[data-e2e="conversation-item"]'));
+            const titleOf = (el) => {
+              const t = el.querySelector('[class*="ConversationItemtitle"]');
+              const line = String((el.innerText || '').split('\n')[0] || '');
+              return norm(t?.innerText || line)
+                .replace(
+                  /\s+(刚刚|\d{1,2}:\d{2}|昨天|前天|星期[一二三四五六日]|\d+\s*(?:秒|分钟|小时|天)前|\d{1,2}-\d{1,2})$/,
+                  '',
+                )
+                .trim();
+            };
+            let hit = null;
+            if (cid) hit = items.find((el) => el.getAttribute('data-stroll-cid') === cid) ?? null;
+            if (!hit) {
+              const exact = items.filter((el) => titleOf(el) === norm(target));
+              hit = (nth > 0 ? exact[nth - 1] : exact[0]) ?? null;
+            }
+            if (!hit) {
+              const partial = items.filter((el) => titleOf(el).includes(norm(target)));
+              if (partial.length === 1) hit = partial[0];
+            }
+            if (!hit) return null;
+            hit.scrollIntoView({ block: 'nearest' });
+            const r = hit.getBoundingClientRect();
+            if (r.width < 10 || r.height < 10) return null;
+            return { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+          },
+          { target: base, nth, cid },
+        )
+        .catch(() => null),
+    );
+    if (!found) return false;
+    await page.mouse.click(found.x, found.y).catch(() => {});
     return true;
   }
 
+  /**
+   * 在会话列表里一段一段往下滚，每滚一次调一次 `find()`。
+   * 不依赖类名：从第一条会话往上找「overflow-y 真的能滚」的那个祖先。
+   */
+  async scrollConversationList(page, find, { tries = 10 } = {}) {
+    const toTop = () => {
+      const el = document.querySelector('[data-e2e="conversation-item"]');
+      let p = el?.parentElement ?? null;
+      while (p) {
+        const st = getComputedStyle(p);
+        if (/(auto|scroll|overlay)/.test(st.overflowY) && p.scrollHeight > p.clientHeight + 20) {
+          p.scrollTop = 0;
+          return;
+        }
+        p = p.parentElement;
+      }
+    };
+    const step = () => {
+      const el = document.querySelector('[data-e2e="conversation-item"]');
+      let p = el?.parentElement ?? null;
+      while (p) {
+        const st = getComputedStyle(p);
+        if (/(auto|scroll|overlay)/.test(st.overflowY) && p.scrollHeight > p.clientHeight + 20) {
+          const before = p.scrollTop;
+          p.scrollTop = before + Math.max(80, Math.round(p.clientHeight * 0.75));
+          return p.scrollTop !== before;
+        }
+        p = p.parentElement;
+      }
+      return false;
+    };
+    // 先回到顶部：目标可能在上面，从当前位置往下滚永远到不了
+    await page.evaluate(toTop).catch(() => {});
+    await page.waitForTimeout(120);
+    for (let i = 0; i < tries; i += 1) {
+      const moved = await page.evaluate(step).catch(() => false);
+      if (!moved) break;
+      await page.waitForTimeout(160);
+      const hit = await find();
+      if (hit) return hit;
+    }
+    return null;
+  }
+
   /** 读聊天页顶部那个会话标题（认不出就返回空串，调用方当「不校验」处理）。 */
   async currentChatTitle(page) {
     return await page

package/src/world.js

@@ -618,6 +618,31 @@ export class StrollWorld {
     return x === y || x.includes(y) || y.includes(x);
   }
 
+  /**
+   * 这一行/这个名字是不是「已知的群」。
+   *
+   * 和 `sameGroup` 的区别是**单向包含**：只认「会话标题包含群名」，不认反过来。
+   * 因为抖音拉群时群名默认是**几个成员的昵称拼起来**（`海底月、小月月、大萌神`），
+   * 用双向包含会把「海底月」这个**人**也判成群——后果有两个：
+   *   1. 她的私信永远发现不了（主列表差集把它当群排掉）；
+   *   2. 发给「海底月」的私信被判成「发群」，内容公开在群里。
+   * 所以只留「标题 ⊇ 群名」这个方向：群标题通常就是群名（可能带人数后缀），
+   * 而人名一定比群名短。
+   */
+  looksLikeKnownGroup(name, known = []) {
+    const norm = (s) =>
+      String(s ?? '')
+        .replace(/[\s\u3000]+/g, '')
+        .replace(/\(\d+\)$|（\d+）$/, '')
+        .toLowerCase();
+    const y = norm(name);
+    if (!y) return false;
+    return (known ?? []).some((n) => {
+      const x = norm(n);
+      return !!x && (x === y || y.includes(x));
+    });
+  }
+
   /** 群名的比较键：去掉空白、大小写，以及同名群加的「#2」后缀。 */
   groupKey(name) {
     return String(name ?? '')
@@ -1623,7 +1648,7 @@ export class StrollWorld {
     const list = Object.keys(this.store.data.strangerSeen ?? {})
       .filter((k) => k.startsWith('douyin:'))
       .map((k) => stripRowTime(k.slice('douyin:'.length)))
-      .filter((who) => !groups.some((g) => this.sameGroup(g, who)));
+      .filter((who) => !this.looksLikeKnownGroup(who, groups));
     return this.matchStranger(list, wanted);
   }
 
@@ -1657,7 +1682,7 @@ export class StrollWorld {
       .filter((k) => k.startsWith('douyin:'))
       .map((k) => stripRowTime(k.slice('douyin:'.length)))
       // 名单里可能混进过群（旧版本没排除干净）：认得出的群不当人看
-      .filter((who) => !groups.some((g) => this.sameGroup(g, who)));
+      .filter((who) => !this.looksLikeKnownGroup(who, groups));
     let who = this.matchStranger(seen, wanted);
     if (!who) {
       const found =
@@ -1679,6 +1704,20 @@ export class StrollWorld {
     const { mode } = this.strangerDmPolicy();
     const name = String(who ?? '').trim();
     if (!name) return { ok: false };
+    /**
+     * 目标就是她自己登录的那个抖音号：抖音不允许给自己发私信。
+     * 以前会一路走到「点开会话」，然后报「找不到这个会话」——听着像找不到人，
+     * 其实是根本不该发（她也只能跟着猜「是不是我自己的号」）。
+     */
+    const selfName = String(this.store.data.douyinSelf?.name ?? '').trim();
+    const norm = (v) => String(v ?? '').replace(/[\s\u3000]+/g, '').toLowerCase();
+    if (selfName && norm(selfName) === norm(name)) {
+      return {
+        ok: false,
+        code: 'SELF',
+        why: `「${name}」就是她自己登录的抖音号，抖音不能给自己发私信`,
+      };
+    }
     if (mode === 'off') return { ok: false, code: 'STRANGER_OFF', why: '陌生人私信设成「关」了' };
     if (this.isStrangerBlocked(name)) {
       return { ok: false, code: 'BLOCKED', why: `「${name}」在黑名单里，不回` };
@@ -1890,7 +1929,7 @@ export class StrollWorld {
               const pv = String(r.preview ?? '');
               let why = 'stranger';
               if (ownerName && this.sameGroup(ownerName, who)) why = 'owner';
-              else if (known.some((n) => this.sameGroup(n, who))) why = 'group';
+              else if (this.looksLikeKnownGroup(who, known)) why = 'group';
               else if (!pv) why = 'no-preview';
               else if (/^\d+分钟内在线$|^在线$/.test(pv)) why = 'online';
               return `${truncate(who, 12)}|${truncate(pv, 12)}|${why}`;
@@ -1898,7 +1937,7 @@ export class StrollWorld {
           });
         }
         const extra = rows
-          .filter((r) => r.name && !known.some((n) => this.sameGroup(n, r.name)))
+          .filter((r) => r.name && !this.looksLikeKnownGroup(r.name, known))
           .map((r) => ({ who: r.name, at: r.at || '', preview: r.preview || '', unread: 0 }))
           .filter((r) => r.preview && !/^\d+分钟内在线$|^在线$/.test(r.preview));
         if (extra.length) {
@@ -1943,7 +1982,7 @@ export class StrollWorld {
           ...(extra ? { hit: truncate(String(extra), 24) } : {}),
         });
       if (!row.preview || /^\d+分钟内在线$|^在线$/.test(row.preview)) continue;
-      if (knownGroups.some((g) => this.sameGroup(g, row.who))) continue;
+      if (this.looksLikeKnownGroup(row.who, knownGroups)) continue;
       const key = `douyin:${row.who}`;
       /**
        * 指纹只用正文，**不带时间**。
@@ -4240,15 +4279,19 @@ export class StrollWorld {
     const OWNER_ALIAS = /^(主人|主人私信|私信|私聊|owner|dm|你|您)$/i;
     let groups = await this.resolveGroups().catch(() => this.groupNames());
     if (wanted && !OWNER_ALIAS.test(wanted)) {
-      let hit = this.matchGroup(groups, wanted);
-      if (!hit) {
+      // 和私信一样：群名可能是「几个人的昵称拼起来的」，命中陌生人名单就优先当人
+      const quick = this.cachedStranger(wanted, groups);
+      let hit = quick ? null : this.matchGroup(groups, wanted);
+      if (!hit && !quick) {
         // 名单可能是旧的（刚被拉进新群）：强刷一次再认，别把群名当成「不认识的人」
         groups = await this.resolveGroups(true, { deep: true }).catch(() => groups);
         hit = this.matchGroup(groups, wanted);
       }
       if (hit) return { ok: true, who: hit, group: true };
       // 不是群：也可能是「陌生人消息」里给她发过话的人（图和表情一样能发过去）
-      const stranger = await this.strangerTargetOf(wanted).catch(() => ({ ok: false }));
+      const stranger = quick
+        ? this.strangerGuard(quick)
+        : await this.strangerTargetOf(wanted).catch(() => ({ ok: false }));
       if (stranger.ok) return { ok: true, who: stranger.who, group: false, stranger: true };
       const list = groups.length ? groups.map((g) => `「${g}」`).join(' 或 ') : '（现在一个群都没认出来）';
       return {
@@ -4920,20 +4963,38 @@ export class StrollWorld {
           !dmFresh && this.lastGroupPoke && Date.now() - Number(this.lastGroupPoke.at ?? 0) < 10 * 60 * 1000
             ? String(this.lastGroupPoke.group ?? '')
             : '';
-        let asGroup = wanted ? this.matchGroup(groups, wanted) : null;
-        if (!asGroup && wanted && groups.length === 1 && /^(群|群聊|那个群|抖音群|group|the group)$/i.test(wanted)) {
-          asGroup = groups[0];
-        }
-        if (!asGroup && wanted && pokedGroup && this.matchGroup([pokedGroup], wanted)) asGroup = pokedGroup;
         /**
          * 先看「这是不是一个给她发过消息的陌生人」——**只查本地名单，不读页面**。
          *
-         * 以前这一步排在「强刷群名单」后面：任何不是群名的 target 都要先深刷一次
-         * 会话列表（真的去读页面，实测 0.85 秒），陌生人也照刷。
-         * 现在命中本地名单就直接走陌生人分支，那 0.85 秒全省下来。
+         * 顺序很关键。抖音拉群时群名默认是**几个成员的昵称拼起来**
+         * （`海底月、小月月、大萌神`），而 `matchGroup` 允许「她写的是群名的一部分」。
+         * 于是 `target=海底月` 会被判成「发到那个群」——**她的私信内容直接公开在群里**。
+         * 所以：能当人就当人，命中陌生人名单就不再做群匹配。
+         * （副作用：想发到这种群得写完整群名，这个代价可以接受。）
          */
-        let quickStranger = '';
-        if (!asGroup && wanted) quickStranger = this.cachedStranger(wanted, groups);
+        let quickStranger = wanted ? this.cachedStranger(wanted, groups) : '';
+        if (quickStranger) {
+          const wouldBeGroup = this.matchGroup(groups, wanted);
+          if (wouldBeGroup) {
+            this.log?.warn?.('stroll target ambiguous', {
+              target: wanted,
+              stranger: quickStranger,
+              group: wouldBeGroup,
+              pick: 'dm',
+            });
+          }
+        }
+        let asGroup = wanted && !quickStranger ? this.matchGroup(groups, wanted) : null;
+        if (
+          !asGroup &&
+          !quickStranger &&
+          wanted &&
+          groups.length === 1 &&
+          /^(群|群聊|那个群|抖音群|group|the group)$/i.test(wanted)
+        ) {
+          asGroup = groups[0];
+        }
+        if (!asGroup && !quickStranger && wanted && pokedGroup && this.matchGroup([pokedGroup], wanted)) asGroup = pokedGroup;
         if (!asGroup && wanted && !quickStranger) {
           // 名单可能是旧的（主人刚把她拉进新群）：滚动会话列表强刷一次再认
           groups = await this.resolveGroups(true, { deep: true }).catch(() => groups);