${htmlContent}
`;
}
// 获取 Notion 数据库属性
async function getDatabaseProperties(token, databaseId) {
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(data.properties || {});
} else {
const error = JSON.parse(response.responseText);
reject(new Error(error.message || '获取数据库属性失败'));
}
},
onerror: function() {
reject(new Error('网络请求失败'));
}
});
});
}
// 查找匹配的属性名（支持模糊匹配）
function findMatchingProperty(dbProps, targetName, expectedType = null) {
if (!targetName) return null;
const normalizedTarget = targetName.toLowerCase().trim();
for (const [propName, propInfo] of Object.entries(dbProps)) {
const normalizedProp = propName.toLowerCase().trim();
// 精确匹配或模糊匹配
if (normalizedProp === normalizedTarget ||
propName === targetName ||
normalizedProp.includes(normalizedTarget) ||
normalizedTarget.includes(normalizedProp)) {
// 如果指定了类型，检查类型是否匹配
if (expectedType && propInfo.type !== expectedType) {
console.warn(`[Discourse Saver] 属性 "${propName}" 类型不匹配: 期望 ${expectedType}, 实际 ${propInfo.type}`);
continue;
}
return { name: propName, type: propInfo.type };
}
}
return null;
}
// 根据 URL 查找已存在的 Notion 页面（去重）
async function findExistingPageByUrl(token, databaseId, url, urlPropName) {
return new Promise((resolve, reject) => {
const filter = {
property: urlPropName,
url: { equals: url }
};
GM_xmlhttpRequest({
method: 'POST',
url: `https://api.notion.com/v1/databases/${databaseId}/query`,
headers: {
'Authorization': `Bearer ${token}`,
'Notion-Version': NOTION_API_VERSION,
'Content-Type': 'application/json'
},
data: JSON.stringify({ filter, page_size: 1 }),
onload: function(response) {
if (response.status >= 200 && response.status < 300) {
const data = JSON.parse(response.responseText);
if (data.results && data.results.length > 0) {
console.log(`[Discourse Saver] 找到已存在的页面: ${data.results[0].id}`);
resolve(data.results[0]);
} else {
resolve(null);
}
} else {
console.warn('[Discourse Saver] 查询已存在页面失败:', response.responseText);
resolve(null); // 查询失败时继续创建新页面
}
},
onerror: function() {
resolve(null); // 网络错误时继续创建新页面
}
});
});
}
// 归档（删除）已存在的 Notion 页面
async function archiveNotionPage(token, pageId) {
return new Promise((resolve) => {
GM_xmlhttpRequest({
method: 'PATCH',
url: `https://api.notion.com/v1/pages/${pageId}`,
headers: {
'Authorization': `Bearer ${token}`,
'Notion-Version': NOTION_API_VERSION,
'Content-Type': 'application/json'
},
data: JSON.stringify({ archived: true }),
onload: function(response) {
if (response.status >= 200 && response.status < 300) {
console.log('[Discourse Saver] 已归档旧页面:', pageId);
resolve(true);
} else {
console.warn('[Discourse Saver] 归档页面失败:', response.responseText);
resolve(false);
}
},
onerror: function() {
resolve(false);
}
});
});
}
// 保存到 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');
}
// 先获取数据库属性
console.log('[Discourse Saver] 正在获取数据库属性...');
let dbProps;
try {
dbProps = await getDatabaseProperties(token, databaseId);
console.log('[Discourse Saver] 数据库属性:', Object.keys(dbProps));
} catch (e) {
throw new Error('获取数据库属性失败: ' + e.message);
}
// 构建 Notion 页面属性（只使用数据库中存在的属性）
const properties = {};
// 标题（必需）- 查找 title 类型的属性
const titleProp = findMatchingProperty(dbProps, config.notionPropTitle || '标题', 'title') ||
findMatchingProperty(dbProps, 'Name', 'title') ||
findMatchingProperty(dbProps, '名称', 'title');
if (!titleProp) {
// 如果没找到，使用数据库中第一个 title 类型的属性
for (const [propName, propInfo] of Object.entries(dbProps)) {
if (propInfo.type === 'title') {
console.log(`[Discourse Saver] 使用 "${propName}" 作为标题属性`);
properties[propName] = {
title: [{ text: { content: metadata.title.substring(0, 2000) } }]
};
break;
}
}
if (Object.keys(properties).length === 0) {
throw new Error('数据库中没有找到标题属性（title 类型）');
}
} else {
console.log(`[Discourse Saver] 标题属性: "${titleProp.name}"`);
properties[titleProp.name] = {
title: [{ text: { content: metadata.title.substring(0, 2000) } }]
};
}
// URL - 查找 url 类型的属性
const urlProp = findMatchingProperty(dbProps, config.notionPropUrl || '链接', 'url');
if (urlProp) {
console.log(`[Discourse Saver] URL属性: "${urlProp.name}"`);
properties[urlProp.name] = { url: metadata.url };
}
// 作者 - 查找 rich_text 类型的属性
const authorProp = findMatchingProperty(dbProps, config.notionPropAuthor || '作者', 'rich_text');
if (authorProp) {
console.log(`[Discourse Saver] 作者属性: "${authorProp.name}"`);
properties[authorProp.name] = {
rich_text: [{ text: { content: metadata.author || '未知' } }]
};
}
// 分类 - 支持多种类型（select、multi_select、rich_text）
console.log(`[Discourse Saver] metadata.category = "${metadata.category || '(空)'}"`);
// 先尝试 select 类型
let categoryProp = findMatchingProperty(dbProps, config.notionPropCategory || '分类', 'select');
// 再尝试 multi_select 类型
if (!categoryProp) {
categoryProp = findMatchingProperty(dbProps, config.notionPropCategory || '分类', 'multi_select');
}
// 再尝试 rich_text 类型
if (!categoryProp) {
categoryProp = findMatchingProperty(dbProps, config.notionPropCategory || '分类', 'rich_text');
}
// 最后不限类型查找
if (!categoryProp) {
categoryProp = findMatchingProperty(dbProps, config.notionPropCategory || '分类', null);
}
if (categoryProp && metadata.category && metadata.category.trim()) {
console.log(`[Discourse Saver] 分类属性: "${categoryProp.name}" (类型: ${categoryProp.type})`);
const categoryValue = metadata.category.trim();
// 根据属性类型设置值
switch (categoryProp.type) {
case 'select':
properties[categoryProp.name] = {
select: { name: categoryValue }
};
break;
case 'multi_select':
properties[categoryProp.name] = {
multi_select: [{ name: categoryValue }]
};
break;
case 'rich_text':
properties[categoryProp.name] = {
rich_text: [{ text: { content: categoryValue } }]
};
break;
default:
// 尝试作为 rich_text 处理
properties[categoryProp.name] = {
rich_text: [{ text: { content: categoryValue } }]
};
}
console.log(`[Discourse Saver] 分类值已设置: "${categoryValue}" (类型: ${categoryProp.type})`);
} else if (!categoryProp) {
console.log('[Discourse Saver] 未找到分类属性');
// 尝试查找任何包含"分类"的属性
for (const [propName, propInfo] of Object.entries(dbProps)) {
if (propName.includes('分类') || propName.toLowerCase().includes('category')) {
console.log(`[Discourse Saver] 发现可能的分类属性: "${propName}" (类型: ${propInfo.type})`);
}
}
} else {
console.log('[Discourse Saver] 分类为空，跳过设置');
}
// 标签 - 查找 multi_select 类型的属性
if (metadata.tags && metadata.tags.length > 0) {
const tagsProp = findMatchingProperty(dbProps, config.notionPropTags || '标签', 'multi_select');
if (tagsProp) {
console.log(`[Discourse Saver] 标签属性: "${tagsProp.name}"`);
properties[tagsProp.name] = {
multi_select: metadata.tags.slice(0, 10).map(tag => ({ name: tag.substring(0, 100) }))
};
}
}
// 保存日期 - 查找 date 类型的属性
const dateProp = findMatchingProperty(dbProps, config.notionPropSavedDate || '保存日期', 'date');
if (dateProp) {
console.log(`[Discourse Saver] 日期属性: "${dateProp.name}"`);
properties[dateProp.name] = {
date: { start: new Date().toISOString().split('T')[0] }
};
}
// 评论数 - 查找 number 类型的属性
const commentCountProp = findMatchingProperty(dbProps, config.notionPropCommentCount || '评论数', 'number');
if (commentCountProp) {
console.log(`[Discourse Saver] 评论数属性: "${commentCountProp.name}"`);
properties[commentCountProp.name] = {
number: metadata.commentCount || 0
};
}
console.log('[Discourse Saver] 最终属性:', Object.keys(properties));
// 将 Markdown 转换为 Notion blocks
const children = markdownToNotionBlocks(markdown);
// 去重检查：根据 URL 查找已存在的页面
let existingPage = null;
if (urlProp) {
console.log('[Discourse Saver] 检查是否已存在相同 URL 的页面...');
existingPage = await findExistingPageByUrl(token, databaseId, metadata.url, urlProp.name);
}
if (existingPage) {
// 归档已存在的页面，然后创建新页面
console.log('[Discourse Saver] 找到已存在的页面，正在归档后重新创建...');
await archiveNotionPage(token, existingPage.id);
}
// 创建新页面（先添加前100个块）
console.log(`[Discourse Saver] 总块数: ${children.length}`);
const pageData = await 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)
}),
onload: function(response) {
try {
if (response.status >= 200 && response.status < 300) {
const data = JSON.parse(response.responseText);
console.log('[Discourse Saver] Notion 页面创建成功:', data.id);
resolve(data);
} else {
let errorMessage = `HTTP ${response.status}`;
try {
const error = JSON.parse(response.responseText);
console.error('[Discourse Saver] Notion 错误:', error);
errorMessage = error.message || errorMessage;
// 打印失败的块信息便于调试
if (error.code === 'validation_error') {
console.error('[Discourse Saver] 验证错误，前3个块:', JSON.stringify(children.slice(0, 3), null, 2));
}
} catch (parseErr) {
console.error('[Discourse Saver] Notion 响应:', response.responseText);
}
console.error('[Discourse Saver] 请求数据:', { properties, childrenCount: children.length });
reject(new Error(errorMessage));
}
} catch (e) {
console.error('[Discourse Saver] 处理Notion响应失败:', e);
reject(new Error('处理Notion响应失败: ' + e.message));
}
},
onerror: function(error) {
console.error('[Discourse Saver] Notion 网络错误:', error);
reject(new Error('网络请求失败'));
}
});
});
// 如果有超过100个块，分批追加剩余的块
if (children.length > 100) {
const pageId = pageData.id;
const remainingChildren = children.slice(100);
const totalBatches = Math.ceil(remainingChildren.length / 100);
console.log(`[Discourse Saver] 需要追加 ${remainingChildren.length} 个块，分 ${totalBatches} 批`);
let successBatches = 0;
let failedBatches = 0;
// 每批最多100个块
for (let i = 0; i < remainingChildren.length; i += 100) {
const batchNum = Math.floor(i/100) + 1;
const batch = remainingChildren.slice(i, i + 100);
console.log(`[Discourse Saver] 追加第 ${batchNum}/${totalBatches} 批，${batch.length} 个块`);
// 重试机制
let retries = 3;
let success = false;
while (retries > 0 && !success) {
try {
await new Promise((resolve, reject) => {
GM_xmlhttpRequest({
method: 'PATCH',
url: `https://api.notion.com/v1/blocks/${pageId}/children`,
headers: {
'Authorization': `Bearer ${token}`,
'Notion-Version': NOTION_API_VERSION,
'Content-Type': 'application/json'
},
data: JSON.stringify({ children: batch }),
onload: function(response) {
if (response.status >= 200 && response.status < 300) {
success = true;
resolve();
} else if (response.status === 429) {
// API 限流，等待后重试
console.warn(`[Discourse Saver] 批次 ${batchNum} API 限流，等待重试...`);
reject(new Error('rate_limited'));
} else {
console.warn(`[Discourse Saver] 批次 ${batchNum} 失败 (${response.status}):`, response.responseText.substring(0, 500));
reject(new Error(`HTTP ${response.status}`));
}
},
onerror: function(error) {
console.warn(`[Discourse Saver] 批次 ${batchNum} 网络错误`);
reject(new Error('network_error'));
}
});
});
} catch (batchError) {
retries--;
if (retries > 0) {
// 等待后重试（限流情况等待更长时间）
const waitTime = batchError.message === 'rate_limited' ? 2000 : 500;
console.log(`[Discourse Saver] 批次 ${batchNum} 重试中... (剩余 ${retries} 次)`);
await new Promise(r => setTimeout(r, waitTime));
}
}
}
if (success) {
successBatches++;
} else {
failedBatches++;
console.error(`[Discourse Saver] 批次 ${batchNum} 最终失败，跳过`);
}
// 避免 API 限流，稍微延迟
if (i + 100 < remainingChildren.length) {
await new Promise(r => setTimeout(r, 400));
}
}
console.log(`[Discourse Saver] 块追加完成: 成功 ${successBatches}/${totalBatches} 批`);
if (failedBatches > 0) {
console.warn(`[Discourse Saver] ${failedBatches} 批追加失败，部分内容可能丢失`);
}
}
return pageData;
}
// Markdown 转 Notion Blocks（v4.6.0 增强版 - 支持更多内容类型）
function markdownToNotionBlocks(markdown) {
const blocks = [];
const lines = markdown.split('\n');
let i = 0;
// 辅助函数：检测URL类型
function getUrlType(url) {
// 视频链接（YouTube、Bilibili、Vimeo、优酷、腾讯视频）
if (/youtube\.com|youtu\.be|vimeo\.com|bilibili\.com|b23\.tv|v\.youku\.com|v\.qq\.com/i.test(url)) {
return 'video';
}
// 网盘链接
if (/pan\.baidu\.com|yun\.baidu\.com|pan\.quark\.cn|123pan\.com|lanzou[a-z]*\.(com|cn)|lanzoui\.com|lanzoux\.com|aliyundrive\.com|alipan\.com|cloud\.189\.cn/i.test(url)) {
return 'cloud';
}
// 音频链接
if (/\.mp3|\.wav|\.ogg|\.m4a|\.aac|soundcloud\.com|spotify\.com|music\./i.test(url)) {
return 'audio';
}
// 图片链接
if (/\.(jpg|jpeg|png|gif|webp|svg|bmp)(\?|$)/i.test(url)) {
return 'image';
}
// PDF 链接
if (/\.pdf(\?|$)/i.test(url)) {
return 'pdf';
}
return 'link';
}
// 辅助函数：获取网盘名称
function getCloudName(url) {
if (/pan\.baidu\.com|yun\.baidu\.com/i.test(url)) return '百度网盘';
if (/pan\.quark\.cn/i.test(url)) return '夸克网盘';
if (/123pan\.com/i.test(url)) return '123云盘';
if (/lanzou[a-z]*\.(com|cn)|lanzoui\.com|lanzoux\.com/i.test(url)) return '蓝奏云';
if (/aliyundrive\.com|alipan\.com/i.test(url)) return '阿里云盘';
if (/cloud\.189\.cn/i.test(url)) return '天翼云盘';
return '网盘';
}
// 辅助函数：验证并补全 URL
function normalizeUrl(url) {
if (!url) return null;
let normalized = url.trim();
// 如果是相对路径，补全为完整 URL
if (!normalized.startsWith('http://') && !normalized.startsWith('https://')) {
if (normalized.startsWith('/')) {
normalized = window.location.origin + normalized;
} else if (normalized.startsWith('#')) {
normalized = window.location.href.split('#')[0] + normalized;
} else if (!normalized.includes(':')) {
// 不是特殊协议（如 mailto:, tel:），添加 https://
normalized = 'https://' + normalized;
}
}
// 验证 URL 是否有效
try {
new URL(normalized);
return normalized;
} catch {
return null;
}
}
// 辅助函数：解析富文本（支持加粗、斜体、链接、代码）- 增强错误处理
function parseRichText(text) {
// 确保输入有效
if (!text || typeof text !== 'string') {
return [{ text: { content: ' ' } }];
}
const safeText = text.substring(0, 2000); // Notion 限制
const richText = [];
try {
// 检测链接 [text](url)
const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g;
let lastIndex = 0;
let match;
while ((match = linkRegex.exec(safeText)) !== null) {
// 添加链接前的文本
if (match.index > lastIndex) {
const before = safeText.substring(lastIndex, match.index);
if (before && before.trim()) {
const formatted = parseInlineFormatting(before);
if (formatted && formatted.length > 0) {
richText.push(...formatted);
}
}
}
// 处理链接
const linkText = match[1] || '链接';
const linkUrl = normalizeUrl(match[2]);
if (linkUrl) {
richText.push({
text: { content: linkText.substring(0, 2000), link: { url: linkUrl } }
});
} else {
// URL 无效，只显示文本
richText.push({
text: { content: linkText.substring(0, 2000) }
});
}
lastIndex = match.index + match[0].length;
}
// 添加剩余文本
if (lastIndex < safeText.length) {
const remaining = safeText.substring(lastIndex);
if (remaining && remaining.trim()) {
const formatted = parseInlineFormatting(remaining);
if (formatted && formatted.length > 0) {
richText.push(...formatted);
}
}
}
} catch (e) {
console.warn('[Discourse Saver] parseRichText 错误:', e.message);
return [{ text: { content: safeText || ' ' } }];
}
// 确保不返回空数组
if (richText.length === 0) {
return [{ text: { content: safeText || ' ' } }];
}
return richText;
}
// 辅助函数：解析内联格式（加粗、斜体、代码）- 修复顺序问题
function parseInlineFormatting(text) {
if (!text || text.trim() === '') {
return [{ text: { content: ' ' } }]; // Notion 不允许空 rich_text
}
const parts = [];
// 使用正则分割并保持顺序
const regex = /(\*\*[^*]+\*\*|\*[^*]+\*|`[^`]+`)/g;
let lastIndex = 0;
let match;
while ((match = regex.exec(text)) !== null) {
// 添加匹配前的普通文本
if (match.index > lastIndex) {
const before = text.substring(lastIndex, match.index);
if (before) {
parts.push({ text: { content: before.substring(0, 2000) } });
}
}
const matched = match[1];
// 加粗 **text**
if (matched.startsWith('**') && matched.endsWith('**')) {
const content = matched.slice(2, -2);
if (content) {
parts.push({ text: { content: content.substring(0, 2000) }, annotations: { bold: true } });
}
}
// 行内代码 `text`
else if (matched.startsWith('`') && matched.endsWith('`')) {
const content = matched.slice(1, -1);
if (content) {
parts.push({ text: { content: content.substring(0, 2000) }, annotations: { code: true } });
}
}
// 斜体 *text*
else if (matched.startsWith('*') && matched.endsWith('*')) {
const content = matched.slice(1, -1);
if (content) {
parts.push({ text: { content: content.substring(0, 2000) }, annotations: { italic: true } });
}
}
lastIndex = match.index + match[0].length;
}
// 添加剩余文本
if (lastIndex < text.length) {
const remaining = text.substring(lastIndex);
if (remaining) {
parts.push({ text: { content: remaining.substring(0, 2000) } });
}
}
// 确保不返回空数组
return parts.length > 0 ? parts : [{ text: { content: text.substring(0, 2000) || ' ' } }];
}
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: parseRichText(line.substring(2)) }
});
} else if (line.startsWith('## ')) {
blocks.push({
type: 'heading_2',
heading_2: { rich_text: parseRichText(line.substring(3)) }
});
} else if (line.startsWith('### ')) {
blocks.push({
type: 'heading_3',
heading_3: { rich_text: parseRichText(line.substring(4)) }
});
}
// 代码块
else if (line.startsWith('```')) {
// Notion 支持的语言映射
const notionLanguageMap = {
'plaintext': 'plain text',
'text': 'plain text',
'txt': 'plain text',
'sh': 'bash',
'shell': 'bash',
'zsh': 'bash',
'ps1': 'powershell',
'ps': 'powershell',
'yml': 'yaml',
'js': 'javascript',
'ts': 'typescript',
'py': 'python',
'rb': 'ruby',
'cs': 'c#',
'cpp': 'c++',
'objc': 'objective-c',
'kt': 'kotlin',
'rs': 'rust',
'md': 'markdown',
'htm': 'html',
'dockerfile': 'docker',
'make': 'makefile',
'asm': 'assembly',
'': 'plain text'
};
const rawLang = line.substring(3).trim().toLowerCase();
const lang = notionLanguageMap[rawLang] || rawLang || 'plain text';
let code = '';
i++;
while (i < lines.length && !lines[i].startsWith('```')) {
code += lines[i] + '\n';
i++;
}
blocks.push({
type: 'code',
code: {
language: lang,
rich_text: [{ text: { content: code.trimEnd().substring(0, 2000) } }]
}
});
}
// Obsidian callout / 折叠块
else if (line.startsWith('> [!')) {
const calloutMatch = line.match(/^> \[!([^\]]+)\]([+-])?\s*(.*)$/);
if (calloutMatch) {
const calloutType = calloutMatch[1];
const isCollapsed = calloutMatch[2] === '-';
const title = calloutMatch[3] || calloutType;
// 收集 callout 内容
let content = '';
i++;
while (i < lines.length && lines[i].startsWith('> ')) {
content += lines[i].substring(2) + '\n';
i++;
}
i--; // 回退一行
// 使用 callout 块
blocks.push({
type: 'callout',
callout: {
rich_text: [{ text: { content: title + '\n' + content.trim() } }],
icon: { type: 'emoji', emoji: calloutType === 'note' ? '📝' : calloutType === 'warning' ? '⚠️' : '💡' }
}
});
}
}
// HTML
`;
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-test-feishu').addEventListener('click', async () => {
const appId = overlay.querySelector('#ds-feishu-app-id').value.trim();
const appSecret = overlay.querySelector('#ds-feishu-app-secret').value.trim();
const domain = overlay.querySelector('#ds-feishu-domain').value;
const statusEl = overlay.querySelector('#ds-feishu-status');
if (!appId || !appSecret) {
statusEl.textContent = '请先填写 App ID 和 App Secret';
statusEl.style.color = '#ef4444';
return;
}
statusEl.textContent = '测试中...';
statusEl.style.color = '#6b7280';
try {
const result = await SaveModule.testFeishuConnection(appId, appSecret, domain);
if (result.success) {
statusEl.textContent = '连接成功，Token 已获取';
statusEl.style.color = '#22c55e';
} else {
statusEl.textContent = '连接失败: ' + result.error;
statusEl.style.color = '#ef4444';
}
} catch (e) {
statusEl.textContent = '测试出错: ' + e.message;
statusEl.style.color = '#ef4444';
}
});
// 下载图片 checkbox 显隐
overlay.querySelector('#ds-download-images').addEventListener('change', (e) => {
overlay.querySelector('#ds-download-images-panel').style.display = e.target.checked ? '' : 'none';
});
// 测试 REST API 连接
overlay.querySelector('#ds-test-rest-api').addEventListener('click', async () => {
const statusEl = overlay.querySelector('#ds-rest-api-status');
const apiKey = overlay.querySelector('#ds-rest-api-key').value.trim();
const apiPort = parseInt(overlay.querySelector('#ds-rest-api-port').value) || 27124;
statusEl.textContent = '正在测试...';
statusEl.style.color = '#6b7280';
try {
const result = await UtilModule.testRestApiConnection(apiKey, apiPort);
if (result.success) {
statusEl.textContent = '连接成功';
statusEl.style.color = '#10b981';
} else {
statusEl.textContent = result.message;
statusEl.style.color = '#ef4444';
}
} catch (e) {
statusEl.textContent = '测试失败: ' + e.message;
statusEl.style.color = '#ef4444';
}
});
// OB 测试按钮（使用 v4.3.8 验证过的剪贴板方式）
overlay.querySelector('#ds-test-ob').addEventListener('click', async () => {
const vaultName = overlay.querySelector('#ds-vault').value.trim();
const folderPath = overlay.querySelector('#ds-folder').value.trim() || 'Discourse收集箱';
const encode = (str) => encodeURIComponent(str);
console.log('[Discourse Saver] OB 测试: vault=' + vaultName + ', folder=' + folderPath);
// 测试内容
const testContent = '# Discourse Saver 测试\n\n如果你看到这个文件，说明连接成功！\n\n时间: ' + new Date().toISOString();
try {
// 步骤1：写入剪贴板（v4.3.8 方式）
if (navigator.clipboard && navigator.clipboard.writeText) {
await navigator.clipboard.writeText(testContent);
console.log('[Discourse Saver] 测试内容已写入剪贴板 (原生API)');
} else {
GM_setClipboard(testContent, 'text');
console.log('[Discourse Saver] 测试内容已写入剪贴板 (GM API)');
}
// 步骤2：构建 URI（始终用 clipboard=true）
const vaultParam = vaultName ? 'vault=' + encode(vaultName) + '&' : '';
const testUri = 'obsidian://advanced-uri?' + vaultParam +
'filepath=' + encode(folderPath + '/DS-测试文件.md') + '&' +
'clipboard=true&' +
'mode=overwrite';
console.log('[Discourse Saver] 测试 URI:', testUri);
alert('测试内容已复制到剪贴板。\n\n即将打开 Obsidian，如果成功会在 "' + folderPath + '" 文件夹中看到 "DS-测试文件.md"');
window.location.href = testUri;
} catch (e) {
console.error('[Discourse Saver] 测试失败:', e);
alert('测试失败: ' + e.message + '\n\n请确保浏览器允许剪贴板访问。');
}
});
// 取消按钮
overlay.querySelector('#ds-cancel').addEventListener('click', () => {
overlay.remove();
});
// 导出配置
overlay.querySelector('#ds-export-config').addEventListener('click', () => {
const cfg = ConfigModule.get();
const json = JSON.stringify(cfg, null, 2);
const blob = new Blob([json], { type: 'application/json' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = 'discourse-saver-config.json';
a.click();
URL.revokeObjectURL(url);
UtilModule.showNotification('配置已导出', 'success');
});
// 导入配置
overlay.querySelector('#ds-import-config').addEventListener('change', (e) => {
const file = e.target.files[0];
if (!file) return;
const reader = new FileReader();
reader.onload = (ev) => {
try {
const imported = JSON.parse(ev.target.result);
ConfigModule.setAll(imported);
overlay.remove();
UtilModule.showNotification('配置已导入，重新打开设置即可看到', 'success');
} catch (err) {
UtilModule.showNotification('导入失败：JSON 格式不正确', 'error');
}
};
reader.readAsText(file);
});
// 保存按钮
overlay.querySelector('#ds-save').addEventListener('click', () => {
const newConfig = {
// 自定义站点
customSites: overlay.querySelector('#ds-custom-sites').value.trim(),
// 保存目标
saveToObsidian: overlay.querySelector('#ds-save-obsidian').checked,
saveToNotion: overlay.querySelector('#ds-save-notion').checked,
saveToFeishu: overlay.querySelector('#ds-save-feishu').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,
// 下载图片到本地
downloadImages: overlay.querySelector('#ds-download-images').checked,
downloadVideos: overlay.querySelector('#ds-download-videos').checked,
restApiKey: overlay.querySelector('#ds-rest-api-key').value.trim(),
restApiPort: parseInt(overlay.querySelector('#ds-rest-api-port').value) || 27124,
mediaFolderName: overlay.querySelector('#ds-media-folder-name').value.trim() || 'media',
// Notion设置
notionToken: overlay.querySelector('#ds-notion-token').value.trim(),
notionDatabaseId: overlay.querySelector('#ds-notion-db').value.trim(),
// 飞书设置
feishuApiDomain: overlay.querySelector('#ds-feishu-domain').value,
feishuAppId: overlay.querySelector('#ds-feishu-app-id').value.trim(),
feishuAppSecret: overlay.querySelector('#ds-feishu-app-secret').value.trim(),
feishuAppToken: overlay.querySelector('#ds-feishu-app-token').value.trim(),
feishuTableId: overlay.querySelector('#ds-feishu-table-id').value.trim(),
feishuUploadContent: overlay.querySelector('#ds-feishu-upload-content').checked,
feishuUploadAttachment: overlay.querySelector('#ds-feishu-upload-attachment').checked,
feishuUploadHtml: overlay.querySelector('#ds-feishu-upload-html').checked,
// 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() {
// 检测是否是 Discourse 论坛
const isDiscourse = ExtractModule.isDiscourseForumPage();
const isTopicPageNow = ExtractModule.isTopicPage();
console.log('[Discourse Saver] 检测结果:');
console.log('[Discourse Saver] - 是否 Discourse 论坛:', isDiscourse);
console.log('[Discourse Saver] - 是否帖子页面:', isTopicPageNow);
console.log('[Discourse Saver] - 当前 URL:', window.location.href);
injectStyles();
createFloatingButton();
// 注册油猴菜单
GM_registerMenuCommand('⚙️ 设置', showSettingsPanel);
GM_registerMenuCommand('📥 保存当前帖子（全部目标）', () => SaveModule.save(null));
GM_registerMenuCommand('📝 仅保存到 Obsidian', () => SaveModule.saveToObsidianOnly(null));
GM_registerMenuCommand('📑 仅保存到 Notion', () => SaveModule.saveToNotionOnly(null));
GM_registerMenuCommand('🐦 仅保存到飞书', () => SaveModule.saveToFeishuOnly(null));
GM_registerMenuCommand('📄 仅导出为 HTML', () => SaveModule.exportHtmlOnly(null));
GM_registerMenuCommand('💾 下载大文件（备选）', () => SaveModule.downloadLastLargeFile());
GM_registerMenuCommand('🔍 调试信息', () => {
const info = {
isDiscourse: ExtractModule.isDiscourseForumPage(),
isTopicPage: ExtractModule.isTopicPage(),
url: window.location.href,
title: document.title,
hasTopicTitle: !!document.querySelector('#topic-title h1, .fancy-title'),
hasCooked: !!document.querySelector('.cooked'),
hasPostStream: !!document.querySelector('.post-stream, .topic-post')
};
console.log('[Discourse Saver] 调试信息:', info);
alert('调试信息已输出到控制台 (F12)\n\n' +
'是否 Discourse: ' + info.isDiscourse + '\n' +
'是否帖子页面: ' + info.isTopicPage + '\n' +
'找到标题: ' + info.hasTopicTitle + '\n' +
'找到内容: ' + info.hasCooked + '\n' +
'找到帖子流: ' + info.hasPostStream);
});
console.log('[Discourse Saver] 油猴脚本已加载 (V5.5.9)');
}
return { init, showSettingsPanel };
})();
// ============================================================
// 启动脚本
// ============================================================
UIModule.init();
})();