墨攻·广点通素材批量推送 v1.6.0 安装向导

推荐方式一：油猴版（一次安装，以后打开页面自动生效）

给 Chrome 安装扩展 Tampermonkey（点此打开下载页 → 下载并按页面指引安装到 Chrome）
点击下面的按钮复制脚本代码
点浏览器右上角 Tampermonkey 图标 → 添加新脚本 → Ctrl+A 全选删除模板 → Ctrl+V 粘贴 → Ctrl+S 保存
打开（或刷新）素材管理页，右侧出现「批量推送广点通」浮窗即安装成功

免安装方式二：控制台版（不需要装任何扩展，适合临时用）

打开素材管理页（usergrowth.com.cn/aigc/manage/creative）
按 F12 打开开发者工具，切到 Console（控制台） 标签
点下面按钮复制代码 → 在控制台粘贴 → 按回车
右侧出现「批量推送广点通」浮窗即可使用。页面刷新后需要重新粘贴一次

若控制台提示"请勿粘贴未知代码"，先手动输入 allow pasting 回车，再粘贴即可（每个浏览器只需操作一次）。

使用教程（浮窗面板详细说明）

一、推送前准备

打开 素材管理 页，确认素材列表能正常显示
先用页面上方的筛选条件（筛选器）筛出要推送的素材范围，脚本只会推送筛选结果里的素材
右下角可设置每页条数（50 / 100 / 500 条/页都可以），脚本会自动识别，无需在面板里填

二、面板各字段怎么填

投放产品：从下拉框直接选择推送目标产品（抖音火山版 / 抖音 / 抖音极速版）
账户类型：一般保持默认 广告账户；用管家账户时再切换
账户ID：完整的广告账号 ID（纯数字），例如 88047096。脚本会自动搜索并选中匹配的账户
起始页：从第几页开始推，默认自动填入当前所在页码，可手动改
推送页数：从起始页开始连续推几页。例如起始页=3、页数=5，会依次推送第 3、4、5、6、7 页
测试模式：第一次使用务必先勾选！流程会完整走一遍（勾选→全选→填弹窗），最后一步自动点"取消"，不会真的推送。日志全部正常后再去掉勾选正式运行

三、脚本每轮自动执行的动作

自动翻到目标页，等待新页素材真正加载完成
勾选第一张素材右上角的对勾 → 底部出现操作栏
点「全选当前页」，并校验选中数不超过每页条数（防止上一页残留混入）
点「推送」→ 悬停展开菜单 → 选「推送至·广点通素材中心」
弹窗中自动选产品、核对账户类型、填入账户 ID
点「确定」→ 自动关闭"推送任务创建成功"提示框（不会误点「查看任务详情」跳走）
自动清空选中，翻到下一页，重复以上步骤；全部完成后日志显示 🎉

四、推送进度去哪看

脚本只负责创建推送任务（提交后约 2 秒即完成）。实际推送进度请到墨攻AI左侧菜单「任务列表」页查看；几百条的任务可能需要几分钟到更久。

五、飞书通知配置（可选）

在飞书群里添加机器人：群设置 → 群机器人 → 添加机器人 → 自定义机器人，复制 Webhook 地址（形如 https://open.feishu.cn/open-apis/bot/v2/hook/xxx）
把 Webhook 地址填入面板「飞书通知 Webhook」；若机器人开启了签名校验，把密钥填入「签名密钥」（未开启则留空）
点面板上的「测试」按钮，群里收到"配置成功"消息即配置完成
之后每次任务结束（全部完成 / 中断 / 手动停止）都会自动把结果发到群里：产品、账户ID、完成页数、失败原因、时间等

六、常见问题

面板没出现？确认脚本已保存启用、刷新页面、且当前在"素材管理"页（其他页面不加载）。

提示"等待超时"？多为页面加载慢或网络波动：点「停止」→ 重新点「开始推送」，或把起始页改为失败页继续。连续失败请把日志截图发给管理员。

想中途停止？点「停止」，脚本会在当前步骤的安全检查点停下；已提交的推送任务不受影响。

日志出现"⚠ 选中数超过每页条数"？脚本检测到残留选中并自动清空重选，属正常自愈；若连续重选后仍报错停止，请人工检查页面后重试。

运行时要注意什么？不要最小化浏览器窗口、不要长时间切走标签页，否则页面渲染暂停可能导致等待超时。

// ==UserScript==
// @name         墨攻·广点通素材批量推送
// @namespace    mogong-auto-push
// @version      1.6.0
// @description  素材管理页自动循环：勾选素材→全选当前页→推送至广点通素材中心→选产品→填账户ID→确定，推送完成后自动翻下一页继续。页面右侧有浮窗面板，可设置产品/账户ID/起始页/页数，支持测试模式与随时停止。
// @author       sy
// @match        https://usergrowth.com.cn/*
// @run-at       document-idle
// @grant        none
// ==/UserScript==

/*
 * v1.6.0：新增「飞书通知」：任务结束（全部完成/中断/手动停止）自动把结果推送到飞书群机器人；
 *   面板填 Webhook 地址（签名密钥选填），「测试」按钮可验证；不填则完全不影响原流程
 * v1.5.0（真实推送 500条/页 × 2 页实测后修正）：
 * ★ 点「确定」后会弹出"推送任务创建成功"提示框：无自动关闭、只有「查看任务详情」按钮，
 *   旧版一直等它消失会导致超时 —— 现在识别该提示框后用右上角 X 关闭（绝不点「查看任务详情」跳走）
 * ★ 推送是异步任务（batch_operation/create 约2秒提交完成）；推送后列表不自动重载、选中保留
 * ★ 翻页等待改为"首卡标题变化"检测：翻页数据偶发延迟切换，固定等待会选到上一页素材
 * v1.4.0：防残留三道闸（清空校验/勾选后计数=1/全选后不超每页条数）
 * v1.3.0：移除补勾第一张卡片；v1.2.0：弹窗表单按标签精确匹配
 */

(function () {
  "use strict";

  if (!location.pathname.includes("/aigc/manage/creative")) return;

  // ---------------- 状态 ----------------
  const state = { running: false, stopRequested: false };

  // ---------------- 基础工具 ----------------
  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

  function visible(el) {
    if (!el) return false;
    const r = el.getBoundingClientRect();
    return r.width > 0 && r.height > 0;
  }

  // 轮询等待条件成立；state.stopRequested 时立刻抛错
  async function waitFor(fn, timeout = 10000, interval = 200, label = "") {
    const start = Date.now();
    while (Date.now() - start < timeout) {
      if (state.stopRequested) throw new Error("已手动停止");
      let v = null;
      try { v = fn(); } catch (e) { v = null; }
      if (v) return v;
      await sleep(interval);
    }
    throw new Error("等待超时：" + (label || "条件"));
  }

  // 模拟完整鼠标点击（带坐标 + pointer 事件，兼容 React/Arco 组件）
  function fireClick(el) {
    if (!el) throw new Error("fireClick：目标元素不存在");
    const r = el.getBoundingClientRect();
    const x = r.x + r.width / 2, y = r.y + r.height / 2;
    const opts = { bubbles: true, cancelable: true, view: window, clientX: x, clientY: y, button: 0 };
    const seq = ["pointerover", "mouseover", "mousemove", "pointerdown", "mousedown", "pointerup", "mouseup", "click"];
    for (const t of seq) {
      const Ev = t.startsWith("pointer") && window.PointerEvent ? PointerEvent : MouseEvent;
      el.dispatchEvent(new Ev(t, opts));
    }
  }

  // 仅悬停（不点击），用于展开 hover 触发的下拉
  function fireHover(el) {
    if (!el) throw new Error("fireHover：目标元素不存在");
    const r = el.getBoundingClientRect();
    const x = r.x + r.width / 2, y = r.y + r.height / 2;
    for (const t of ["pointerover", "mouseover", "mousemove"]) {
      const Ev = t.startsWith("pointer") && window.PointerEvent ? PointerEvent : MouseEvent;
      el.dispatchEvent(new Ev(t, { bubbles: true, cancelable: true, view: window, clientX: x, clientY: y }));
    }
  }

  // React 受控 input 赋值
  function fireInput(el, value) {
    el.focus();
    const setter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value").set;
    setter.call(el, value);
    el.dispatchEvent(new Event("input", { bubbles: true }));
    el.dispatchEvent(new Event("change", { bubbles: true }));
  }

  function pressEnter(el) {
    ["keydown", "keypress", "keyup"].forEach((t) =>
      el.dispatchEvent(new KeyboardEvent(t, { key: "Enter", code: "Enter", keyCode: 13, which: 13, bubbles: true, cancelable: true }))
    );
  }

  // ---------------- 页面元素定位（即取即用，防止 React 重挂节点失效） ----------------
  const getCards = () => [...document.querySelectorAll(".waterfall-item")];
  const getOpBar = () => document.querySelector("[class*='operation-bar-']");
  const getPager = () => document.querySelector(".arco-pagination");

  function getSelCount() {
    const bar = getOpBar();
    if (!bar) return 0;
    const num = bar.querySelector("[class*='selected-num']");
    return num ? parseInt(num.textContent.trim(), 10) || 0 : 0;
  }

  function getActivePage() {
    const el = document.querySelector(".arco-pagination-item-active");
    return el ? parseInt(el.textContent.trim(), 10) : null;
  }

  // 读取每页条数（如 50），读取失败返回 null
  function getPageSize() {
    const pager = getPager();
    if (!pager) return null;
    const sel = pager.querySelector(".arco-select");
    const m = sel ? sel.textContent.match(/(\d+)\s*条/) : null;
    return m ? parseInt(m[1], 10) : null;
  }

  function getTotalText() {
    const el = document.querySelector(".arco-pagination-total-text") ||
      [...document.querySelectorAll("[class*='total']")].find((x) => /共\s*\d+\s*条/.test(x.textContent));
    if (!el) return "";
    const m = el.textContent.match(/共\s*(\d+)\s*条/);
    return m ? "共 " + m[1] + " 条" : "";
  }

  // 查找可见的下拉菜单项
  const findMenuItem = (text) =>
    [...document.querySelectorAll(".arco-dropdown-menu-item")].find(
      (d) => d.textContent.includes(text) && visible(d)
    );

  // 查找可见且未禁用的下拉选项
  const findOption = (matcher) =>
    [...document.querySelectorAll(".arco-select-option")].find(
      (o) => visible(o) && !/disabled/.test(String(o.className)) && matcher(o.textContent.trim())
    );

  // 清空选中（带校验：点击关闭后轮询确认计数归零，未归零自动重试）
  async function clearSelection() {
    for (let t = 0; t < 3; t++) {
      const bar = getOpBar();
      if (!bar || !visible(bar)) return true;
      const num = bar.querySelector("[class*='selected-num']");
      const n = num ? parseInt(num.textContent.trim(), 10) || 0 : 0;
      if (n === 0) return true;
      const close = bar.querySelector("[class*='close-']");
      if (!close) return false;
      fireClick(close);
      await sleep(900);
    }
    const bar = getOpBar();
    const num = bar && bar.querySelector("[class*='selected-num']");
    return !num || (parseInt(num.textContent.trim(), 10) || 0) === 0;
  }

  // 翻到指定页：优先点页码按钮 → 跳页输入框 → 逐页点上一页/下一页
  async function goToPage(n) {
    const pager = getPager();
    if (!pager) throw new Error("找不到分页组件");
    pager.scrollIntoView({ block: "center" });
    await sleep(400);

    if (getActivePage() !== n) {
      const item = [...document.querySelectorAll(".arco-pagination-item")].find(
        (it) => it.textContent.trim() === String(n)
      );
      const jump = document.querySelector(".arco-pagination-jumper input, .arco-pagination-jumper-input input");
      if (item) {
        fireClick(item);
      } else if (jump) {
        fireInput(jump, String(n));
        pressEnter(jump);
      } else {
        const next = document.querySelector(".arco-pagination-item-next");
        const prev = document.querySelector(".arco-pagination-item-prev");
        let guard = 0;
        while (getActivePage() !== n && guard < 60) {
          if (state.stopRequested) throw new Error("已手动停止");
          const cur = getActivePage();
          const btn = n > cur ? next : prev;
          if (!btn) throw new Error("无法翻到第 " + n + " 页（页码按钮不存在且无上/下一页按钮）");
          fireClick(btn);
          await sleep(1200);
          guard++;
        }
      }
    }

    await waitFor(() => getActivePage() === n, 15000, 300, "翻到第 " + n + " 页");
    // ★ 等新页数据真正渲染：首卡标题应与翻页前不同（分页是前端切换，偶发延迟，固定等待会选到上一页素材）
    const prevFirst =
      (document.querySelector(".waterfall-item [class*='title-']") || {}).textContent?.trim() || "";
    const t0 = Date.now();
    while (Date.now() - t0 < 15000) {
      if (state.stopRequested) throw new Error("已手动停止");
      const cur =
        (document.querySelector(".waterfall-item [class*='title-']") || {}).textContent?.trim() || "";
      if (cur && cur !== prevFirst) break;
      await sleep(400);
    }
    await sleep(800); // 等列表渲染稳定
    const cards = getCards();
    if (cards.length) {
      cards[0].scrollIntoView({ block: "center" });
      await sleep(500);
    }
  }

  // 勾选第一个素材 → 全选当前页；返回最终选中数量
  // ★ 防残留：勾选后强制校验计数恰好=1；全选后校验不超过每页条数，异常自动重选
  async function selectAllCurrentPage() {
    const expected = getPageSize(); // 每页条数，读取失败时跳过严格校验
    for (let round = 0; round < 2; round++) {
      await clearSelection();

      // 第1步：勾选第一张卡片，并确认计数恰好变为 1（>1 说明有残留选中）
      let picked = false;
      for (let t = 0; t < 3 && !picked; t++) {
        const cards = getCards();
        if (!cards.length) throw new Error("页面上没有素材卡片");
        const first = cards[0];
        const r = first.getBoundingClientRect();
        first.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, clientX: r.x + r.width / 2, clientY: r.y + r.height / 2 }));
        await sleep(200);
        const icon = first.querySelector(".check-icon");
        if (!icon) throw new Error("找不到素材右上角的对勾");
        fireClick(icon);
        for (let i = 0; i < 20; i++) {
          await sleep(300);
          const n = getSelCount();
          if (n === 1) { picked = true; break; }
          if (n > 1) break; // 检测到残留，走外层重清
        }
        if (!picked) await clearSelection();
      }
      if (!picked) throw new Error("勾选素材后计数异常（当前 " + getSelCount() + "，应为 1），可能存在残留选中");

      // 第2步：点「全选当前页」下拉项（替换语义，结果=每页条数；下拉不出再兜底点按钮）
      let bulked = false;
      for (let t = 0; t < 3 && !bulked; t++) {
        const barEl = getOpBar();
        const selBtn = barEl && [...barEl.querySelectorAll("button")].find((b) => b.textContent.includes("全选"));
        if (!selBtn) throw new Error("找不到「全选」按钮");
        fireHover(selBtn);
        let dropItem = null;
        for (let i = 0; i < 12 && !dropItem; i++) {
          await sleep(150);
          dropItem = findMenuItem("全选当前页");
        }
        if (dropItem) {
          fireClick(dropItem);
        } else {
          fireClick(selBtn); // 兜底
        }
        for (let i = 0; i < 12; i++) {
          await sleep(300);
          if (getSelCount() > 1) { bulked = true; break; }
        }
      }
      if (!bulked) throw new Error("全选当前页未生效");

      // 第3步：校验选中数不超过每页条数（超出 = 上一页残留被带入）
      const n = getSelCount();
      if (n < 1) throw new Error("全选后选中数为 0");
      if (expected && n > expected) {
        if (round === 0) {
          log(`⚠ 选中数 ${n} 超过每页条数 ${expected}，检测到上一页残留，自动清空重选…`);
          continue;
        }
        throw new Error(`选中数 ${n} 仍超过每页条数 ${expected}，为避免把残留素材重复推送已停止，请人工检查`);
      }
      return n;
    }
  }

  // ★ 按表单「标签文本」精确匹配表单项
  // （不能用整项文本模糊匹配：「账户类型」项的单选文字里也含"广告账户"且排在前面，会误匹配）
  function findFormItem(modal, labelText) {
    return [...modal.querySelectorAll(".arco-form-item")].find((fi) => {
      const lb = fi.querySelector(".arco-form-label-item");
      return lb && lb.textContent.trim() === labelText;
    });
  }

  function findPushModal() {
    return [...document.querySelectorAll(".arco-modal")].find(
      (m) => visible(m) && ((m.querySelector(".arco-modal-title") || {}).textContent || "").includes("广点通素材中心")
    );
  }

  // 关闭上一轮残留的推送弹窗（脚本异常中断后重跑时可能存在）
  async function closeLeftoverModal() {
    const modal = findPushModal();
    if (modal) {
      const cancel = [...modal.querySelectorAll(".arco-modal-footer button")].find((b) => b.textContent.includes("取消"));
      if (cancel) { fireClick(cancel); await sleep(800); }
    }
  }

  // 在推送弹窗中选择产品 / 账户类型 / 填账户ID
  async function fillPushModal(product, accountType, accountId) {
    await waitFor(findPushModal, 6000, 200, "推送设置弹窗");

    // 1) 投放产品（名称去掉括号内计数后精确匹配）
    const prodItem = findFormItem(findPushModal(), "投放产品");
    if (!prodItem) throw new Error("弹窗里找不到「投放产品」");
    let opt = null;
    for (let t = 0; t < 2 && !opt; t++) {
      fireClick(prodItem.querySelector(".arco-select"));
      try {
        opt = await waitFor(() => findOption((txt) => txt.replace(/[（(][^）)]*[)）]\s*$/, "").trim() === product), 3000, 200, "");
      } catch (e) { /* 重试 */ }
    }
    if (!opt) throw new Error("找不到产品选项「" + product + "」");
    log("选择产品：" + opt.textContent.trim());
    fireClick(opt);
    await sleep(500);

    // 2) 账户类型（默认已选「广告账户」，需要时切换）
    const typeItem = findFormItem(findPushModal(), "账户类型");
    if (typeItem) {
      const radio = [...typeItem.querySelectorAll(".arco-radio")].find((x) => x.textContent.includes(accountType));
      if (radio && !radio.className.includes("checked")) {
        fireClick(radio);
        await sleep(400);
      }
    }

    // 3) 账户ID（可搜索多选框：输入 → 等匹配项 → 点击；无匹配则回车兜底）
    const accItem = findFormItem(findPushModal(), "广告账户");
    if (!accItem) throw new Error("弹窗里找不到「广告账户」表单项");
    const inp = accItem.querySelector("input.arco-input-tag-input");
    if (!inp) throw new Error("弹窗里找不到账户ID输入框");
    fireClick(inp);
    inp.focus();
    await sleep(300);
    fireInput(inp, accountId);
    await sleep(1000);
    let accOpt = null;
    try {
      accOpt = await waitFor(() => findOption((txt) => txt.includes(accountId)), 8000, 300, "账户ID匹配项");
    } catch (e) { /* 无匹配项时走回车兜底 */ }
    if (accOpt) {
      log("选中账户：" + accOpt.textContent.trim().slice(0, 40));
      fireClick(accOpt);
    } else {
      log("未搜索到匹配账户，尝试回车提交…");
      pressEnter(inp);
    }
    // 校验已形成标签（每次重新查询，防止 React 重渲染导致引用失效）
    await waitFor(() => {
      const m = findPushModal();
      const item = m && findFormItem(m, "广告账户");
      return !!(item && item.querySelectorAll(".arco-tag").length);
    }, 5000, 200, "账户ID填入");
  }

  // 点击确定提交；处理"推送任务创建成功"提示框（点右上角X关闭，绝不点「查看任务详情」）
  async function confirmPush(dryRun) {
    const modal = findPushModal();
    if (!modal) throw new Error("推送弹窗已关闭？");

    if (dryRun) {
      const cancel = [...modal.querySelectorAll(".arco-modal-footer button")].find((b) => b.textContent.includes("取消"));
      fireClick(cancel);
      await sleep(800);
      return "【测试模式】流程验证通过，未真正推送";
    }

    const ok = [...modal.querySelectorAll(".arco-modal-footer button")].find((b) => b.textContent.includes("确定"));
    fireClick(ok);
    log("已点击确定，提交推送任务…");

    const seenMsg = new Set();
    const start = Date.now();
    while (Date.now() - start < 60000) {
      if (state.stopRequested) throw new Error("已手动停止（注意：推送任务可能已提交）");
      document.querySelectorAll(".arco-message").forEach((m) => {
        const t = m.textContent.trim();
        if (t && !seenMsg.has(t)) { seenMsg.add(t); log("提示：" + t); }
      });
      const mods = [...document.querySelectorAll(".arco-modal")].filter(visible);
      if (mods.length === 0) return "推送任务已提交 ✔";
      for (const m of mods) {
        const txt = m.textContent;
        if (/推送任务创建成功/.test(txt)) {
          await sleep(600);
          const x = m.querySelector(".arco-modal-close-icon");
          if (x) {
            fireClick(x);
          } else {
            document.dispatchEvent(new KeyboardEvent("keydown", { key: "Escape", keyCode: 27, which: 27, bubbles: true }));
          }
          await sleep(800);
          return "推送任务已创建 ✔（进度请到左侧「任务列表」查看）";
        }
        if (/确认|是否|确定要/.test(txt)) {
          const b = [...m.querySelectorAll("button")].find((x) => /确定|确认|推送/.test(x.textContent));
          if (b) { log("出现二次确认，已点击"); fireClick(b); }
        } else if (/成功|完成|结果/.test(txt)) {
          const b = [...m.querySelectorAll("button")].find((x) => /确定|关闭|完成|知道了/.test(x.textContent));
          if (b) fireClick(b);
          return "推送完成 ✔";
        }
      }
      await sleep(800);
    }
    throw new Error("等待推送提交超时（60秒），请人工查看页面状态");
  }

  // ---------------- 飞书通知 ----------------
  // 通过飞书群「自定义机器人」Webhook 发送文本消息；未配置或格式不对时静默跳过
  async function sendFeishu(text) {
    const saved = JSON.parse(localStorage.getItem("mg_push_cfg") || "{}");
    const hook = (saved.feishuWebhook || "").trim();
    if (!/^https:\/\/open\.feishu\.cn\/open-apis\/bot\/v2\/hook\//.test(hook)) return false;
    try {
      const body = { msg_type: "text", content: { text } };
      const secret = (saved.feishuSecret || "").trim();
      if (secret) {
        // 飞书签名算法：HmacSHA256(key = "时间戳\n密钥", message = 空) 后 Base64
        const ts = Math.floor(Date.now() / 1000).toString();
        const enc = new TextEncoder();
        const key = await crypto.subtle.importKey(
          "raw", enc.encode(ts + "\n" + secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]
        );
        const sig = await crypto.subtle.sign("HMAC", key, new ArrayBuffer(0));
        body.timestamp = ts;
        body.sign = btoa(String.fromCharCode.apply(null, new Uint8Array(sig)));
      }
      try {
        const res = await fetch(hook, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
        const j = await res.json().catch(() => ({}));
        return j.code === 0 || j.StatusCode === 0 || j.StatusCode === undefined;
      } catch (e) {
        // 跨域受限时降级：消息仍会送达，只是读不到响应
        await fetch(hook, { method: "POST", mode: "no-cors", headers: { "Content-Type": "text/plain;charset=UTF-8" }, body: JSON.stringify(body) });
        return true;
      }
    } catch (e) {
      log("⚠ 飞书通知发送失败：" + e.message);
      return false;
    }
  }

  // ---------------- 主流程 ----------------
  async function runMain(cfg) {
    const { startPage, pages, product, accountType, accountId, dryRun } = cfg;
    log("当前列表 " + (getTotalText() || "条数未知"));
    let done = 0;
    let totalPushed = 0;
    let failMsg = "";
    for (let i = 0; i < pages; i++) {
      if (state.stopRequested) break;
      const target = startPage + i;
      log(`──── 第 ${i + 1}/${pages} 轮 · 目标第 ${target} 页 ────`);
      try {
        await closeLeftoverModal(); // 清理异常中断残留的弹窗
        if (getActivePage() !== target) await goToPage(target);
        const n = await selectAllCurrentPage();
        log(`已全选当前页 ${n} 项`);

        // 推送目标下拉：优先悬停展开（更安全），失败再点击按钮
        let gdt = null;
        for (let t = 0; t < 4 && !gdt; t++) {
          gdt = findMenuItem("广点通素材中心");
          if (!gdt) {
            const barEl = getOpBar();
            const pushBtn = barEl && [...barEl.querySelectorAll("button")].find((b) => b.textContent.trim() === "推送");
            if (!pushBtn) throw new Error("找不到「推送」按钮");
            if (t < 2) {
              fireHover(pushBtn); // 悬停展开，不点击
            } else {
              fireClick(pushBtn); // 兜底点击
            }
            try {
              gdt = await waitFor(() => findMenuItem("广点通素材中心"), 2500, 150, "");
            } catch (e) { /* 重试 */ }
          }
          await sleep(300);
        }
        if (!gdt) throw new Error("推送目标下拉未能打开");
        fireClick(gdt);

        await fillPushModal(product, accountType, accountId);
        log("弹窗填写完成，提交中…");
        log(await confirmPush(dryRun));
        done++;
        totalPushed += n;
        await sleep(2500);      // 等推送后的列表刷新稳定
        await clearSelection(); // 清空选中（带校验）
        await sleep(1000);
        await clearSelection(); // 刷新可能异步恢复选中，再清一次
      } catch (err) {
        failMsg = "第 " + target + " 页：" + err.message;
        log("❌ " + failMsg);
        log("脚本已停止。排查后可将「起始页」改为 " + target + " 继续。");
        break;
      }
    }
    let summary;
    if (state.stopRequested) summary = "⏹ 已手动停止";
    else if (failMsg) summary = "❌ 推送中断";
    else summary = dryRun ? "🧪 测试模式完成（未真实推送）" : "🎉 全部完成";
    log(`${summary}（完成 ${done}/${pages} 页）`);
    state.running = false;
    refreshButtons();
    // 飞书通知（面板未配置 Webhook 时自动跳过）
    const pageSize = getPageSize();
    const pushDetail =
      pageSize && totalPushed === pageSize * done
        ? `（每页 ${pageSize} 条 × ${done} 页）`
        : `（共 ${done} 页）`;
    const text = `[墨攻AI·批量推送] ${summary}\n` +
      `产品：${cfg.product}（${cfg.accountType}）\n账户ID：${cfg.accountId}\n` +
      `进度：完成 ${done}/${pages} 页（起始第 ${cfg.startPage} 页）\n` +
      `推送素材量：${totalPushed} 条${pushDetail}\n` +
      (failMsg ? `失败原因：${failMsg}\n` : "") +
      `时间：${new Date().toLocaleString("zh-CN", { hour12: false })}`;
    const fOk = await sendFeishu(text);
    log(fOk ? "📨 飞书通知已发送" : "（未配置飞书Webhook或发送失败，已跳过通知）");
  }

  // ---------------- 浮窗面板 UI ----------------
  let logBox, startBtn, stopBtn;

  function log(msg) {
    const line = document.createElement("div");
    line.textContent = "[" + new Date().toLocaleTimeString("zh-CN", { hour12: false }) + "] " + msg;
    line.style.margin = "2px 0";
    logBox && logBox.appendChild(line);
    if (logBox) logBox.scrollTop = logBox.scrollHeight;
    console.log("[墨攻推送] " + msg);
  }

  function refreshButtons() {
    if (startBtn) startBtn.disabled = state.running;
    if (stopBtn) stopBtn.disabled = !state.running;
  }

  function buildPanel() {
    if (document.getElementById("mg-push-panel")) return;
    const p = document.createElement("div");
    p.id = "mg-push-panel";
    Object.assign(p.style, {
      position: "fixed", top: "70px", right: "12px", zIndex: 2147483646,
      width: "300px", background: "#fff", borderRadius: "10px",
      boxShadow: "0 6px 24px rgba(0,0,0,.22)", font: "13px/1.5 system-ui,sans-serif",
      color: "#1d2129", userSelect: "none",
    });
    p.innerHTML = `
      <div id="mg-head" style="padding:10px 12px;background:#165dff;color:#fff;border-radius:10px 10px 0 0;cursor:move;font-weight:600">
        墨攻·广点通素材批量推送 v1.6</div>
      <div style="padding:10px 12px;display:flex;flex-direction:column;gap:8px">
        <label>投放产品<br><select id="mg-product" style="width:100%;padding:5px;border:1px solid #e5e6eb;border-radius:6px">
          <option>抖音火山版</option><option>抖音</option><option>抖音极速版</option>
        </select></label>
        <div style="display:flex;gap:8px">
          <label style="flex:1">账户类型<br><select id="mg-atype" style="width:100%;padding:5px;border:1px solid #e5e6eb;border-radius:6px">
            <option>广告账户</option><option>管家账户</option></select></label>
          <label style="flex:1.4">账户ID<br><input id="mg-acc" placeholder="完整账号ID"
            style="width:100%;box-sizing:border-box;padding:5px 8px;border:1px solid #e5e6eb;border-radius:6px"></label>
        </div>
        <div style="display:flex;gap:8px">
          <label style="flex:1">起始页<br><input id="mg-start" type="number" min="1" style="width:100%;padding:5px;border:1px solid #e5e6eb;border-radius:6px"></label>
          <label style="flex:1">推送页数<br><input id="mg-pages" type="number" min="1" value="1" style="width:100%;padding:5px;border:1px solid #e5e6eb;border-radius:6px"></label>
        </div>
        <label>飞书通知 Webhook（选填，任务结束时通知）<br><input id="mg-feishu" placeholder="https://open.feishu.cn/open-apis/bot/v2/hook/..."
          style="width:100%;box-sizing:border-box;padding:5px 8px;border:1px solid #e5e6eb;border-radius:6px"></label>
        <div style="display:flex;gap:8px;align-items:flex-end">
          <label style="flex:1">签名密钥（选填）<br><input id="mg-fssecret" placeholder="机器人未开启签名校验则留空"
            style="width:100%;box-sizing:border-box;padding:5px 8px;border:1px solid #e5e6eb;border-radius:6px"></label>
          <button id="mg-fstest" style="flex:0 0 auto;padding:6px 12px;background:#00b42a;color:#fff;border:0;border-radius:6px;cursor:pointer">测试</button>
        </div>
        <label style="color:#86909c"><input id="mg-dry" type="checkbox"> 测试模式（走完流程但最后点「取消」）</label>
        <div style="display:flex;gap:8px">
          <button id="mg-start-btn" style="flex:1;padding:7px 0;background:#165dff;color:#fff;border:0;border-radius:6px;cursor:pointer">开始推送</button>
          <button id="mg-stop-btn" style="flex:1;padding:7px 0;background:#f53f3f;color:#fff;border:0;border-radius:6px;cursor:pointer" disabled>停止</button>
        </div>
        <div id="mg-log" style="height:150px;overflow:auto;background:#f7f8fa;border-radius:6px;padding:6px 8px;font-size:12px;color:#4e5969"></div>
      </div>`;
    document.body.appendChild(p);
    logBox = p.querySelector("#mg-log");
    startBtn = p.querySelector("#mg-start-btn");
    stopBtn = p.querySelector("#mg-stop-btn");

    // 恢复上次的设置
    const saved = JSON.parse(localStorage.getItem("mg_push_cfg") || "{}");
    if (saved.product) p.querySelector("#mg-product").value = saved.product;
    if (saved.accountType) p.querySelector("#mg-atype").value = saved.accountType;
    if (saved.accountId) p.querySelector("#mg-acc").value = saved.accountId;
    if (saved.feishuWebhook) p.querySelector("#mg-feishu").value = saved.feishuWebhook;
    if (saved.feishuSecret) p.querySelector("#mg-fssecret").value = saved.feishuSecret;
    p.querySelector("#mg-start").value = getActivePage() || 1;

    // 拖动
    const head = p.querySelector("#mg-head");
    let drag = null;
    head.addEventListener("mousedown", (e) => {
      drag = { dx: e.clientX - p.offsetLeft, dy: e.clientY - p.offsetTop };
      e.preventDefault();
    });
    document.addEventListener("mousemove", (e) => {
      if (!drag) return;
      p.style.left = e.clientX - drag.dx + "px";
      p.style.top = e.clientY - drag.dy + "px";
      p.style.right = "auto";
    });
    document.addEventListener("mouseup", () => (drag = null));

    startBtn.addEventListener("click", () => {
      if (state.running) return;
      const cfg = {
        product: p.querySelector("#mg-product").value.trim(),
        accountType: p.querySelector("#mg-atype").value,
        accountId: p.querySelector("#mg-acc").value.trim(),
        startPage: parseInt(p.querySelector("#mg-start").value, 10),
        pages: parseInt(p.querySelector("#mg-pages").value, 10),
        dryRun: p.querySelector("#mg-dry").checked,
        feishuWebhook: p.querySelector("#mg-feishu").value.trim(),
        feishuSecret: p.querySelector("#mg-fssecret").value.trim(),
      };
      if (!cfg.product) return log("❌ 请填写投放产品");
      if (!/^\d+$/.test(cfg.accountId)) return log("❌ 请填写正确的账户ID（纯数字）");
      if (!cfg.startPage || cfg.startPage < 1) return log("❌ 起始页无效");
      if (!cfg.pages || cfg.pages < 1) return log("❌ 推送页数无效");
      localStorage.setItem("mg_push_cfg", JSON.stringify(cfg));
      state.running = true;
      state.stopRequested = false;
      refreshButtons();
      log(cfg.dryRun ? "▶ 测试模式启动" : `▶ 启动：从第 ${cfg.startPage} 页起推送 ${cfg.pages} 页 → ${cfg.product} / ${cfg.accountId}`);
      runMain(cfg).catch((e) => log("❌ 异常终止：" + e.message));
    });

    stopBtn.addEventListener("click", () => {
      state.stopRequested = true;
      log("⏳ 将在当前步骤安全检查点停止…");
      refreshButtons();
    });

    // 飞书通知测试按钮：保存配置并立即发一条测试消息
    p.querySelector("#mg-fstest").addEventListener("click", async () => {
      const saved = JSON.parse(localStorage.getItem("mg_push_cfg") || "{}");
      saved.feishuWebhook = p.querySelector("#mg-feishu").value.trim();
      saved.feishuSecret = p.querySelector("#mg-fssecret").value.trim();
      localStorage.setItem("mg_push_cfg", JSON.stringify(saved));
      if (!/^https:\/\/open\.feishu\.cn\/open-apis\/bot\/v2\/hook\//.test(saved.feishuWebhook)) {
        return log("❌ Webhook 地址格式不对，应为 https://open.feishu.cn/open-apis/bot/v2/hook/xxx");
      }
      log("📨 正在发送飞书测试通知…");
      const ok = await sendFeishu("[墨攻AI·批量推送] 飞书通知配置成功 ✓（此为测试消息）");
      log(ok ? "✅ 飞书测试通知已发送，请到群里查看" : "❌ 发送失败：请检查 Webhook 地址与签名密钥");
    });

    log("面板就绪（v1.6）。建议先用「测试模式」跑 1 页验证。");
  }

  // SPA 渲染完成后挂面板
  const tryMount = setInterval(() => {
    if (document.querySelector(".arco-pagination") || getCards().length) {
      clearInterval(tryMount);
      buildPanel();
    }
  }, 800);
  setTimeout(() => clearInterval(tryMount), 30000);
})();