Discourse Saver 油猴脚本安装器

功能特性

📝
多目标保存
支持 Obsidian、Notion、HTML 三种保存方式
💬
评论支持
可保存评论，支持楼层范围和折叠模式
🔗
快捷操作
单击链接按钮保存，双击复制链接
🖼️
图片嵌入
支持 Base64 嵌入图片，解决手机端显示问题
安装步骤

安装油猴扩展

首先确保浏览器已安装 Tampermonkey 或 Violentmonkey 扩展
点击安装按钮

点击下方的"一键安装脚本"按钮，油猴会自动弹出安装界面
确认安装

在油猴安装界面中点击"安装"或"确认"按钮完成安装
配置设置

访问任意 Discourse 论坛，点击油猴图标选择"设置"进行配置
如果按钮无效，请手动复制下方代码到油猴新建脚本
脚本源码

// ==UserScript==
// @name         Discourse Saver (油猴版)
// @namespace    https://github.com/discourse-saver
// @version      4.5.5
// @description  通用Discourse论坛内容保存工具 - 支持Obsidian/Notion/HTML，评论、用户名超链接、折叠模式
// @author       阿成
// @icon         https://www.google.com/s2/favicons?sz=64&domain=obsidian.md
// @match        https://linux.do/*
// @match        https://meta.discourse.org/*
// @match        https://users.rust-lang.org/*
// @match        https://forums.docker.com/*
// @match        https://community.openai.com/*
// @match        https://discuss.python.org/*
// @match        https://*.discourse.group/*
// @match        https://forum.obsidian.md/*
// @match        https://community.cloudflare.com/*
// @match        https://forum.cursor.com/*
// @match        https://community.render.com/*
// @match        https://community.fly.io/*
// @match        https://discourse.haskell.org/*
// @match        https://discourse.julialang.org/*
// @match        https://forum.rclone.org/*
// @match        https://discourse.nixos.org/*
// @include      *://*discourse*/*
// @include      *://*forum*/*
// @require      https://cdn.jsdelivr.net/npm/turndown@7.1.2/dist/turndown.js
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @grant        GM_notification
// @grant        GM_setClipboard
// @grant        GM_addStyle
// @grant        GM_xmlhttpRequest
// @connect      *
// @run-at       document-end
// @license      MIT
// @downloadURL  https://github.com/discourse-saver/userscript/raw/main/discourse-saver.user.js
// @updateURL    https://github.com/discourse-saver/userscript/raw/main/discourse-saver.user.js
// ==/UserScript==

(function() {
  'use strict';

  // ============================================================
  // 模块1: 配置管理 (ConfigModule)
  // ============================================================
  const ConfigModule = (function() {
    const DEFAULT_CONFIG = {
      // 保存目标
      saveToObsidian: true,
      saveToNotion: false,
      exportHtml: false,

      // Obsidian 设置
      vaultName: '',
      folderPath: 'Discourse收集箱',
      useAdvancedUri: true,

      // Notion 设置
      notionToken: '',
      notionDatabaseId: '',
      notionPropTitle: '标题',
      notionPropUrl: '链接',
      notionPropAuthor: '作者',
      notionPropCategory: '分类',
      notionPropTags: '标签',
      notionPropSavedDate: '保存日期',
      notionPropCommentCount: '评论数',

      // HTML 导出设置
      htmlExportFolder: 'Discourse导出',

      // 内容设置
      addMetadata: true,
      includeImages: true,
      embedImages: false,  // 将图片嵌入为 Base64（解决手机端图片无法显示问题）

      // 评论设置
      saveComments: false,
      commentCount: 100,
      saveAllComments: false,  // 与 useFloorRange 互斥
      foldComments: false,

      // 楼层范围（与 saveAllComments 互斥）
      useFloorRange: false,
      floorFrom: 1,
      floorTo: 100
    };

    function get(key) {
      if (key) {
        return GM_getValue(key, DEFAULT_CONFIG[key]);
      }
      // 获取全部配置
      const config = {};
      for (const k in DEFAULT_CONFIG) {
        config[k] = GM_getValue(k, DEFAULT_CONFIG[k]);
      }
      return config;
    }

    function set(key, value) {
      GM_setValue(key, value);
    }

    function setAll(config) {
      for (const k in config) {
        GM_setValue(k, config[k]);
      }
    }

    function getDefault() {
      return { ...DEFAULT_CONFIG };
    }

    return { get, set, setAll, getDefault };
  })();

  // ============================================================
  // 模块2: 工具函数 (UtilModule)
  // ============================================================
  const UtilModule = (function() {
    // 获取北京时间
    function getBeijingTime() {
      const now = new Date();
      const utc = now.getTime() + now.getTimezoneOffset() * 60000;
      const beijing = new Date(utc + 8 * 3600000);
      const year = beijing.getFullYear();
      const month = String(beijing.getMonth() + 1).padStart(2, '0');
      const day = String(beijing.getDate()).padStart(2, '0');
      const hours = String(beijing.getHours()).padStart(2, '0');
      const minutes = String(beijing.getMinutes()).padStart(2, '0');
      const seconds = String(beijing.getSeconds()).padStart(2, '0');
      return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    }

    // 清理文件名
    function sanitizeFileName(name) {
      return name
        .replace(/[<>:"/\|?*]/g, '')
        .replace(/\s+/g, ' ')
        .trim()
        .substring(0, 100);
    }

    // 显示通知
    function showNotification(message, type = 'info') {
      // 移除旧通知
      const old = document.querySelector('.ds-notification');
      if (old) old.remove();

      const colors = {
        success: '#10b981',
        error: '#ef4444',
        info: '#3b82f6',
        warning: '#f59e0b'
      };

      const div = document.createElement('div');
      div.className = 'ds-notification';
      div.style.cssText = `
        position: fixed;
        top: 20px;
        right: 20px;
        padding: 12px 20px;
        background: ${colors[type] || colors.info};
        color: white;
        border-radius: 8px;
        font-size: 14px;
        z-index: 999999;
        box-shadow: 0 4px 12px rgba(0,0,0,0.3);
        animation: dsSlideIn 0.3s ease;
      `;
      div.textContent = message;
      document.body.appendChild(div);

      setTimeout(() => div.remove(), 3000);
    }

    // 图片嵌入限制常量
    const IMAGE_LIMITS = {
      MAX_SINGLE_SIZE: 15 * 1024 * 1024,    // 单张图片最大 15MB
      MAX_TOTAL_SIZE: 100 * 1024 * 1024,    // 总大小最大 100MB
      MAX_IMAGE_COUNT: 50                    // 最多嵌入 50 张图片
    };

    // 下载图片并转换为 Base64（带大小检测）
    function fetchImageAsBase64(url, maxSize = IMAGE_LIMITS.MAX_SINGLE_SIZE) {
      return new Promise((resolve, reject) => {
        GM_xmlhttpRequest({
          method: 'GET',
          url: url,
          responseType: 'blob',
          timeout: 30000,
          onload: function(response) {
            if (response.status >= 200 && response.status < 300) {
              const blob = response.response;

              // 检查图片大小
              if (blob.size > maxSize) {
                reject(new Error(`图片过大 (${(blob.size/1024/1024).toFixed(1)}MB > ${(maxSize/1024/1024).toFixed(0)}MB限制)`));
                return;
              }

              const reader = new FileReader();
              reader.onloadend = () => resolve({
                data: reader.result,
                size: blob.size
              });
              reader.onerror = () => reject(new Error('Failed to read blob'));
              reader.readAsDataURL(blob);
            } else {
              reject(new Error(`HTTP ${response.status}`));
            }
          },
          onerror: function() {
            reject(new Error('Network error'));
          },
          ontimeout: function() {
            reject(new Error('Timeout'));
          }
        });
      });
    }

    // 批量将 Markdown 中的图片 URL 替换为 Base64
    async function embedImagesInMarkdown(markdown, onProgress = null) {
      // 参数验证
      if (!markdown || typeof markdown !== 'string') {
        console.warn('[Discourse Saver] embedImagesInMarkdown: 无效的 markdown 参数');
        return markdown || '';
      }

      // 匹配 Markdown 图片语法: ![alt](url)
      const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
      let matches;
      try {
        matches = [...markdown.matchAll(imageRegex)];
      } catch (regexError) {
        console.error('[Discourse Saver] 正则匹配失败:', regexError);
        return markdown;
      }

      if (matches.length === 0) {
        return markdown;
      }

      console.log(`[Discourse Saver] 发现 ${matches.length} 张图片`);

      // 收集所有图片 URL（去重）
      const urlList = [];
      const seenUrls = new Set();
      for (const match of matches) {
        const url = match[2];
        // 跳过已经是 base64 的图片和无效 URL
        if (url && !url.startsWith('data:') && url.startsWith('http') && !seenUrls.has(url)) {
          seenUrls.add(url);
          urlList.push(url);
        }
      }

      if (urlList.length === 0) {
        console.log('[Discourse Saver] 没有需要嵌入的图片');
        return markdown;
      }

      // 应用图片数量限制
      const effectiveUrls = urlList.slice(0, IMAGE_LIMITS.MAX_IMAGE_COUNT);
      if (urlList.length > IMAGE_LIMITS.MAX_IMAGE_COUNT) {
        console.warn(`[Discourse Saver] 图片数量 (${urlList.length}) 超过限制 (${IMAGE_LIMITS.MAX_IMAGE_COUNT})，只嵌入前 ${IMAGE_LIMITS.MAX_IMAGE_COUNT} 张`);
        showNotification(`图片过多，只嵌入前 ${IMAGE_LIMITS.MAX_IMAGE_COUNT} 张`, 'warning');
      }

      console.log(`[Discourse Saver] 开始嵌入 ${effectiveUrls.length} 张图片...`);

      // 用于存储结果和追踪总大小
      const urlMap = new Map();
      let totalSize = 0;
      let completed = 0;
      let skippedCount = 0;
      const total = effectiveUrls.length;
      const OVERALL_TIMEOUT = 180000; // 3分钟总超时（增加到3分钟以支持更多图片）

      try {
        await Promise.race([
          Promise.all(effectiveUrls.map(async (url) => {
            try {
              // 检查是否已超过总大小限制
              if (totalSize >= IMAGE_LIMITS.MAX_TOTAL_SIZE) {
                console.warn(`[Discourse Saver] 总大小已达限制，跳过: ${url.substring(0, 50)}...`);
                urlMap.set(url, null);
                skippedCount++;
                completed++;
                if (onProgress) onProgress(completed, total);
                return;
              }

              const result = await fetchImageAsBase64(url);
              const imageSize = result.size;

              // 检查添加此图片后是否超过总大小限制
              if (totalSize + imageSize > IMAGE_LIMITS.MAX_TOTAL_SIZE) {
                console.warn(`[Discourse Saver] 添加此图片将超过总大小限制，跳过 (${(imageSize/1024/1024).toFixed(1)}MB)`);
                urlMap.set(url, null);
                skippedCount++;
              } else {
                urlMap.set(url, result.data);
                totalSize += imageSize;
                console.log(`[Discourse Saver] 图片嵌入 ${completed+1}/${total}: ${(imageSize/1024).toFixed(0)}KB, 总计: ${(totalSize/1024/1024).toFixed(1)}MB`);
              }

              completed++;
              if (onProgress) onProgress(completed, total);
            } catch (error) {
              console.warn(`[Discourse Saver] 图片下载失败: ${url}`, error.message);
              urlMap.set(url, null);
              skippedCount++;
              completed++;
              if (onProgress) onProgress(completed, total);
            }
          })),
          new Promise((_, reject) =>
            setTimeout(() => reject(new Error('图片嵌入总超时')), OVERALL_TIMEOUT)
          )
        ]);
      } catch (timeoutError) {
        console.warn('[Discourse Saver] 图片嵌入超时，部分图片可能未嵌入:', timeoutError.message);
      }

      // 替换 Markdown 中的图片 URL
      let result = markdown;
      try {
        for (const [url, base64] of urlMap.entries()) {
          if (base64 && typeof base64 === 'string') {
            result = result.split(`](${url})`).join(`](${base64})`);
          }
        }
      } catch (replaceError) {
        console.error('[Discourse Saver] 图片 URL 替换失败:', replaceError);
        return markdown;
      }

      const successCount = [...urlMap.values()].filter(v => v !== null).length;
      console.log(`[Discourse Saver] 图片嵌入完成: ${successCount}/${total} 成功, ${skippedCount} 跳过, 总大小: ${(totalSize/1024/1024).toFixed(1)}MB`);

      if (skippedCount > 0) {
        showNotification(`已嵌入 ${successCount} 张图片，${skippedCount} 张因过大或超限跳过`, 'info');
      }

      return result;
    }

    return { getBeijingTime, sanitizeFileName, showNotification, fetchImageAsBase64, embedImagesInMarkdown };
  })();

  // ============================================================
  // 模块3: 内容提取 (ExtractModule)
  // ============================================================
  const ExtractModule = (function() {
    // 检查是否在帖子页面
    function isTopicPage() {
      return document.querySelector('#topic-title h1') !== null;
    }

    // 提取主帖内容
    function extractContent() {
      const titleElement = document.querySelector('#topic-title h1');
      const contentElement = document.querySelector('.topic-body .cooked');
      const authorElement = document.querySelector('.topic-meta-data .creator a, .names .first a');

      if (!titleElement || !contentElement) {
        return null;
      }

      const title = titleElement.textContent.trim();
      const contentHTML = contentElement.innerHTML;
      const url = window.location.href;
      const author = authorElement ? authorElement.textContent.trim() : '未知作者';
      const topicId = window.location.pathname.match(/\/t\/[^/]+\/(\d+)/)?.[1];

      // 提取分类
      let category = '';
      const categoryBadge = document.querySelector('.topic-category .badge-category__name, .badge-category-bg .badge-category__name');
      if (categoryBadge) {
        category = categoryBadge.textContent.trim();
      }

      // 提取标签
      const tags = [];
      const tagElements = document.querySelectorAll('.discourse-tags .discourse-tag, .list-tags .discourse-tag');
      tagElements.forEach(tag => {
        const tagText = tag.textContent.trim();
        if (tagText && !tags.includes(tagText)) {
          tags.push(tagText);
        }
      });

      return { title, contentHTML, url, author, topicId, category, tags };
    }

    // 提取评论（DOM方式）
    function extractComments(maxCount = 100) {
      const comments = [];
      let commentElements = document.querySelectorAll('div.crawler-post');

      if (commentElements.length === 0) {
        commentElements = document.querySelectorAll('.topic-post');
      }

      const commentNodes = Array.from(commentElements).slice(1, maxCount + 1);
      const baseUrl = window.location.origin;

      for (const el of commentNodes) {
        const usernameEl = el.querySelector('.creator span[itemprop="name"]') ||
                           el.querySelector('.names .first a') ||
                           el.querySelector('.username a');
        const username = usernameEl ? usernameEl.textContent.trim() : '匿名用户';

        // 提取用户主页链接
        let userUrl = '';
        const userLinkEl = el.querySelector('.creator a[href*="/u/"]') ||
                           el.querySelector('.names .first a[href*="/u/"]') ||
                           el.querySelector('.username a[href*="/u/"]') ||
                           el.querySelector('a[data-user-card]');
        if (userLinkEl) {
          userUrl = userLinkEl.href;
        } else if (username && username !== '匿名用户') {
          userUrl = `${baseUrl}/u/${username}`;
        }

        const contentEl = el.querySelector('.post[itemprop="text"]') ||
                          el.querySelector('.cooked');
        const contentHTML = contentEl ? contentEl.innerHTML : '';

        const positionEl = el.querySelector('span[itemprop="position"]') ||
                           el.querySelector('.post-number');
        const position = positionEl ? positionEl.textContent.trim() : (comments.length + 2).toString();

        const timeEl = el.querySelector('time.post-time') ||
                       el.querySelector('.relative-date');
        const time = timeEl ? (timeEl.getAttribute('datetime') || timeEl.textContent) : '';

        const likesEl = el.querySelector('meta[itemprop="userInteractionCount"]') ||
                        el.querySelector('.post-likes');
        const likes = likesEl ?
                      (likesEl.getAttribute('content') || likesEl.textContent.replace(/[^\d]/g, '')) : '0';

        if (contentHTML) {
          comments.push({
            username,
            userUrl,
            contentHTML,
            position,
            time,
            likes
          });
        }
      }

      console.log(`[Discourse Saver] 提取到 ${comments.length} 条评论`);
      return comments;
    }

    // 使用API获取评论
    async function extractCommentsViaAPI(topicId, maxCount, saveAll = false, progressCallback = null) {
      const comments = [];
      const baseUrl = window.location.origin;

      try {
        if (progressCallback) progressCallback('正在获取帖子信息...');
        const topicUrl = `${baseUrl}/t/${topicId}.json`;
        const topicResponse = await fetch(topicUrl, { credentials: 'include' });

        if (!topicResponse.ok) {
          throw new Error(`获取帖子信息失败: ${topicResponse.status}`);
        }

        const topicData = await topicResponse.json();
        const stream = topicData.post_stream?.stream || [];
        const totalPosts = stream.length;

        if (totalPosts === 0) {
          return comments;
        }

        const commentIds = stream.slice(1);
        const targetCount = saveAll ? commentIds.length : Math.min(maxCount, commentIds.length);
        const idsToFetch = commentIds.slice(0, targetCount);

        // 分批获取
        const batchSize = 20;
        for (let i = 0; i < idsToFetch.length; i += batchSize) {
          const batch = idsToFetch.slice(i, i + batchSize);
          const params = batch.map(id => `post_ids[]=${id}`).join('&');
          const postsUrl = `${baseUrl}/t/${topicId}/posts.json?${params}`;

          if (progressCallback) {
            const progress = Math.min(i + batchSize, idsToFetch.length);
            progressCallback(`正在加载评论 ${progress}/${targetCount}...`);
          }

          const postsResponse = await fetch(postsUrl, { credentials: 'include' });
          if (!postsResponse.ok) continue;

          const postsData = await postsResponse.json();
          const posts = postsData.post_stream?.posts || [];

          for (const post of posts) {
            if (post.post_number === 1) continue;

            const postUsername = post.username || post.display_username || '匿名用户';
            const userUrl = postUsername !== '匿名用户' ? `${baseUrl}/u/${postUsername}` : '';

            comments.push({
              username: postUsername,
              userUrl,
              contentHTML: post.cooked || '',
              position: String(post.post_number),
              time: post.created_at || '',
              likes: String(post.like_count || 0)
            });
          }

          if (i + batchSize < idsToFetch.length) {
            await new Promise(r => setTimeout(r, 100));
          }
        }

        comments.sort((a, b) => parseInt(a.position) - parseInt(b.position));
        return comments;

      } catch (error) {
        console.error('[Discourse Saver] API获取评论失败:', error);
        throw error;
      }
    }

    // 提取单条评论
    function extractSingleComment(postNumber) {
      const commentElements = document.querySelectorAll('.topic-post, article[data-post-id]');
      const baseUrl = window.location.origin;

      for (const el of commentElements) {
        const posNum = el.getAttribute('data-post-number') ||
                       el.querySelector('[data-post-number]')?.getAttribute('data-post-number');

        if (posNum === postNumber) {
          const usernameEl = el.querySelector('.creator span[itemprop="name"]') ||
                             el.querySelector('.names .first a') ||
                             el.querySelector('.username a');
          const username = usernameEl ? usernameEl.textContent.trim() : '匿名用户';

          let userUrl = '';
          const userLinkEl = el.querySelector('.creator a[href*="/u/"]') ||
                             el.querySelector('.names .first a[href*="/u/"]') ||
                             el.querySelector('.username a[href*="/u/"]') ||
                             el.querySelector('a[data-user-card]');
          if (userLinkEl) {
            userUrl = userLinkEl.href;
          } else if (username && username !== '匿名用户') {
            userUrl = `${baseUrl}/u/${username}`;
          }

          const contentEl = el.querySelector('.post[itemprop="text"]') ||
                            el.querySelector('.cooked');
          const contentHTML = contentEl ? contentEl.innerHTML : '';

          const timeEl = el.querySelector('time.post-time') ||
                         el.querySelector('.relative-date');
          const time = timeEl ? (timeEl.getAttribute('datetime') || timeEl.textContent) : '';

          const likesEl = el.querySelector('meta[itemprop="userInteractionCount"]') ||
                          el.querySelector('.post-likes');
          const likes = likesEl ?
                        (likesEl.getAttribute('content') || likesEl.textContent.replace(/[^\d]/g, '')) : '0';

          return {
            username,
            userUrl,
            contentHTML,
            position: postNumber,
            time,
            likes
          };
        }
      }
      return null;
    }

    return {
      isTopicPage,
      extractContent,
      extractComments,
      extractCommentsViaAPI,
      extractSingleComment
    };
  })();

  // ============================================================
  // 模块4: Markdown转换 (ConvertModule)
  // ============================================================
  const ConvertModule = (function() {
    let turndownService = null;

    // 解析视频URL
    function parseVideoUrl(href) {
      // YouTube
      const ytMatch = href.match(/(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/)([a-zA-Z0-9_-]{11})/);
      if (ytMatch) {
        return { embedUrl: 'https://www.youtube.com/embed/' + ytMatch[1], isVideo: true, platform: 'youtube' };
      }
      // Bilibili
      const biliMatch = href.match(/bilibili\.com\/video\/(BV[a-zA-Z0-9]+|av\d+)/i);
      if (biliMatch) {
        const vid = biliMatch[1];
        if (vid.toLowerCase().startsWith('bv')) {
          return { embedUrl: '//player.bilibili.com/player.html?bvid=' + vid, isVideo: true, platform: 'bilibili' };
        } else {
          return { embedUrl: '//player.bilibili.com/player.html?aid=' + vid.replace(/^av/i, ''), isVideo: true, platform: 'bilibili' };
        }
      }
      // Vimeo
      const vimeoMatch = href.match(/vimeo\.com\/(\d+)/);
      if (vimeoMatch) {
        return { embedUrl: 'https://player.vimeo.com/video/' + vimeoMatch[1], isVideo: true, platform: 'vimeo' };
      }
      return { embedUrl: '', isVideo: false, platform: '' };
    }

    // 生成视频嵌入
    function generateVideoEmbed(videoInfo, originalUrl) {
      if (videoInfo.embedUrl) {
        return '

<iframe src="' + videoInfo.embedUrl + '" style="width:100%; aspect-ratio:16/9;" frameborder="0" allowfullscreen></iframe>

';
      }
      return '

' + originalUrl + '

';
    }

    // 初始化Turndown
    function initTurndown() {
      if (turndownService) return turndownService;

      turndownService = new TurndownService({
        headingStyle: 'atx',
        codeBlockStyle: 'fenced',
        emDelimiter: '*'
      });

      // 保留颜色样式
      turndownService.addRule('coloredText', {
        filter: (node) => {
          if (node.nodeName !== 'SPAN') return false;
          const style = node.getAttribute('style') || '';
          return style.includes('color');
        },
        replacement: (content, node) => {
          const style = node.getAttribute('style') || '';
          const colorMatch = style.match(/color:\s*([^;]+)/i);
          if (colorMatch && content.trim()) {
            const color = colorMatch[1].trim();
            return `<span style="color:${color}">${content}</span>`;
          }
          return content;
        }
      });

      // 处理代码块
      turndownService.addRule('codeBlocks', {
        filter: (node) => {
          return node.nodeName === 'PRE' && node.querySelector('code');
        },
        replacement: (content, node) => {
          const codeNode = node.querySelector('code');
          if (!codeNode) return content;

          const clonedCode = codeNode.cloneNode(true);
          const brTags = clonedCode.querySelectorAll('br');
          brTags.forEach(br => br.replaceWith('
'));
          const code = clonedCode.textContent;

          const langFromClass = codeNode.className.match(/lang-(\w+)/);
          const langFromData = node.getAttribute('data-code-wrap');
          const lang = langFromClass ? langFromClass[1] : (langFromData || '');

          return '

```' + lang + '
' + code + '
```

';
        }
      });

      // 处理lightbox图片
      turndownService.addRule('lightboxImages', {
        filter: (node) => {
          return node.nodeName === 'A' &&
                 node.classList.contains('lightbox') &&
                 node.querySelector('img');
        },
        replacement: (content, node) => {
          const img = node.querySelector('img');
          if (!img) return '';

          const src = node.href || img.src;
          const fullSrc = src.startsWith('http') ? src : window.location.origin + src;
          const alt = (img.getAttribute('data-base62-sha1') ||
                      img.alt?.replace(/[_\d]+$/, '').trim() ||
                      'image').replace(/[
]+/g, ' ').trim();

          return '

![' + alt + '](' + fullSrc + ')

';
        }
      });

      // 处理普通图片
      turndownService.addRule('images', {
        filter: (node) => {
          if (node.nodeName !== 'IMG') return false;
          if (node.classList.contains('emoji')) return false;
          if (node.parentNode?.classList?.contains('lightbox')) return false;
          return true;
        },
        replacement: (content, node) => {
          const src = node.src;
          if (!src) return '';

          const fullSrc = src.startsWith('http') ? src : window.location.origin + src;
          const alt = (node.alt?.replace(/[_\d]+$/, '').trim() || 'image').replace(/[
]+/g, ' ').trim();

          return '

![' + alt + '](' + fullSrc + ')

';
        }
      });

      // 移除emoji
      turndownService.addRule('emojiImages', {
        filter: (node) => {
          if (node.nodeName !== 'IMG') return false;
          const className = node.className || '';
          const src = node.src || '';
          const alt = node.alt || '';
          if (className.includes('emoji') ||
              src.includes('/emoji/') ||
              src.includes('twemoji') ||
              /^:[^:]+:$/.test(alt)) return true;
          return false;
        },
        replacement: () => ''
      });

      // 视频链接转iframe
      turndownService.addRule('onlineVideoEmbed', {
        filter: (node) => {
          if (node.nodeName !== 'A') return false;
          const href = node.href || '';
          const videoInfo = parseVideoUrl(href);
          return videoInfo.isVideo;
        },
        replacement: (content, node) => {
          const href = node.href || '';
          const videoInfo = parseVideoUrl(href);
          if (videoInfo.isVideo) {
            return generateVideoEmbed(videoInfo, href);
          }
          return '[' + content + '](' + href + ')';
        }
      });

      // 文档链接
      turndownService.addRule('documentEmbed', {
        filter: (node) => {
          if (node.nodeName !== 'A') return false;
          if (node.classList?.contains('lightbox')) return false;
          const href = (node.href || '').toLowerCase();
          return /\.(pdf|docx?|xlsx?|pptx?|svg|csv|txt)(\?|$)/i.test(href);
        },
        replacement: (content, node) => {
          const href = node.href || '';
          const hrefLower = href.toLowerCase();

          let fileName = content.trim().replace(/[
]+/g, ' ').trim();
          const imgMatch = fileName.match(/^!\[([^\]]*)\]\([^)]+\)$/);
          if (imgMatch) {
            fileName = imgMatch[1] || '';
          }
          fileName = fileName || href.split('/').pop().split('?')[0] || '文档';

          if (/\.svg(\?|$)/i.test(hrefLower)) {
            return '

![' + fileName + '](' + href + ')

';
          }
          if (/\.pdf(\?|$)/i.test(hrefLower)) {
            return '

📄 **' + fileName + '**
📥 [下载 PDF](' + href + ')

';
          }
          return '

📎 **' + fileName + '**
📥 [下载文件](' + href + ')

';
        }
      });

      return turndownService;
    }

    // 清理Markdown
    function cleanupMarkdown(markdown) {
      // 移除空锚点链接
      markdown = markdown.replace(/\[\s*\]\(#[^)]*\)/g, '');
      // 移除emoji图片语法
      markdown = markdown.replace(/!\[:[a-z_]+:\]\([^)]+\)/gi, '');
      // 移除图片尺寸信息行
      markdown = markdown.replace(/^\s*\d+×\d+\s+\d+(?:\.\d+)?\s*(?:KB|MB|GB)\s*$/gim, '');
      // 移除转义下划线
      markdown = markdown.replace(/\_/g, '_');
      // 清理嵌套图片链接
      markdown = markdown.replace(/\[!\[([^\]]*)\]\([^)]+\)\]\(([^)]+)\)/g, '![$1]($2)');
      markdown = markdown.replace(/!\[!\[([^\]]*)\]\([^)]+\)\]\(([^)]+)\)/g, '![$1]($2)');
      markdown = markdown.replace(/!!\[/g, '![');
      // 移除GIF
      markdown = markdown.replace(/!\[[^\]]*\]\([^)]*\.gif[^)]*\)/gi, '');
      // 移除多余空行
      markdown = markdown.replace(/
{3,}/g, '

');

      return markdown;
    }

    // 转换为带评论的Markdown
    function convertToMarkdownWithComments(contentHTML, metadata, comments, config) {
      const td = initTurndown();
      let mainContent = td.turndown(contentHTML);
      mainContent = cleanupMarkdown(mainContent);

      let markdown = '';

      // 添加元数据
      if (config.addMetadata) {
        const timeStr = UtilModule.getBeijingTime();
        const allTags = ['discourse'];
        if (metadata.tags && metadata.tags.length > 0) {
          metadata.tags.forEach(tag => {
            const cleanTag = String(tag).trim();
            if (cleanTag && !allTags.includes(cleanTag)) {
              allTags.push(cleanTag);
            }
          });
        }
        // 生成 YAML 列表格式的 tags
        const tagsYaml = allTags
          .map(t => t.replace(/[,\[\]#]/g, '').trim())
          .filter(t => t)
          .map(t => `  - ${t}`)
          .join('
');

        markdown += `---
来源: ${metadata.url}
标题: "${metadata.title.replace(/"/g, '\"')}"
作者: ${metadata.author}
分类: ${metadata.category || '未分类'}
tags:
${tagsYaml}
保存时间: ${timeStr}
评论数: ${comments.length}
---

`;
      }

      // 添加标题和正文
      markdown += `# ${metadata.title}

`;
      markdown += mainContent;

      // 添加评论区
      if (config.saveComments && comments.length > 0) {
        markdown += '

---

';
        markdown += `## 评论区（共${comments.length}条）

`;

        for (const comment of comments) {
          let commentContent = td.turndown(comment.contentHTML);
          commentContent = cleanupMarkdown(commentContent);
          commentContent = commentContent.trim();

          // 用户名超链接
          const usernameDisplay = comment.userUrl
            ? `[${comment.username}](${comment.userUrl})`
            : comment.username;
          const usernameDisplayHtml = comment.userUrl
            ? `<a href="${comment.userUrl}"><b>${comment.username}</b></a>`
            : `<b>${comment.username}</b>`;

          if (config.foldComments) {
            // 折叠模式：转换Markdown为HTML
            let htmlContent = commentContent.trim();
            htmlContent = htmlContent.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
            htmlContent = htmlContent.replace(/~~(.+?)~~/g, '<del>$1</del>');
            htmlContent = htmlContent.replace(/`([^`]+)`/g, '<code>$1</code>');

            // 保护图片，转换链接
            const imgPlaceholders = [];
            htmlContent = htmlContent.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match) => {
              imgPlaceholders.push(match);
              return `__IMG_PLACEHOLDER_${imgPlaceholders.length - 1}__`;
            });
            htmlContent = htmlContent.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
            imgPlaceholders.forEach((img, i) => {
              htmlContent = htmlContent.replace(`__IMG_PLACEHOLDER_${i}__`, img);
            });

            markdown += `<details>
<summary><b>${comment.position}楼 - ${usernameDisplayHtml}</b></summary>

`;
            markdown += htmlContent;
            markdown += '

</details>

';
          } else {
            markdown += `### ${comment.position}楼 - ${usernameDisplay}

`;
            markdown += commentContent;
            markdown += '

';
          }
        }
      }

      return markdown;
    }

    return {
      initTurndown,
      cleanupMarkdown,
      convertToMarkdownWithComments
    };
  })();

  // ============================================================
  // 模块5: 保存功能 (SaveModule)
  // ============================================================
  const SaveModule = (function() {
    const NOTION_API_VERSION = '2022-06-28';

    // 通用：提取内容和评论
    async function extractData(config, targetPostNumber = null) {
      const extracted = ExtractModule.extractContent();
      if (!extracted) {
        throw new Error('无法提取帖子内容');
      }

      const { title, contentHTML, url, author, topicId, category, tags } = extracted;
      let comments = [];
      let isSingleCommentMode = targetPostNumber && targetPostNumber !== '1';

      if (isSingleCommentMode) {
        UtilModule.showNotification(`正在提取第${targetPostNumber}楼评论...`, 'info');
        const singleComment = ExtractModule.extractSingleComment(targetPostNumber);
        if (singleComment) {
          comments = [singleComment];
        } else {
          throw new Error(`未找到第${targetPostNumber}楼评论`);
        }
      } else if (config.saveComments) {
        let effectiveCommentCount = config.commentCount;
        let effectiveSaveAll = config.saveAllComments;

        if (config.useFloorRange) {
          effectiveCommentCount = config.floorTo || 100;
        }

        const useAPI = effectiveSaveAll || effectiveCommentCount > 30;

        if (useAPI && topicId) {
          UtilModule.showNotification('正在通过API加载评论...', 'info');
          try {
            comments = await ExtractModule.extractCommentsViaAPI(
              topicId,
              effectiveCommentCount,
              effectiveSaveAll,
              (msg) => UtilModule.showNotification(msg, 'info')
            );
          } catch (apiError) {
            console.warn('[Discourse Saver] API获取失败，回退到DOM方式:', apiError);
            comments = ExtractModule.extractComments(effectiveCommentCount);
          }
        } else {
          UtilModule.showNotification('正在提取评论...', 'info');
          comments = ExtractModule.extractComments(effectiveCommentCount);
        }
      }

      // 楼层范围过滤
      if (config.useFloorRange && comments.length > 0) {
        const floorFrom = config.floorFrom || 1;
        const floorTo = config.floorTo || 100;
        comments = comments.filter(c => {
          const pos = parseInt(c.position);
          return pos >= floorFrom && pos <= floorTo;
        });
      }

      return {
        title, contentHTML, url, author, topicId, category, tags,
        comments, isSingleCommentMode
      };
    }

    // 下载 Markdown 文件（备选方案：当剪贴板模式失败时使用）
    function downloadMarkdownFile(markdown, fileName, folderPath) {
      const blob = new Blob([markdown], { type: 'text/markdown;charset=utf-8' });
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = `${fileName}.md`;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);

      // 提示用户
      const vaultPath = folderPath || 'Discourse收集箱';
      UtilModule.showNotification(`文件已下载，请手动放入 Obsidian: ${vaultPath}/`, 'info');
      console.log(`[Discourse Saver] 备选方案：已下载为文件: ${fileName}.md`);
      console.log(`[Discourse Saver] 请将文件移动到 Obsidian vault 的 "${vaultPath}" 文件夹`);
    }

    // 存储最后一次大文件保存的信息（用于备选下载）
    let lastLargeFileSave = null;

    // 保存到 Obsidian
    async function sendToObsidian(markdown, fileName, config) {
      const vaultName = config.vaultName;
      const folderPath = config.folderPath || 'Discourse收集箱';
      const encode = (str) => encodeURIComponent(str);

      // 计算 URL 编码后的内容长度
      const encodedLength = encode(markdown).length;
      // URL 长度限制约 2MB，但浏览器实际限制更低，设置 50KB 阈值使用剪贴板模式
      const URL_LENGTH_THRESHOLD = 50000;
      const useClipboard = encodedLength > URL_LENGTH_THRESHOLD;

      let obsidianUrl;
      if (config.useAdvancedUri) {
        const parts = [];
        if (vaultName) parts.push(`vault=${encode(vaultName)}`);
        parts.push(`filepath=${encode(`${folderPath}/${fileName}.md`)}`);

        if (useClipboard) {
          // 内容过大，使用剪贴板模式
          GM_setClipboard(markdown, 'text');
          parts.push(`clipboard=true`);
          parts.push(`mode=overwrite`);
          console.log(`[Discourse Saver] 内容过大 (${Math.round(encodedLength/1024)}KB)，使用剪贴板模式`);

          // 保存信息用于备选下载
          lastLargeFileSave = { markdown, fileName, folderPath };

          // 显示提示
          UtilModule.showNotification('内容已复制到剪贴板，正在打开 Obsidian...', 'info');
        } else {
          parts.push(`data=${encode(markdown)}`);
          parts.push(`mode=overwrite`);
        }
        obsidianUrl = `obsidian://advanced-uri?${parts.join('&')}`;
      } else {
        // 普通 URI 模式
        const parts = [];
        if (vaultName) parts.push(`vault=${encode(vaultName)}`);
        parts.push(`file=${encode(`${folderPath}/${fileName}`)}`);

        if (useClipboard) {
          // 普通模式也尝试使用剪贴板
          GM_setClipboard(markdown, 'text');
          parts.push(`content=${encode('<!-- 内容已复制到剪贴板，请按 Ctrl+V / Cmd+V 粘贴 -->')}`);
          parts.push(`overwrite=true`);

          // 保存信息用于备选下载
          lastLargeFileSave = { markdown, fileName, folderPath };

          UtilModule.showNotification('内容已复制到剪贴板，Obsidian 打开后请手动粘贴', 'info');
        } else {
          parts.push(`content=${encode(markdown)}`);
          parts.push(`overwrite=true`);
        }
        obsidianUrl = `obsidian://new?${parts.join('&')}`;
      }

      window.open(obsidianUrl, '_self');
      return true;
    }

    // 备选方案：下载上次大文件（供油猴菜单调用）
    function downloadLastLargeFile() {
      if (lastLargeFileSave) {
        downloadMarkdownFile(
          lastLargeFileSave.markdown,
          lastLargeFileSave.fileName,
          lastLargeFileSave.folderPath
        );
      } else {
        UtilModule.showNotification('没有待下载的大文件', 'warning');
      }
    }

    // 保存为 HTML 文件下载
    function downloadAsHtml(markdown, metadata, fileName, config) {
      const htmlContent = generateHtmlContent(markdown, metadata);
      const folder = config.htmlExportFolder || 'Discourse导出';
      const fullFileName = `${folder}/${fileName}.html`;

      // 创建 Blob 并下载
      const blob = new Blob([htmlContent], { type: 'text/html;charset=utf-8' });
      const url = URL.createObjectURL(blob);
      const a = document.createElement('a');
      a.href = url;
      a.download = `${fileName}.html`;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      URL.revokeObjectURL(url);

      return true;
    }

    // 生成 HTML 内容
    function generateHtmlContent(markdown, metadata) {
      // 简单的 Markdown 转 HTML（基础转换）
      let htmlBody = markdown
        .replace(/^### (.+)$/gm, '<h3>$1</h3>')
        .replace(/^## (.+)$/gm, '<h2>$1</h2>')
        .replace(/^# (.+)$/gm, '<h1>$1</h1>')
        .replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>')
        .replace(/\*(.+?)\*/g, '<em>$1</em>')
        .replace(/`([^`]+)`/g, '<code>$1</code>')
        .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1" style="max-width:100%;">')
        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank">$1</a>')
        .replace(/^---$/gm, '<hr>')
        .replace(/

/g, '</p><p>')
        .replace(/
/g, '<br>');

      // 处理代码块
      htmlBody = htmlBody.replace(/```(\w*)
([\s\S]*?)```/g, (match, lang, code) => {
        return `<pre><code class="language-${lang}">${code.replace(/</g, '&lt;').replace(/>/g, '&gt;')}</code></pre>`;
      });

      return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>${metadata.title}</title>
  <style>
    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; line-height: 1.6; }
    h1 { color: #1f2937; border-bottom: 2px solid #e5e7eb; padding-bottom: 10px; }
    h2, h3 { color: #374151; margin-top: 24px; }
    a { color: #3b82f6; }
    code { background: #f3f4f6; padding: 2px 6px; border-radius: 4px; font-family: monospace; }
    pre { background: #1f2937; color: #e5e7eb; padding: 16px; border-radius: 8px; overflow-x: auto; }
    pre code { background: none; padding: 0; }
    img { border-radius: 8px; margin: 10px 0; }
    hr { border: none; border-top: 1px solid #e5e7eb; margin: 20px 0; }
    .metadata { background: #f9fafb; padding: 15px; border-radius: 8px; margin-bottom: 20px; font-size: 14px; color: #6b7280; }
    details { margin: 10px 0; padding: 10px; background: #f9fafb; border-radius: 8px; }
    summary { cursor: pointer; font-weight: 600; }
  </style>
</head>
<body>
  <div class="metadata">
    <p><strong>来源:</strong> <a href="${metadata.url}" target="_blank">${metadata.url}</a></p>
    <p><strong>作者:</strong> ${metadata.author} | <strong>分类:</strong> ${metadata.category || '未分类'}</p>
    <p><strong>保存时间:</strong> ${UtilModule.getBeijingTime()}</p>
  </div>
  <article>
    <p>${htmlBody}</p>
  </article>
</body>
</html>`;
    }

    // 保存到 Notion（使用 GM_xmlhttpRequest 解决 CORS）
    async function saveToNotion(markdown, metadata, config) {
      const token = config.notionToken;
      const databaseId = config.notionDatabaseId.replace(/-/g, '');

      if (!token || !databaseId) {
        throw new Error('请先配置 Notion Token 和 Database ID');
      }

      // 构建 Notion 页面属性
      const properties = {};

      // 标题（必需）
      properties[config.notionPropTitle || '标题'] = {
        title: [{ text: { content: metadata.title.substring(0, 2000) } }]
      };

      // URL
      if (config.notionPropUrl) {
        properties[config.notionPropUrl] = { url: metadata.url };
      }

      // 作者
      if (config.notionPropAuthor) {
        properties[config.notionPropAuthor] = {
          rich_text: [{ text: { content: metadata.author || '未知' } }]
        };
      }

      // 分类
      if (config.notionPropCategory && metadata.category) {
        properties[config.notionPropCategory] = {
          select: { name: metadata.category }
        };
      }

      // 标签
      if (config.notionPropTags && metadata.tags && metadata.tags.length > 0) {
        properties[config.notionPropTags] = {
          multi_select: metadata.tags.slice(0, 10).map(tag => ({ name: tag.substring(0, 100) }))
        };
      }

      // 保存日期
      if (config.notionPropSavedDate) {
        properties[config.notionPropSavedDate] = {
          date: { start: new Date().toISOString().split('T')[0] }
        };
      }

      // 评论数
      if (config.notionPropCommentCount) {
        properties[config.notionPropCommentCount] = {
          number: metadata.commentCount || 0
        };
      }

      // 将 Markdown 转换为 Notion blocks
      const children = markdownToNotionBlocks(markdown);

      // 创建页面
      return new Promise((resolve, reject) => {
        GM_xmlhttpRequest({
          method: 'POST',
          url: 'https://api.notion.com/v1/pages',
          headers: {
            'Authorization': `Bearer ${token}`,
            'Notion-Version': NOTION_API_VERSION,
            'Content-Type': 'application/json'
          },
          data: JSON.stringify({
            parent: { database_id: databaseId },
            properties: properties,
            children: children.slice(0, 100) // Notion 限制首次最多100个块
          }),
          onload: function(response) {
            if (response.status >= 200 && response.status < 300) {
              const data = JSON.parse(response.responseText);
              console.log('[Discourse Saver] Notion 保存成功:', data.id);
              resolve(data);
            } else {
              const error = JSON.parse(response.responseText);
              console.error('[Discourse Saver] Notion 错误:', error);
              reject(new Error(error.message || 'Notion API 错误'));
            }
          },
          onerror: function(error) {
            reject(new Error('网络请求失败'));
          }
        });
      });
    }

    // Markdown 转 Notion Blocks（简化版）
    function markdownToNotionBlocks(markdown) {
      const blocks = [];
      const lines = markdown.split('
');
      let i = 0;

      while (i < lines.length) {
        const line = lines[i];

        // 跳过 YAML frontmatter
        if (line === '---' && i === 0) {
          i++;
          while (i < lines.length && lines[i] !== '---') i++;
          i++;
          continue;
        }

        // 标题
        if (line.startsWith('# ')) {
          blocks.push({
            type: 'heading_1',
            heading_1: { rich_text: [{ text: { content: line.substring(2) } }] }
          });
        } else if (line.startsWith('## ')) {
          blocks.push({
            type: 'heading_2',
            heading_2: { rich_text: [{ text: { content: line.substring(3) } }] }
          });
        } else if (line.startsWith('### ')) {
          blocks.push({
            type: 'heading_3',
            heading_3: { rich_text: [{ text: { content: line.substring(4) } }] }
          });
        }
        // 代码块
        else if (line.startsWith('```')) {
          const lang = line.substring(3).trim() || 'plain text';
          let code = '';
          i++;
          while (i < lines.length && !lines[i].startsWith('```')) {
            code += lines[i] + '
';
            i++;
          }
          blocks.push({
            type: 'code',
            code: {
              language: lang,
              rich_text: [{ text: { content: code.trimEnd().substring(0, 2000) } }]
            }
          });
        }
        // 分割线
        else if (line === '---' || line === '***') {
          blocks.push({ type: 'divider', divider: {} });
        }
        // 图片
        else if (line.match(/^!\[.*\]\(.+\)$/)) {
          const match = line.match(/^!\[([^\]]*)\]\(([^)]+)\)$/);
          if (match) {
            blocks.push({
              type: 'image',
              image: { type: 'external', external: { url: match[2] } }
            });
          }
        }
        // 普通段落
        else if (line.trim()) {
          blocks.push({
            type: 'paragraph',
            paragraph: { rich_text: [{ text: { content: line.substring(0, 2000) } }] }
          });
        }

        i++;
      }

      return blocks;
    }

    // 测试 Notion 连接（支持两种调用方式）
    async function testNotionConnection(tokenOrConfig, dbId = null) {
      let token, databaseId;

      // 支持两种调用方式：testNotionConnection(config) 或 testNotionConnection(token, dbId)
      if (typeof tokenOrConfig === 'object') {
        token = tokenOrConfig.notionToken;
        databaseId = tokenOrConfig.notionDatabaseId;
      } else {
        token = tokenOrConfig;
        databaseId = dbId;
      }

      databaseId = databaseId.replace(/-/g, '');

      return new Promise((resolve, reject) => {
        GM_xmlhttpRequest({
          method: 'GET',
          url: `https://api.notion.com/v1/databases/${databaseId}`,
          headers: {
            'Authorization': `Bearer ${token}`,
            'Notion-Version': NOTION_API_VERSION
          },
          onload: function(response) {
            if (response.status >= 200 && response.status < 300) {
              const data = JSON.parse(response.responseText);
              resolve({ success: true, title: data.title?.[0]?.plain_text || 'Database' });
            } else {
              const error = JSON.parse(response.responseText);
              reject(new Error(error.message || 'Connection failed'));
            }
          },
          onerror: function() {
            reject(new Error('网络请求失败'));
          }
        });
      });
    }

    // 准备保存数据（公共函数）
    async function prepareData(targetPostNumber = null) {
      const config = ConfigModule.get();
      const data = await extractData(config, targetPostNumber);
      const { title, contentHTML, url, author, topicId, category, tags, comments, isSingleCommentMode } = data;

      const effectiveConfig = isSingleCommentMode
        ? { ...config, saveComments: true, foldComments: false }
        : config;

      let markdown = ConvertModule.convertToMarkdownWithComments(
        contentHTML,
        { title, url, author, topicId, category, tags },
        comments,
        effectiveConfig
      );

      // 如果启用了图片嵌入，将图片转换为 Base64
      if (config.embedImages) {
        try {
          UtilModule.showNotification('正在嵌入图片（可能需要一些时间）...', 'info');
          const originalMarkdown = markdown;  // 保存原始内容以防出错
          markdown = await UtilModule.embedImagesInMarkdown(markdown, (completed, total) => {
            UtilModule.showNotification(`正在嵌入图片 ${completed}/${total}...`, 'info');
          });
          // 检查结果是否有效
          if (!markdown || markdown.length === 0) {
            console.warn('[Discourse Saver] 图片嵌入返回空结果，使用原始内容');
            markdown = originalMarkdown;
          }
        } catch (embedError) {
          console.error('[Discourse Saver] 图片嵌入失败，使用原始内容:', embedError);
          UtilModule.showNotification('图片嵌入失败，将使用原始图片链接', 'warning');
          // markdown 保持原值，不影响后续保存
        }
      }

      let fileName = UtilModule.sanitizeFileName(title);
      if (isSingleCommentMode) {
        fileName += `_${targetPostNumber}楼`;
      }

      const metadata = { title, url, author, category, tags, commentCount: comments.length };

      return { markdown, fileName, metadata, comments, config };
    }

    // 独立导出：仅保存到 Obsidian
    async function saveToObsidianOnly(targetPostNumber = null) {
      try {
        UtilModule.showNotification('正在准备保存到 Obsidian...', 'info');
        const { markdown, fileName, comments, config } = await prepareData(targetPostNumber);
        await sendToObsidian(markdown, fileName, config);
        const commentInfo = comments.length > 0 ? `（含${comments.length}条评论）` : '';
        UtilModule.showNotification(`已保存到 Obsidian${commentInfo}`, 'success');
        return { success: true, target: 'Obsidian' };
      } catch (error) {
        console.error('[Discourse Saver] Obsidian 保存失败:', error);
        UtilModule.showNotification('Obsidian 保存失败: ' + error.message, 'error');
        return { success: false, target: 'Obsidian', error: error.message };
      }
    }

    // 独立导出：仅保存到 Notion
    async function saveToNotionOnly(targetPostNumber = null) {
      try {
        const config = ConfigModule.get();
        if (!config.notionToken || !config.notionDatabaseId) {
          throw new Error('请先配置 Notion Token 和 Database ID');
        }

        UtilModule.showNotification('正在准备保存到 Notion...', 'info');
        const { markdown, metadata, comments } = await prepareData(targetPostNumber);
        await saveToNotion(markdown, metadata, config);
        const commentInfo = comments.length > 0 ? `（含${comments.length}条评论）` : '';
        UtilModule.showNotification(`已保存到 Notion${commentInfo}`, 'success');
        return { success: true, target: 'Notion' };
      } catch (error) {
        console.error('[Discourse Saver] Notion 保存失败:', error);
        UtilModule.showNotification('Notion 保存失败: ' + error.message, 'error');
        return { success: false, target: 'Notion', error: error.message };
      }
    }

    // 独立导出：仅导出为 HTML
    async function exportHtmlOnly(targetPostNumber = null) {
      try {
        UtilModule.showNotification('正在准备导出 HTML...', 'info');
        const { markdown, fileName, metadata, comments, config } = await prepareData(targetPostNumber);
        downloadAsHtml(markdown, metadata, fileName, config);
        const commentInfo = comments.length > 0 ? `（含${comments.length}条评论）` : '';
        UtilModule.showNotification(`已导出 HTML${commentInfo}`, 'success');
        return { success: true, target: 'HTML' };
      } catch (error) {
        console.error('[Discourse Saver] HTML 导出失败:', error);
        UtilModule.showNotification('HTML 导出失败: ' + error.message, 'error');
        return { success: false, target: 'HTML', error: error.message };
      }
    }

    // 主保存函数（并行处理所有选中的目标，Obsidian 最后执行）
    async function save(targetPostNumber = null) {
      try {
        const config = ConfigModule.get();
        console.log('[Discourse Saver] 配置:', config);

        // 检查是否至少选择了一个保存目标
        if (!config.saveToObsidian && !config.saveToNotion && !config.exportHtml) {
          UtilModule.showNotification('请在设置中至少选择一个保存目标', 'warning');
          return;
        }

        // 提取数据（只提取一次）
        UtilModule.showNotification('正在提取内容...', 'info');
        const { markdown, fileName, metadata, comments } = await prepareData(targetPostNumber);

        // 构建任务列表（Obsidian 单独处理，因为会跳转页面）
        const tasks = [];
        const taskNames = [];
        let shouldSaveToObsidian = false;

        // Notion 和 HTML 先执行（不会跳转页面）
        if (config.saveToNotion && config.notionToken && config.notionDatabaseId) {
          tasks.push(
            saveToNotion(markdown, metadata, config)
              .then(() => ({ success: true, target: 'Notion' }))
              .catch(e => ({ success: false, target: 'Notion', error: e.message }))
          );
          taskNames.push('Notion');
        }

        if (config.exportHtml) {
          tasks.push(
            Promise.resolve()
              .then(() => {
                downloadAsHtml(markdown, metadata, fileName, config);
                return { success: true, target: 'HTML' };
              })
              .catch(e => ({ success: false, target: 'HTML', error: e.message }))
          );
          taskNames.push('HTML');
        }

        // 记录是否需要保存到 Obsidian（最后执行）
        if (config.saveToObsidian) {
          shouldSaveToObsidian = true;
          taskNames.push('Obsidian');
        }

        if (taskNames.length === 0) {
          UtilModule.showNotification('没有可执行的保存任务', 'warning');
          return;
        }

        // 显示正在保存
        UtilModule.showNotification(`正在保存到 ${taskNames.join('、')}...`, 'info');

        // 先并行执行 Notion 和 HTML 任务
        let results = [];
        if (tasks.length > 0) {
          results = await Promise.allSettled(tasks);
        }

        // 统计结果
        const succeeded = [];
        const failed = [];

        results.forEach((result, index) => {
          if (result.status === 'fulfilled' && result.value.success) {
            succeeded.push(result.value.target);
          } else {
            // 注意：taskNames 不包含 Obsidian（如果有的话），所以 index 对应的是非 Obsidian 任务
            const nonObsidianTaskNames = taskNames.filter(t => t !== 'Obsidian');
            const target = result.status === 'fulfilled' ? result.value.target : nonObsidianTaskNames[index];
            const error = result.status === 'fulfilled' ? result.value.error : result.reason?.message;
            failed.push({ target, error });
            console.error(`[Discourse Saver] ${target} 保存失败:`, error);
          }
        });

        // 显示中间结果（如果有非 Obsidian 任务完成）
        const commentInfo = comments.length > 0 ? `（含${comments.length}条评论）` : '';

        if (succeeded.length > 0 && !shouldSaveToObsidian) {
          if (failed.length === 0) {
            UtilModule.showNotification(`已保存到 ${succeeded.join('、')}${commentInfo}`, 'success');
          } else {
            UtilModule.showNotification(
              `已保存到 ${succeeded.join('、')}${commentInfo}，${failed.map(f => f.target).join('、')} 失败`,
              'warning'
            );
          }
        } else if (failed.length > 0 && !shouldSaveToObsidian) {
          UtilModule.showNotification(`${failed.map(f => f.target).join('、')} 保存失败`, 'error');
        }

        // 最后执行 Obsidian 保存（会跳转页面）
        if (shouldSaveToObsidian) {
          // 给其他任务一个短暂的时间确保完成
          await new Promise(resolve => setTimeout(resolve, 300));

          try {
            // 显示即将跳转提示
            if (succeeded.length > 0 || failed.length > 0) {
              const msg = succeeded.length > 0
                ? `${succeeded.join('、')} 已完成，正在跳转到 Obsidian...`
                : `正在跳转到 Obsidian...`;
              UtilModule.showNotification(msg, 'info');
              await new Promise(resolve => setTimeout(resolve, 500));
            }

            await sendToObsidian(markdown, fileName, config);
            succeeded.push('Obsidian');
          } catch (e) {
            failed.push({ target: 'Obsidian', error: e.message });
            console.error('[Discourse Saver] Obsidian 保存失败:', e);
          }
        }

        return { succeeded, failed };

      } catch (error) {
        console.error('[Discourse Saver] 保存失败:', error);
        UtilModule.showNotification('保存失败: ' + error.message, 'error');
        return { succeeded: [], failed: [{ target: 'all', error: error.message }] };
      }
    }

    // 导出所有函数
    return {
      save,                    // 根据配置保存（并行）
      saveToObsidianOnly,      // 仅保存到 Obsidian
      saveToNotionOnly,        // 仅保存到 Notion
      exportHtmlOnly,          // 仅导出 HTML
      testNotionConnection,    // 测试 Notion 连接
      downloadLastLargeFile    // 备选：下载大文件
    };
  })();

  // ============================================================
  // 模块6: 用户界面 (UIModule)
  // ============================================================
  const UIModule = (function() {
    let linkClickCount = 0;
    let linkClickTimer = null;
    let lastLinkPostNumber = null;

    // 注入样式
    function injectStyles() {
      GM_addStyle(`
        @keyframes dsSlideIn {
          from { transform: translateX(100%); opacity: 0; }
          to { transform: translateX(0); opacity: 1; }
        }

        .ds-settings-overlay {
          position: fixed;
          top: 0;
          left: 0;
          width: 100%;
          height: 100%;
          background: rgba(0,0,0,0.5);
          z-index: 999998;
          display: flex;
          align-items: center;
          justify-content: center;
        }

        .ds-settings-panel {
          background: white;
          border-radius: 12px;
          padding: 24px;
          width: 480px;
          max-height: 80vh;
          overflow-y: auto;
          box-shadow: 0 20px 60px rgba(0,0,0,0.3);
        }

        .ds-settings-panel h2 {
          margin: 0 0 20px 0;
          font-size: 20px;
          color: #1f2937;
          border-bottom: 2px solid #e5e7eb;
          padding-bottom: 12px;
        }

        .ds-form-group {
          margin-bottom: 16px;
        }

        .ds-form-group label {
          display: block;
          margin-bottom: 6px;
          font-weight: 500;
          color: #374151;
          font-size: 14px;
        }

        .ds-form-group input[type="text"],
        .ds-form-group input[type="number"] {
          width: 100%;
          padding: 10px 12px;
          border: 1px solid #d1d5db;
          border-radius: 6px;
          font-size: 14px;
          box-sizing: border-box;
        }

        .ds-form-group input:focus {
          outline: none;
          border-color: #3b82f6;
          box-shadow: 0 0 0 3px rgba(59,130,246,0.1);
        }

        .ds-checkbox-group {
          display: flex;
          align-items: center;
          gap: 8px;
        }

        .ds-checkbox-group input[type="checkbox"] {
          width: 18px;
          height: 18px;
          cursor: pointer;
        }

        .ds-checkbox-group label {
          margin: 0;
          cursor: pointer;
        }

        .ds-btn-group {
          display: flex;
          gap: 12px;
          margin-top: 24px;
          padding-top: 16px;
          border-top: 1px solid #e5e7eb;
        }

        .ds-btn {
          flex: 1;
          padding: 12px 20px;
          border: none;
          border-radius: 8px;
          font-size: 14px;
          font-weight: 500;
          cursor: pointer;
          transition: all 0.2s;
        }

        .ds-btn-primary {
          background: #3b82f6;
          color: white;
        }

        .ds-btn-primary:hover {
          background: #2563eb;
        }

        .ds-btn-secondary {
          background: #f3f4f6;
          color: #374151;
        }

        .ds-btn-secondary:hover {
          background: #e5e7eb;
        }

        .ds-section-title {
          font-size: 14px;
          font-weight: 600;
          color: #6b7280;
          margin: 20px 0 12px 0;
          text-transform: uppercase;
          letter-spacing: 0.5px;
        }

        .ds-hint {
          font-size: 12px;
          color: #9ca3af;
          margin-top: 4px;
        }
      `);
    }

    // 判断是否为链接按钮
    function isLinkButton(element) {
      if (!element) return { isLink: false, postNumber: null };

      if (!ExtractModule.isTopicPage()) {
        return { isLink: false, postNumber: null };
      }

      const postContainer = element.closest('.topic-post, article[data-post-id]');
      if (!postContainer) {
        return { isLink: false, postNumber: null };
      }

      const controlsArea = element.closest('.post-controls, .post-menu-area, .actions, nav.post-controls');
      if (!controlsArea) {
        return { isLink: false, postNumber: null };
      }

      const className = element.className || '';
      const dataShareUrl = element.getAttribute('data-share-url');
      const title = element.title || '';
      const ariaLabel = element.getAttribute('aria-label') || '';

      const hasCopyLinkClass = className.includes('post-action-menu__copy-link') ||
                                className.includes('copy-link');
      const hasShareUrl = dataShareUrl !== null && dataShareUrl !== '';
      const hasShareClass = className.includes('share');
      const hasShareTitle = title.includes('将此帖子的链接复制到剪贴板') ||
                            title.includes('复制到剪贴板') ||
                            title.includes('链接') ||
                            title.toLowerCase().includes('copy a link') ||
                            title.toLowerCase().includes('copy') ||
                            title.toLowerCase().includes('share');
      const hasShareAria = ariaLabel.includes('链接') ||
                           ariaLabel.includes('复制') ||
                           ariaLabel.includes('分享') ||
                           ariaLabel.toLowerCase().includes('share') ||
                           ariaLabel.toLowerCase().includes('copy');

      const isLinkLike = hasCopyLinkClass || hasShareUrl || hasShareClass || hasShareTitle || hasShareAria;

      if (!isLinkLike) {
        return { isLink: false, postNumber: null };
      }

      const topicPost = element.closest('.topic-post');
      const postNumber = topicPost?.getAttribute('data-post-number') ||
                         postContainer.getAttribute('data-post-number') ||
                         postContainer.querySelector('[data-post-number]')?.getAttribute('data-post-number') ||
                         '1';

      return { isLink: true, postNumber: postNumber };
    }

    // 触发原生复制链接
    function triggerOriginalCopyLink(postNumber) {
      let linkUrl = window.location.href;
      linkUrl = linkUrl.replace(/#.*$/, '').replace(/\?.*$/, '');

      if (postNumber !== '1') {
        const match = linkUrl.match(/^(.*\/t\/[^/]+\/\d+)(\/\d+)?$/);
        if (match) {
          linkUrl = match[1] + '/' + postNumber;
        } else {
          linkUrl = linkUrl + '/' + postNumber;
        }
      }

      GM_setClipboard(linkUrl, 'text');

      if (postNumber === '1') {
        UtilModule.showNotification('已复制帖子链接', 'success');
      } else {
        UtilModule.showNotification(`已复制${postNumber}楼链接`, 'success');
      }
    }

    // 劫持链接按钮
    function hijackLinkButton() {
      document.addEventListener('click', (e) => {
        let target = e.target.closest('button');
        if (!target) {
          target = e.target.closest('a');
        }

        if (target?.hasAttribute('data-ds-bypass')) {
          return;
        }

        const linkResult = isLinkButton(target);

        if (target && linkResult.isLink) {
          e.preventDefault();
          e.stopPropagation();
          e.stopImmediatePropagation();

          const isSameButton = lastLinkPostNumber === linkResult.postNumber;

          if (isSameButton) {
            linkClickCount++;
          } else {
            if (linkClickTimer) {
              clearTimeout(linkClickTimer);
              linkClickTimer = null;
            }
            linkClickCount = 1;
          }

          lastLinkPostNumber = linkResult.postNumber;

          if (linkClickTimer) {
            clearTimeout(linkClickTimer);
          }

          if (linkClickCount === 2 && isSameButton) {
            // 双击：复制链接
            linkClickCount = 0;
            lastLinkPostNumber = null;
            triggerOriginalCopyLink(linkResult.postNumber);
          } else {
            // 等待判断
            const postNumber = linkResult.postNumber;
            linkClickTimer = setTimeout(() => {
              if (linkClickCount === 1) {
                // 单击：保存
                if (postNumber === '1') {
                  console.log('[Discourse Saver] 单击主帖链接按钮');
                  SaveModule.save(null);
                } else {
                  console.log('[Discourse Saver] 单击评论链接按钮，楼层:', postNumber);
                  SaveModule.save(postNumber);
                }
              }
              linkClickCount = 0;
              lastLinkPostNumber = null;
            }, 300);
          }

          return false;
        }
      }, true);

      console.log('[Discourse Saver] 链接按钮劫持已激活');
    }

    // 显示设置面板
    function showSettingsPanel() {
      const config = ConfigModule.get();

      const overlay = document.createElement('div');
      overlay.className = 'ds-settings-overlay';
      overlay.innerHTML = `
        <div class="ds-settings-panel">
          <h2>📝 Discourse Saver 设置 (V4.5.5)</h2>

          <div class="ds-section-title">保存目标</div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-save-obsidian" ${config.saveToObsidian ? 'checked' : ''}>
            <label for="ds-save-obsidian">保存到 Obsidian</label>
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-save-notion" ${config.saveToNotion ? 'checked' : ''}>
            <label for="ds-save-notion">保存到 Notion</label>
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-export-html" ${config.exportHtml ? 'checked' : ''}>
            <label for="ds-export-html">导出为 HTML 文件</label>
          </div>

          <div class="ds-section-title">Obsidian 设置</div>

          <div class="ds-form-group">
            <label>Vault 名称</label>
            <input type="text" id="ds-vault" value="${config.vaultName}" placeholder="你的Vault名称">
            <div class="ds-hint">留空则保存到默认Vault</div>
          </div>

          <div class="ds-form-group">
            <label>保存文件夹路径</label>
            <input type="text" id="ds-folder" value="${config.folderPath}" placeholder="Discourse收集箱">
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-metadata" ${config.addMetadata ? 'checked' : ''}>
            <label for="ds-metadata">添加元数据 (YAML frontmatter)</label>
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-advanced-uri" ${config.useAdvancedUri ? 'checked' : ''}>
            <label for="ds-advanced-uri">使用 Advanced URI 插件</label>
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-embed-images" ${config.embedImages ? 'checked' : ''}>
            <label for="ds-embed-images">嵌入图片 (Base64)</label>
            <div class="ds-hint" style="margin-left: 26px; margin-top: 2px;">解决手机端图片无法显示问题，会增加文件大小</div>
          </div>

          <div class="ds-section-title">Notion 设置</div>

          <div class="ds-form-group">
            <label>Notion API Token</label>
            <input type="text" id="ds-notion-token" value="${config.notionToken}" placeholder="secret_xxx...">
            <div class="ds-hint">从 Notion 集成页面获取</div>
          </div>

          <div class="ds-form-group">
            <label>Database ID</label>
            <input type="text" id="ds-notion-db" value="${config.notionDatabaseId}" placeholder="32位数据库ID">
          </div>

          <div class="ds-form-group" style="display: flex; gap: 8px;">
            <button class="ds-btn ds-btn-secondary" id="ds-test-notion" style="flex: none; padding: 8px 16px;">测试连接</button>
            <span id="ds-notion-status" style="line-height: 36px; color: #6b7280; font-size: 13px;"></span>
          </div>

          <div class="ds-section-title">HTML 导出设置</div>

          <div class="ds-form-group">
            <label>导出文件夹名</label>
            <input type="text" id="ds-html-folder" value="${config.htmlExportFolder}" placeholder="Discourse导出">
            <div class="ds-hint">下载的HTML文件将使用此前缀</div>
          </div>

          <div class="ds-section-title">评论设置</div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-comments" ${config.saveComments ? 'checked' : ''}>
            <label for="ds-comments">保存评论</label>
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-fold" ${config.foldComments ? 'checked' : ''}>
            <label for="ds-fold">折叠评论 (使用 details 标签)</label>
          </div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-all-comments" ${config.saveAllComments ? 'checked' : ''}>
            <label for="ds-all-comments">保存全部评论</label>
            <div class="ds-hint" style="margin-left: 26px; margin-top: 2px;">与"楼层范围"互斥</div>
          </div>

          <div class="ds-form-group">
            <label>评论数量上限</label>
            <input type="number" id="ds-comment-count" value="${config.commentCount}" min="1" max="9999">
            <div class="ds-hint">当不勾选"保存全部"时生效</div>
          </div>

          <div class="ds-section-title">楼层范围</div>

          <div class="ds-form-group ds-checkbox-group">
            <input type="checkbox" id="ds-floor-range" ${config.useFloorRange ? 'checked' : ''}>
            <label for="ds-floor-range">启用楼层范围过滤</label>
            <div class="ds-hint" style="margin-left: 26px; margin-top: 2px;">与"保存全部评论"互斥</div>
          </div>

          <div class="ds-form-group" style="display: flex; gap: 12px;">
            <div style="flex: 1;">
              <label>起始楼层</label>
              <input type="number" id="ds-floor-from" value="${config.floorFrom}" min="1">
            </div>
            <div style="flex: 1;">
              <label>结束楼层</label>
              <input type="number" id="ds-floor-to" value="${config.floorTo}" min="1">
            </div>
          </div>

          <div class="ds-btn-group">
            <button class="ds-btn ds-btn-secondary" id="ds-cancel">取消</button>
            <button class="ds-btn ds-btn-primary" id="ds-save">保存设置</button>
          </div>
        </div>
      `;

      document.body.appendChild(overlay);

      // 互斥逻辑：saveAllComments 和 useFloorRange
      const allCommentsCheckbox = overlay.querySelector('#ds-all-comments');
      const floorRangeCheckbox = overlay.querySelector('#ds-floor-range');

      allCommentsCheckbox.addEventListener('change', () => {
        if (allCommentsCheckbox.checked) {
          floorRangeCheckbox.checked = false;
        }
      });

      floorRangeCheckbox.addEventListener('change', () => {
        if (floorRangeCheckbox.checked) {
          allCommentsCheckbox.checked = false;
        }
      });

      // 测试Notion连接
      overlay.querySelector('#ds-test-notion').addEventListener('click', async () => {
        const token = overlay.querySelector('#ds-notion-token').value.trim();
        const dbId = overlay.querySelector('#ds-notion-db').value.trim();
        const statusEl = overlay.querySelector('#ds-notion-status');

        if (!token || !dbId) {
          statusEl.textContent = '请填写Token和Database ID';
          statusEl.style.color = '#ef4444';
          return;
        }

        statusEl.textContent = '测试中...';
        statusEl.style.color = '#6b7280';

        try {
          const result = await SaveModule.testNotionConnection(token, dbId);
          if (result.success) {
            statusEl.textContent = '连接成功!';
            statusEl.style.color = '#22c55e';
          } else {
            statusEl.textContent = '连接失败: ' + result.error;
            statusEl.style.color = '#ef4444';
          }
        } catch (e) {
          statusEl.textContent = '测试出错: ' + e.message;
          statusEl.style.color = '#ef4444';
        }
      });

      // 取消按钮
      overlay.querySelector('#ds-cancel').addEventListener('click', () => {
        overlay.remove();
      });

      // 保存按钮
      overlay.querySelector('#ds-save').addEventListener('click', () => {
        const newConfig = {
          // 保存目标
          saveToObsidian: overlay.querySelector('#ds-save-obsidian').checked,
          saveToNotion: overlay.querySelector('#ds-save-notion').checked,
          exportHtml: overlay.querySelector('#ds-export-html').checked,
          // Obsidian设置
          vaultName: overlay.querySelector('#ds-vault').value.trim(),
          folderPath: overlay.querySelector('#ds-folder').value.trim() || 'Discourse收集箱',
          addMetadata: overlay.querySelector('#ds-metadata').checked,
          useAdvancedUri: overlay.querySelector('#ds-advanced-uri').checked,
          embedImages: overlay.querySelector('#ds-embed-images').checked,
          // Notion设置
          notionToken: overlay.querySelector('#ds-notion-token').value.trim(),
          notionDatabaseId: overlay.querySelector('#ds-notion-db').value.trim(),
          // HTML设置
          htmlExportFolder: overlay.querySelector('#ds-html-folder').value.trim() || 'Discourse导出',
          // 评论设置
          saveComments: overlay.querySelector('#ds-comments').checked,
          foldComments: overlay.querySelector('#ds-fold').checked,
          saveAllComments: overlay.querySelector('#ds-all-comments').checked,
          commentCount: parseInt(overlay.querySelector('#ds-comment-count').value) || 100,
          // 楼层范围
          useFloorRange: overlay.querySelector('#ds-floor-range').checked,
          floorFrom: parseInt(overlay.querySelector('#ds-floor-from').value) || 1,
          floorTo: parseInt(overlay.querySelector('#ds-floor-to').value) || 100
        };

        ConfigModule.setAll(newConfig);
        overlay.remove();
        UtilModule.showNotification('设置已保存', 'success');
      });

      // 点击遮罩关闭
      overlay.addEventListener('click', (e) => {
        if (e.target === overlay) {
          overlay.remove();
        }
      });
    }

    // 初始化
    function init() {
      injectStyles();
      hijackLinkButton();

      // 注册油猴菜单
      GM_registerMenuCommand('⚙️ 设置', showSettingsPanel);
      GM_registerMenuCommand('📥 保存当前帖子（全部目标）', () => SaveModule.save(null));
      GM_registerMenuCommand('📝 仅保存到 Obsidian', () => SaveModule.saveToObsidianOnly(null));
      GM_registerMenuCommand('📑 仅保存到 Notion', () => SaveModule.saveToNotionOnly(null));
      GM_registerMenuCommand('📄 仅导出为 HTML', () => SaveModule.exportHtmlOnly(null));
      GM_registerMenuCommand('💾 下载大文件（备选）', () => SaveModule.downloadLastLargeFile());

      console.log('[Discourse Saver] 油猴脚本已加载 (V4.5.5)');
    }

    return { init, showSettingsPanel };
  })();

  // ============================================================
  // 启动脚本
  // ============================================================
  UIModule.init();

})();
更新日志 (V4.5.5)

恢复: 剪贴板模式 (clipboard=true) 作为大文件首选方案
新增: 备选下载菜单（剪贴板失败时可手动下载 .md 文件）
优化: 内容过大时自动复制到剪贴板并打开 Obsidian
保持: 单张图片 15MB、总大小 100MB、最多 50 张限制