@web-auto/camo 0.1.2 → 0.1.4

package/src/autoscript/action-providers/xhs/comments.mjs

@@ -0,0 +1,412 @@
+export function buildCommentsHarvestScript(params = {}) {
+  const maxRounds = Math.max(1, Number(params.maxRounds ?? params.maxScrollRounds ?? 14) || 14);
+  const scrollStep = Math.max(120, Number(params.scrollStep ?? 420) || 420);
+  const settleMs = Math.max(80, Number(params.settleMs ?? 180) || 180);
+  const stallRounds = Math.max(1, Number(params.stallRounds ?? 2) || 2);
+  const requireBottom = params.requireBottom !== false;
+  const includeComments = params.includeComments !== false;
+  const commentsLimit = Math.max(0, Number(params.commentsLimit ?? 0) || 0);
+  const recoveryStuckRounds = Math.max(1, Number(params.recoveryStuckRounds ?? 2) || 2);
+  const recoveryUpRounds = Math.max(1, Number(params.recoveryUpRounds ?? 2) || 2);
+  const recoveryDownRounds = Math.max(1, Number(params.recoveryDownRounds ?? 3) || 3);
+  const maxRecoveries = Math.max(0, Number(params.maxRecoveries ?? 3) || 3);
+  const recoveryUpStep = Math.max(80, Number(params.recoveryUpStep ?? Math.floor(scrollStep * 0.75)) || Math.floor(scrollStep * 0.75));
+  const recoveryDownStep = Math.max(120, Number(params.recoveryDownStep ?? Math.floor(scrollStep * 1.3)) || Math.floor(scrollStep * 1.3));
+  const recoveryNoProgressRounds = Math.max(1, Number(params.recoveryNoProgressRounds ?? 3) || 3);
+  const progressDiffThreshold = Math.max(2, Number(
+    params.progressDiffThreshold ?? Math.max(12, Math.floor(scrollStep * 0.08)),
+  ) || Math.max(12, Math.floor(scrollStep * 0.08)));
+  const recoveryDownBoostPerAttempt = Math.max(0, Number(params.recoveryDownBoostPerAttempt ?? 1) || 1);
+  const maxRecoveryDownBoost = Math.max(0, Number(params.maxRecoveryDownBoost ?? 2) || 2);
+  const adaptiveMaxRounds = params.adaptiveMaxRounds !== false;
+  const adaptiveExpectedPerRound = Math.max(1, Number(params.adaptiveExpectedPerRound ?? 6) || 6);
+  const adaptiveBufferRounds = Math.max(0, Number(params.adaptiveBufferRounds ?? 22) || 22);
+  const adaptiveMinBoostRounds = Math.max(0, Number(params.adaptiveMinBoostRounds ?? 36) || 36);
+  const adaptiveMaxRoundsCap = Math.max(maxRounds, Number(params.adaptiveMaxRoundsCap ?? 320) || 320);
+
+  return `(async () => {
+    const state = window.__camoXhsState || (window.__camoXhsState = {});
+    const metricsState = state.metrics && typeof state.metrics === 'object' ? state.metrics : {};
+    state.metrics = metricsState;
+    metricsState.searchCount = Number(metricsState.searchCount || 0);
+    const detailSelectors = [
+      '.note-detail-mask',
+      '.note-detail-page',
+      '.note-detail-dialog',
+      '.note-detail-mask .detail-container',
+      '.note-detail-mask .media-container',
+      '.note-detail-mask .note-scroller',
+      '.note-detail-mask .note-content',
+      '.note-detail-mask .interaction-container',
+      '.note-detail-mask .comments-container',
+    ];
+    const isVisible = (node) => {
+      if (!node || !(node instanceof HTMLElement)) return false;
+      const style = window.getComputedStyle(node);
+      if (!style) return false;
+      if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity || '1') === 0) return false;
+      const rect = node.getBoundingClientRect();
+      return rect.width > 1 && rect.height > 1;
+    };
+    const isDetailVisible = () => detailSelectors.some((selector) => isVisible(document.querySelector(selector)));
+    const parseCountToken = (raw) => {
+      const token = String(raw || '').trim();
+      const matched = token.match(/^([0-9]+(?:\\.[0-9]+)?)(万|w|W)?$/);
+      if (!matched) return null;
+      const base = Number(matched[1]);
+      if (!Number.isFinite(base)) return null;
+      if (!matched[2]) return Math.round(base);
+      return Math.round(base * 10000);
+    };
+    const readExpectedCommentsCount = () => {
+      const scopeSelectors = [
+        '.note-detail-mask .interaction-container',
+        '.note-detail-mask .comments-container',
+        '.note-detail-page .interaction-container',
+        '.note-detail-page .comments-container',
+        '.note-detail-mask',
+        '.note-detail-page',
+      ];
+      const patterns = [
+        /([0-9]+(?:\\.[0-9]+)?(?:万|w|W)?)\\s*条?评论/,
+        /评论\\s*([0-9]+(?:\\.[0-9]+)?(?:万|w|W)?)/,
+        /共\\s*([0-9]+(?:\\.[0-9]+)?(?:万|w|W)?)\\s*条/,
+      ];
+      for (const selector of scopeSelectors) {
+        const root = document.querySelector(selector);
+        if (!root) continue;
+        const text = String(root.textContent || '').replace(/\\s+/g, ' ').trim();
+        if (!text) continue;
+        for (const re of patterns) {
+          const matched = text.match(re);
+          if (!matched || !matched[1]) continue;
+          const parsed = parseCountToken(matched[1]);
+          if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+        }
+      }
+      return null;
+    };
+
+    const scroller = document.querySelector('.note-scroller')
+      || document.querySelector('.comments-el')
+      || document.querySelector('.comments-container')
+      || document.scrollingElement
+      || document.documentElement;
+    const readMetrics = () => {
+      const target = scroller || document.documentElement;
+      return {
+        scrollTop: Number(target?.scrollTop || 0),
+        scrollHeight: Number(target?.scrollHeight || 0),
+        clientHeight: Number(target?.clientHeight || window.innerHeight || 0),
+      };
+    };
+    const commentMap = new Map();
+    const collect = (round) => {
+      const nodes = Array.from(document.querySelectorAll('.comment-item, [class*="comment-item"]'));
+      for (const item of nodes) {
+        const textNode = item.querySelector('.content, .comment-content, p');
+        const authorNode = item.querySelector('.name, .author, .user-name, [class*="author"], [class*="name"]');
+        const text = String((textNode && textNode.textContent) || '').trim();
+        const author = String((authorNode && authorNode.textContent) || '').trim();
+        if (!text) continue;
+        const key = author + '::' + text;
+        if (commentMap.has(key)) continue;
+        const likeNode = item.querySelector('.like-wrapper, .comment-like, [class*="like"]');
+        commentMap.set(key, {
+          author,
+          text,
+          liked: Boolean(likeNode && /like-active/.test(String(likeNode.className || ''))),
+          firstSeenRound: round,
+        });
+      }
+    };
+
+    const configuredMaxRounds = Number(${maxRounds});
+    const scrollStep = Number(${scrollStep});
+    const settleMs = Number(${settleMs});
+    const stallRounds = Number(${stallRounds});
+    const requireBottom = ${requireBottom ? 'true' : 'false'};
+    const includeComments = ${includeComments ? 'true' : 'false'};
+    const commentsLimit = Number(${commentsLimit});
+    const recoveryStuckRounds = Number(${recoveryStuckRounds});
+    const recoveryUpRounds = Number(${recoveryUpRounds});
+    const recoveryDownRounds = Number(${recoveryDownRounds});
+    const maxRecoveries = Number(${maxRecoveries});
+    const recoveryUpStep = Number(${recoveryUpStep});
+    const recoveryDownStep = Number(${recoveryDownStep});
+    const recoveryNoProgressRounds = Number(${recoveryNoProgressRounds});
+    const progressDiffThreshold = Number(${progressDiffThreshold});
+    const recoveryDownBoostPerAttempt = Number(${recoveryDownBoostPerAttempt});
+    const maxRecoveryDownBoost = Number(${maxRecoveryDownBoost});
+    const adaptiveMaxRounds = ${adaptiveMaxRounds ? 'true' : 'false'};
+    const adaptiveExpectedPerRound = Number(${adaptiveExpectedPerRound});
+    const adaptiveBufferRounds = Number(${adaptiveBufferRounds});
+    const adaptiveMinBoostRounds = Number(${adaptiveMinBoostRounds});
+    const adaptiveMaxRoundsCap = Number(${adaptiveMaxRoundsCap});
+    let maxRounds = configuredMaxRounds;
+    let maxRoundsSource = 'configured';
+    let budgetExpectedCommentsCount = null;
+    const applyAdaptiveRounds = (expectedCommentsCount) => {
+      const expected = Number(expectedCommentsCount);
+      if (!adaptiveMaxRounds || !Number.isFinite(expected) || expected <= 0) return false;
+      const estimatedRounds = Math.ceil(expected / adaptiveExpectedPerRound) + adaptiveBufferRounds;
+      if (estimatedRounds <= configuredMaxRounds) return false;
+      const boostedRounds = Math.max(configuredMaxRounds + adaptiveMinBoostRounds, estimatedRounds);
+      const nextRounds = Math.max(configuredMaxRounds, Math.min(adaptiveMaxRoundsCap, boostedRounds));
+      maxRounds = nextRounds;
+      maxRoundsSource = 'adaptive_expected_comments';
+      budgetExpectedCommentsCount = Math.round(expected);
+      return true;
+    };
+    applyAdaptiveRounds(readExpectedCommentsCount());
+    let rounds = 0;
+    let reachedBottom = false;
+    let exitReason = 'max_rounds_reached';
+    let noProgressRounds = 0;
+    let noNewCommentsStreak = 0;
+    let stalledScrollRounds = 0;
+    let noEffectStreak = 0;
+    let recoveries = 0;
+    let bestRemainingDiff = Number.POSITIVE_INFINITY;
+    const recoveryReasonCounts = {
+      no_effect: 0,
+      no_new_comments: 0,
+    };
+    const performScroll = async (deltaY, waitMs = settleMs) => {
+      if (typeof scroller?.scrollBy === 'function') {
+        scroller.scrollBy({ top: deltaY, behavior: 'auto' });
+      } else {
+        window.scrollBy({ top: deltaY, behavior: 'auto' });
+      }
+      await new Promise((resolve) => setTimeout(resolve, waitMs));
+    };
+
+    for (let round = 1; round <= maxRounds; round += 1) {
+      rounds = round;
+      if (!isDetailVisible()) {
+        exitReason = 'detail_hidden';
+        break;
+      }
+      const beforeCount = commentMap.size;
+      collect(round);
+      if ((budgetExpectedCommentsCount === null || budgetExpectedCommentsCount === undefined) && round <= 6) {
+        applyAdaptiveRounds(readExpectedCommentsCount());
+      }
+      const beforeMetrics = readMetrics();
+      const beforeDiff = beforeMetrics.scrollHeight - (beforeMetrics.scrollTop + beforeMetrics.clientHeight);
+      if (Number.isFinite(beforeDiff) && beforeDiff >= 0) {
+        bestRemainingDiff = Math.min(bestRemainingDiff, beforeDiff);
+      }
+      if (beforeDiff <= 6) {
+        reachedBottom = true;
+        exitReason = 'bottom_reached';
+        break;
+      }
+
+      const prevTop = beforeMetrics.scrollTop;
+      if (typeof scroller?.scrollBy === 'function') {
+        scroller.scrollBy({ top: scrollStep, behavior: 'auto' });
+      } else {
+        window.scrollBy({ top: scrollStep, behavior: 'auto' });
+      }
+      await new Promise((resolve) => setTimeout(resolve, settleMs));
+      collect(round);
+      let afterMetrics = readMetrics();
+      let moved = Math.abs(afterMetrics.scrollTop - prevTop) > 1;
+      if (!moved && typeof window.scrollBy === 'function') {
+        window.scrollBy({ top: Math.max(120, Math.floor(scrollStep / 2)), behavior: 'auto' });
+        await new Promise((resolve) => setTimeout(resolve, settleMs));
+        collect(round);
+        afterMetrics = readMetrics();
+        moved = Math.abs(afterMetrics.scrollTop - prevTop) > 1;
+      }
+      const increased = commentMap.size > beforeCount;
+      const afterDiff = afterMetrics.scrollHeight - (afterMetrics.scrollTop + afterMetrics.clientHeight);
+      const diffImproved = Number.isFinite(afterDiff) && Number.isFinite(beforeDiff)
+        ? afterDiff <= (beforeDiff - progressDiffThreshold)
+        : false;
+      const bestImproved = Number.isFinite(afterDiff) && Number.isFinite(bestRemainingDiff)
+        ? afterDiff <= (bestRemainingDiff - progressDiffThreshold)
+        : false;
+      if (Number.isFinite(afterDiff) && afterDiff >= 0) {
+        bestRemainingDiff = Math.min(bestRemainingDiff, afterDiff);
+      }
+      const progressedByScroll = diffImproved || bestImproved;
+      const progressed = increased || progressedByScroll;
+      if (!progressed) {
+        noProgressRounds += 1;
+        noNewCommentsStreak += 1;
+      } else {
+        noProgressRounds = 0;
+        noNewCommentsStreak = 0;
+      }
+      if (!moved) stalledScrollRounds += 1;
+      else stalledScrollRounds = 0;
+      if (!moved) noEffectStreak += 1;
+      else noEffectStreak = 0;
+      if (afterDiff <= 6) {
+        reachedBottom = true;
+        exitReason = 'bottom_reached';
+        break;
+      }
+      let recoveryTrigger = null;
+      if (noNewCommentsStreak >= recoveryNoProgressRounds) recoveryTrigger = 'no_new_comments';
+      if (!recoveryTrigger && noEffectStreak >= recoveryStuckRounds) recoveryTrigger = 'no_effect';
+      if (recoveryTrigger) {
+        if (recoveries >= maxRecoveries) {
+          exitReason = recoveryTrigger === 'no_new_comments'
+            ? 'no_new_comments_after_recovery_budget'
+            : 'scroll_stalled_after_recovery';
+          break;
+        }
+        recoveries += 1;
+        recoveryReasonCounts[recoveryTrigger] += 1;
+        for (let i = 0; i < recoveryUpRounds; i += 1) {
+          await performScroll(-recoveryUpStep, settleMs + 120);
+          collect(round);
+        }
+        const downBoost = Math.min(maxRecoveryDownBoost, Math.max(0, recoveries - 1) * recoveryDownBoostPerAttempt);
+        const downRounds = recoveryDownRounds + downBoost;
+        for (let i = 0; i < downRounds; i += 1) {
+          await performScroll(recoveryDownStep, settleMs + 180);
+          collect(round);
+        }
+        const recoveredMetrics = readMetrics();
+        const recoveredDiff = recoveredMetrics.scrollHeight - (recoveredMetrics.scrollTop + recoveredMetrics.clientHeight);
+        const recoveredDiffImproved = Number.isFinite(recoveredDiff) && Number.isFinite(afterDiff)
+          ? recoveredDiff <= (afterDiff - progressDiffThreshold)
+          : false;
+        const recoveredBestImproved = Number.isFinite(recoveredDiff) && Number.isFinite(bestRemainingDiff)
+          ? recoveredDiff <= (bestRemainingDiff - progressDiffThreshold)
+          : false;
+        if (Number.isFinite(recoveredDiff) && recoveredDiff >= 0) {
+          bestRemainingDiff = Math.min(bestRemainingDiff, recoveredDiff);
+        }
+        if (recoveredDiff <= 6) {
+          reachedBottom = true;
+          exitReason = 'bottom_reached';
+          break;
+        }
+        if (commentMap.size > beforeCount || recoveredDiffImproved || recoveredBestImproved) {
+          noProgressRounds = 0;
+          noNewCommentsStreak = 0;
+        }
+        noEffectStreak = 0;
+        stalledScrollRounds = 0;
+        continue;
+      }
+      if (stalledScrollRounds >= stallRounds) {
+        exitReason = 'scroll_stalled';
+        break;
+      }
+      if (noProgressRounds >= stallRounds) {
+        if (!requireBottom) {
+          exitReason = 'no_new_comments';
+          break;
+        }
+      }
+      if (round === maxRounds) {
+        exitReason = 'max_rounds_reached';
+      }
+    }
+
+    const comments = Array.from(commentMap.values())
+      .sort((a, b) => Number(a.firstSeenRound || 0) - Number(b.firstSeenRound || 0))
+      .map((item, index) => ({
+        index,
+        author: item.author,
+        text: item.text,
+        liked: item.liked,
+      }));
+    const metrics = readMetrics();
+    const detectedExpectedCommentsCount = readExpectedCommentsCount();
+    const expectedCommentsCount = Number.isFinite(Number(detectedExpectedCommentsCount))
+      ? Number(detectedExpectedCommentsCount)
+      : (Number.isFinite(Number(budgetExpectedCommentsCount)) ? Number(budgetExpectedCommentsCount) : null);
+    const commentCoverageRate = Number.isFinite(Number(expectedCommentsCount)) && Number(expectedCommentsCount) > 0
+      ? Number(Math.min(1, comments.length / Number(expectedCommentsCount)).toFixed(4))
+      : null;
+
+    state.currentComments = comments;
+    state.commentsCollectedAt = new Date().toISOString();
+    state.lastCommentsHarvest = {
+      noteId: state.currentNoteId || null,
+      searchCount: Number(metricsState.searchCount || 0),
+      collected: comments.length,
+      expectedCommentsCount,
+      commentCoverageRate,
+      recoveries,
+      recoveryReasonCounts,
+      maxRecoveries,
+      recoveryNoProgressRounds,
+      reachedBottom,
+      exitReason,
+      rounds,
+      configuredMaxRounds,
+      maxRounds,
+      maxRoundsSource,
+      budgetExpectedCommentsCount,
+      scroll: metrics,
+      at: state.commentsCollectedAt,
+    };
+    const payload = {
+      noteId: state.currentNoteId || null,
+      searchCount: Number(metricsState.searchCount || 0),
+      collected: comments.length,
+      expectedCommentsCount,
+      commentCoverageRate,
+      recoveries,
+      recoveryReasonCounts,
+      maxRecoveries,
+      recoveryNoProgressRounds,
+      firstComment: comments[0] || null,
+      reachedBottom,
+      exitReason,
+      rounds,
+      configuredMaxRounds,
+      maxRounds,
+      maxRoundsSource,
+      budgetExpectedCommentsCount,
+      scroll: metrics,
+    };
+    if (includeComments) {
+      const bounded = commentsLimit > 0 ? comments.slice(0, commentsLimit) : comments;
+      payload.comments = bounded;
+      payload.commentsTruncated = commentsLimit > 0 && comments.length > commentsLimit;
+    }
+    return payload;
+  })()`;
+}
+
+export function buildCommentMatchScript(params = {}) {
+  const keywords = (Array.isArray(params.keywords || params.matchKeywords)
+    ? (params.keywords || params.matchKeywords)
+    : String(params.keywords || params.matchKeywords || '').split(','))
+    .map((item) => String(item))
+    .filter(Boolean);
+  const mode = String(params.mode || params.matchMode || 'any');
+  const minHits = Math.max(1, Number(params.minHits ?? params.matchMinHits ?? 1) || 1);
+
+  return `(async () => {
+    const state = window.__camoXhsState || (window.__camoXhsState = {});
+    const rows = Array.isArray(state.currentComments) ? state.currentComments : [];
+    const keywords = ${JSON.stringify(keywords)};
+    const mode = ${JSON.stringify(mode)};
+    const minHits = Number(${minHits});
+    const normalize = (value) => String(value || '').toLowerCase().replace(/\\s+/g, ' ').trim();
+    const tokens = keywords.map((item) => normalize(item)).filter(Boolean);
+    const matches = [];
+    for (const row of rows) {
+      const text = normalize(row.text);
+      if (!text || tokens.length === 0) continue;
+      const hits = tokens.filter((token) => text.includes(token));
+      if (mode === 'all' && hits.length < tokens.length) continue;
+      if (mode === 'atLeast' && hits.length < Math.max(1, minHits)) continue;
+      if (mode !== 'all' && mode !== 'atLeast' && hits.length === 0) continue;
+      matches.push({ index: row.index, hits });
+    }
+    state.matchedComments = matches;
+    state.matchRule = { tokens, mode, minHits };
+    return { matchCount: matches.length, mode, minHits: Math.max(1, minHits) };
+  })()`;
+}

package/src/autoscript/action-providers/xhs/common.mjs

@@ -0,0 +1,77 @@
+import { callAPI } from '../../../utils/browser-service.mjs';
+
+export function withOperationHighlight(script, color = '#ff7a00') {
+  return `(() => {
+    const flashNode = (node, duration = 420) => {
+      if (!(node instanceof HTMLElement)) return;
+      const prevOutline = node.style.outline;
+      const prevOffset = node.style.outlineOffset;
+      const prevTransition = node.style.transition;
+      node.style.transition = 'outline 80ms ease';
+      node.style.outline = '2px solid ${color}';
+      node.style.outlineOffset = '2px';
+      setTimeout(() => {
+        node.style.outline = prevOutline;
+        node.style.outlineOffset = prevOffset;
+        node.style.transition = prevTransition;
+      }, duration);
+    };
+    const flashViewport = (duration = 420) => {
+      const root = document.documentElement;
+      if (!(root instanceof HTMLElement)) return;
+      const prevShadow = root.style.boxShadow;
+      const prevTransition = root.style.transition;
+      root.style.transition = 'box-shadow 80ms ease';
+      root.style.boxShadow = 'inset 0 0 0 3px ${color}';
+      setTimeout(() => {
+        root.style.boxShadow = prevShadow;
+        root.style.transition = prevTransition;
+      }, duration);
+    };
+    flashViewport();
+    const target = document.activeElement instanceof HTMLElement
+      ? document.activeElement
+      : (document.body || document.documentElement);
+    flashNode(target);
+    return (${script});
+  })()`;
+}
+
+export async function runEvaluateScript({ profileId, script, highlight = true }) {
+  const wrappedScript = highlight ? withOperationHighlight(script) : script;
+  return callAPI('evaluate', { profileId, script: wrappedScript });
+}
+
+export function extractEvaluateResultData(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  if ('result' in payload) return payload.result;
+  if (payload.data && typeof payload.data === 'object' && 'result' in payload.data) {
+    return payload.data.result;
+  }
+  return null;
+}
+
+export function extractScreenshotBase64(payload) {
+  if (!payload || typeof payload !== 'object') return '';
+  if (typeof payload.data === 'string' && payload.data) return payload.data;
+  if (payload.result && typeof payload.result === 'object' && typeof payload.result.data === 'string') {
+    return payload.result.data;
+  }
+  if (payload.data && typeof payload.data === 'object' && typeof payload.data.data === 'string') {
+    return payload.data.data;
+  }
+  return '';
+}
+
+export async function evaluateWithScript({ profileId, script, message, highlight }) {
+  const result = await runEvaluateScript({ profileId, script, highlight });
+  return { ok: true, code: 'OPERATION_DONE', message, data: result };
+}
+
+export function createEvaluateHandler(message, buildScript) {
+  return async ({ profileId, params }) => {
+    const script = buildScript(params);
+    const highlight = params.highlight !== false;
+    return evaluateWithScript({ profileId, script, message, highlight });
+  };
+}

package/src/autoscript/action-providers/xhs/detail.mjs

@@ -0,0 +1,181 @@
+export function buildDetailHarvestScript() {
+  return `(async () => {
+    const state = window.__camoXhsState || (window.__camoXhsState = {});
+    const scroller = document.querySelector('.note-scroller')
+      || document.querySelector('.comments-el')
+      || document.scrollingElement
+      || document.documentElement;
+    for (let i = 0; i < 3; i += 1) {
+      scroller.scrollBy({ top: 360, behavior: 'auto' });
+      await new Promise((resolve) => setTimeout(resolve, 120));
+    }
+    const title = (document.querySelector('.note-title') || {}).textContent || '';
+    const content = (document.querySelector('.note-content') || {}).textContent || '';
+    state.lastDetail = {
+      title: String(title).trim().slice(0, 200),
+      contentLength: String(content).trim().length,
+      capturedAt: new Date().toISOString(),
+    };
+    return { harvested: true, detail: state.lastDetail };
+  })()`;
+}
+
+export function buildExpandRepliesScript() {
+  return `(async () => {
+    const buttons = Array.from(document.querySelectorAll([
+      '.note-detail-mask .show-more',
+      '.note-detail-mask .reply-expand',
+      '.note-detail-mask [class*="expand"]',
+      '.note-detail-page .show-more',
+      '.note-detail-page .reply-expand',
+      '.note-detail-page [class*="expand"]',
+    ].join(',')));
+    let clicked = 0;
+    for (const button of buttons.slice(0, 8)) {
+      if (!(button instanceof HTMLElement)) continue;
+      const text = (button.textContent || '').trim();
+      if (!text) continue;
+      button.scrollIntoView({ behavior: 'auto', block: 'center' });
+      await new Promise((resolve) => setTimeout(resolve, 60));
+      button.click();
+      clicked += 1;
+      await new Promise((resolve) => setTimeout(resolve, 120));
+    }
+    return { expanded: clicked, scanned: buttons.length };
+  })()`;
+}
+
+export function buildCloseDetailScript() {
+  return `(async () => {
+    const state = window.__camoXhsState || (window.__camoXhsState = {});
+    const metrics = state.metrics && typeof state.metrics === 'object' ? state.metrics : {};
+    state.metrics = metrics;
+    metrics.searchCount = Number(metrics.searchCount || 0);
+    metrics.rollbackCount = Number(metrics.rollbackCount || 0);
+    metrics.returnToSearchCount = Number(metrics.returnToSearchCount || 0);
+    const harvest = state.lastCommentsHarvest && typeof state.lastCommentsHarvest === 'object'
+      ? state.lastCommentsHarvest
+      : null;
+    const exitMeta = {
+      pageExitReason: String(harvest?.exitReason || 'close_without_harvest').trim(),
+      reachedBottom: typeof harvest?.reachedBottom === 'boolean' ? harvest.reachedBottom : null,
+      commentsCollected: Number.isFinite(Number(harvest?.collected)) ? Number(harvest.collected) : null,
+      expectedCommentsCount: Number.isFinite(Number(harvest?.expectedCommentsCount)) ? Number(harvest.expectedCommentsCount) : null,
+      commentCoverageRate: Number.isFinite(Number(harvest?.commentCoverageRate)) ? Number(harvest.commentCoverageRate) : null,
+      scrollRecoveries: Number.isFinite(Number(harvest?.recoveries)) ? Number(harvest.recoveries) : 0,
+      harvestRounds: Number.isFinite(Number(harvest?.rounds)) ? Number(harvest.rounds) : null,
+    };
+    const detailSelectors = [
+      '.note-detail-mask',
+      '.note-detail-page',
+      '.note-detail-dialog',
+      '.note-detail-mask .detail-container',
+      '.note-detail-mask .media-container',
+      '.note-detail-mask .note-scroller',
+      '.note-detail-mask .note-content',
+      '.note-detail-mask .interaction-container',
+      '.note-detail-mask .comments-container',
+    ];
+    const searchSelectors = ['.note-item', '.search-result-list', '#search-input', '.feeds-page'];
+    const hasVisible = (selectors) => selectors.some((selector) => {
+      const node = document.querySelector(selector);
+      if (!node || !(node instanceof HTMLElement)) return false;
+      const style = window.getComputedStyle(node);
+      if (!style) return false;
+      if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity || '1') === 0) return false;
+      const rect = node.getBoundingClientRect();
+      return rect.width > 1 && rect.height > 1;
+    });
+    const isDetailVisible = () => hasVisible(detailSelectors);
+    const isSearchVisible = () => hasVisible(searchSelectors);
+    const dispatchEscape = () => {
+      const target = document.activeElement || document.body || document.documentElement;
+      const opts = { key: 'Escape', code: 'Escape', keyCode: 27, which: 27, bubbles: true, cancelable: true };
+      target.dispatchEvent(new KeyboardEvent('keydown', opts));
+      target.dispatchEvent(new KeyboardEvent('keyup', opts));
+      document.dispatchEvent(new KeyboardEvent('keydown', opts));
+      document.dispatchEvent(new KeyboardEvent('keyup', opts));
+    };
+    const waitForCloseAnimation = async () => {
+      for (let i = 0; i < 45; i += 1) {
+        if (!isDetailVisible() && isSearchVisible()) return true;
+        await new Promise((resolve) => setTimeout(resolve, 120));
+      }
+      return !isDetailVisible() && isSearchVisible();
+    };
+    const buildCounterMeta = (returnedToSearch) => ({
+      searchCount: Number(metrics.searchCount || 0),
+      rollbackCount: Number(metrics.rollbackCount || 0),
+      returnToSearchCount: Number(metrics.returnToSearchCount || 0),
+      returnedToSearch: Boolean(returnedToSearch),
+    });
+
+    if (!isDetailVisible()) {
+      return {
+        closed: true,
+        via: 'already_closed',
+        searchVisible: isSearchVisible(),
+        ...buildCounterMeta(false),
+        ...exitMeta,
+      };
+    }
+
+    metrics.rollbackCount += 1;
+    metrics.lastRollbackAt = new Date().toISOString();
+
+    for (let attempt = 1; attempt <= 4; attempt += 1) {
+      dispatchEscape();
+      await new Promise((resolve) => setTimeout(resolve, 220));
+      if (await waitForCloseAnimation()) {
+        const searchVisible = isSearchVisible();
+        if (searchVisible) {
+          metrics.returnToSearchCount += 1;
+          metrics.lastReturnToSearchAt = new Date().toISOString();
+        }
+        return {
+          closed: true,
+          via: 'escape',
+          attempts: attempt,
+          searchVisible,
+          ...buildCounterMeta(searchVisible),
+          ...exitMeta,
+        };
+      }
+    }
+
+    const selectors = ['.note-detail-mask .close-box', '.note-detail-mask .close-circle', '.close-box', '.close-circle'];
+    for (const selector of selectors) {
+      const target = document.querySelector(selector);
+      if (!target || !(target instanceof HTMLElement)) continue;
+      target.scrollIntoView({ behavior: 'auto', block: 'center' });
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      target.click();
+      await new Promise((resolve) => setTimeout(resolve, 220));
+      if (await waitForCloseAnimation()) {
+        const searchVisible = isSearchVisible();
+        if (searchVisible) {
+          metrics.returnToSearchCount += 1;
+          metrics.lastReturnToSearchAt = new Date().toISOString();
+        }
+        return {
+          closed: true,
+          via: selector,
+          attempts: 5,
+          searchVisible,
+          ...buildCounterMeta(searchVisible),
+          ...exitMeta,
+        };
+      }
+    }
+
+    return {
+      closed: false,
+      via: 'escape_failed',
+      detailVisible: isDetailVisible(),
+      searchVisible: isSearchVisible(),
+      ...buildCounterMeta(false),
+      ...exitMeta,
+    };
+  })()`;
+}
+