导出 MiniMax Agent 对话内容为 Markdown 格式，包括对话、Task 和 Thinking
// ==UserScript==
// @name MiniMax Dialogue Exporter
// @namespace https://agent.minimaxi.com/
// @version 3.2.1
// @description 导出 MiniMax Agent 对话内容为 Markdown 格式，包括对话、Task 和 Thinking
// @author AIPD01
// @match https://agent.minimaxi.com/*
// @icon https://agent.minimaxi.com/favicon.ico
// @grant GM_download
// @grant GM_setClipboard
// @license MIT
// ==/UserScript==
(function() {
'use strict';
// 配置
const CONFIG = {
containerId: 'minimax-export-container',
exportBtnId: 'minimax-export-btn',
copyBtnId: 'minimax-copy-btn'
};
// 创建按钮容器
function createButtonContainer() {
if (document.getElementById(CONFIG.containerId)) return;
// 创建容器
const container = document.createElement('div');
container.id = CONFIG.containerId;
container.style.cssText = `
position: fixed;
bottom: 20px;
right: 20px;
z-index: 9999;
display: flex;
flex-direction: column;
gap: 10px;
`;
// 创建导出按钮
const exportBtn = createButton(CONFIG.exportBtnId, '📥 导出文件', '#4F46E5', exportToFile);
// 创建复制按钮
const copyBtn = createButton(CONFIG.copyBtnId, '📋 复制内容', '#10B981', copyToClipboard);
container.appendChild(exportBtn);
container.appendChild(copyBtn);
document.body.appendChild(container);
}
// 创建单个按钮
function createButton(id, text, bgColor, onClick) {
const button = document.createElement('button');
button.id = id;
button.textContent = text;
button.style.cssText = `
padding: 12px 20px;
background-color: ${bgColor};
color: #ffffff;
border: none;
border-radius: 8px;
cursor: pointer;
font-size: 14px;
font-weight: 600;
box-shadow: 0 4px 12px ${bgColor}66;
transition: all 0.3s ease;
white-space: nowrap;
`;
const hoverColor = adjustColor(bgColor, -20);
button.addEventListener('mouseenter', () => {
button.style.backgroundColor = hoverColor;
button.style.transform = 'translateY(-2px)';
});
button.addEventListener('mouseleave', () => {
button.style.backgroundColor = bgColor;
button.style.transform = 'translateY(0)';
});
button.addEventListener('click', onClick);
return button;
}
// 调整颜色亮度
function adjustColor(hex, amount) {
const num = parseInt(hex.replace('#', ''), 16);
const r = Math.max(0, Math.min(255, (num >> 16) + amount));
const g = Math.max(0, Math.min(255, ((num >> 8) & 0x00FF) + amount));
const b = Math.max(0, Math.min(255, (num & 0x0000FF) + amount));
return `#${(1 << 24 | r << 16 | g << 8 | b).toString(16).slice(1)}`;
}
// 获取对话标题
function getDialogueTitle() {
// 从页面标题获取，格式通常是 "标题 - MiniMax Agent"
const pageTitle = document.title;
const titleMatch = pageTitle.match(/^(.+?)\s*-\s*MiniMax Agent$/);
if (titleMatch) {
return titleMatch[1].trim();
}
// 备用：从 URL 的 share ID 生成
const urlMatch = window.location.pathname.match(/\/share\/(\d+)/);
if (urlMatch) {
return `MiniMax 对话_${urlMatch[1]}`;
}
return `MiniMax 对话_${new Date().toISOString().slice(0, 10)}`;
}
// 清理文本
function cleanText(text) {
return text
.replace(/\s+/g, ' ')
.trim();
}
// 获取元素的缩进层级 (基于 padding-left)
function getIndentLevel(element) {
const style = element.getAttribute('style') || '';
const paddingMatch = style.match(/padding-left:\s*(\d+)px/);
if (paddingMatch) {
const padding = parseInt(paddingMatch[1]);
if (padding >= 64) return 2; // 二级子内容
if (padding >= 32) return 1; // 一级子任务
}
return 0; // 顶层
}
// 主提取函数 - 基于实际 DOM 结构，支持层级
function extractDialogueFromDOM() {
const items = [];
// 找到主对话容器
const messagesContainer = document.querySelector('.messages-container');
if (!messagesContainer) {
console.warn('未找到 .messages-container');
return items;
}
// 获取所有消息块 - 直接子元素中包含 .message 的
const allMessages = messagesContainer.querySelectorAll('.message.sent, .message.received');
if (allMessages.length === 0) {
console.warn('未找到消息元素');
return items;
}
const processedTexts = new Set(); // 用于去重
allMessages.forEach((messageEl, index) => {
const isSent = messageEl.classList.contains('sent');
const isReceived = messageEl.classList.contains('received');
// 获取层级
const level = getIndentLevel(messageEl);
if (isSent) {
// 用户消息
const userContent = extractUserMessageContent(messageEl);
if (userContent && !processedTexts.has(userContent)) {
items.push({
type: 'user',
content: userContent,
level: 0 // 用户消息始终是顶层
});
processedTexts.add(userContent);
}
} else if (isReceived) {
// AI 响应 - 可能包含多种内容
const receivedItems = extractReceivedContent(messageEl, processedTexts, level);
items.push(...receivedItems);
}
});
return items;
}
// 提取用户消息内容
function extractUserMessageContent(messageEl) {
// 用户消息结构：.message.sent > .message-content > .text-pretty
const textPretty = messageEl.querySelector('.text-pretty');
if (textPretty) {
return cleanText(textPretty.textContent || '');
}
// 备用：直接获取 .message-content 的文本
const messageContent = messageEl.querySelector('.message-content');
if (messageContent) {
return cleanText(messageContent.textContent || '');
}
return '';
}
// 提取 AI 响应内容（received 消息）
function extractReceivedContent(messageEl, processedTexts, level) {
const items = [];
// 1. 检查是否是思考块
const thinkContainer = messageEl.querySelector('.think-container');
if (thinkContainer) {
const thinkingItem = extractThinkingBlock(thinkContainer, processedTexts, level);
if (thinkingItem) {
items.push(thinkingItem);
}
// 思考块后面可能还有正文内容
const matrixMarkdown = messageEl.querySelector('.matrix-markdown');
if (matrixMarkdown) {
const textItems = extractMarkdownContent(matrixMarkdown, processedTexts, true, level);
items.push(...textItems);
}
return items;
}
// 2. 检查是否是工具调用
const toolName = messageEl.querySelector('.tool-name');
if (toolName) {
const toolItem = extractToolBlock(messageEl, processedTexts, level);
if (toolItem) {
items.push(toolItem);
}
return items;
}
// 3. 普通 AI 响应 - 提取 matrix-markdown 内容
const matrixMarkdown = messageEl.querySelector('.matrix-markdown');
if (matrixMarkdown) {
const textItems = extractMarkdownContent(matrixMarkdown, processedTexts, false, level);
items.push(...textItems);
}
return items;
}
// 提取思考块内容
function extractThinkingBlock(thinkContainer, processedTexts, level = 0) {
// 获取思考时间
let duration = '';
const durationSpan = thinkContainer.querySelector('span');
if (durationSpan) {
const timeText = durationSpan.textContent;
const timeMatch = timeText.match(/(\d+\.?\d*)s/);
if (timeMatch) {
duration = `${timeMatch[1]}s`;
}
}
// 获取思考内容 - 在 .hidden 内的 .relative.pl-5 中
let content = '';
const hiddenDiv = thinkContainer.querySelector('.hidden');
if (hiddenDiv) {
const contentDiv = hiddenDiv.querySelector('.relative.pl-5, [class*="pl-5"]');
if (contentDiv) {
content = extractTextFromElement(contentDiv);
} else {
// 备用：直接获取 hidden div 的文本
content = extractTextFromElement(hiddenDiv);
}
}
const key = `thinking:${duration}:${content.slice(0, 50)}`;
if (processedTexts.has(key)) return null;
processedTexts.add(key);
return {
type: 'thinking',
duration: duration,
content: content || null,
level: level
};
}
// 提取工具调用块
function extractToolBlock(messageEl, processedTexts, level = 0) {
const toolNameEl = messageEl.querySelector('.tool-name');
if (!toolNameEl) return null;
const fullText = toolNameEl.textContent.trim();
// 检查是否是高级任务（深度研究任务、浏览器代理等）
const isAgentTask = toolNameEl.classList.contains('tool-agent-name');
if (isAgentTask) {
// 高级任务 - 作为章节标题
const agentTaskName = fullText;
const key = `agent:${agentTaskName}`;
if (processedTexts.has(key)) return null;
processedTexts.add(key);
return {
type: 'agent_task',
name: agentTaskName,
level: level
};
}
// 判断状态
const isCompleted = fullText.includes('已完成') || fullText.includes('Completed');
const isOngoing = fullText.includes('正在进行') || fullText.includes('Ongoing');
if (!isCompleted && !isOngoing) return null;
// 提取动作名称 - 在 span 中
let action = '';
const actionSpans = toolNameEl.querySelectorAll('span');
actionSpans.forEach(span => {
const spanText = span.textContent.trim();
if (spanText && !spanText.match(/^\d/) && spanText.length > 2) {
if (spanText.includes('已完成') || spanText.includes('正在进行')) {
action = spanText;
}
}
});
if (!action) {
// 从全文提取
action = fullText
.replace(/已完成|正在进行|Completed|Ongoing/g, '')
.trim()
.split('\n')[0]
.trim();
}
// 提取详细信息（如文件路径）
let detail = '';
const detailDiv = toolNameEl.querySelector('[class*="text-col_text01"]');
if (detailDiv) {
detail = detailDiv.textContent.trim();
} else {
// 从全文提取路径
const pathMatch = fullText.match(/(\/[\w\-\/\.]+)/);
if (pathMatch) {
detail = pathMatch[1];
}
}
// 清理 action
action = action.replace(detail, '').trim();
if (!action || action.length < 2) {
action = fullText.split('\n')[0].replace(/已完成|正在进行/g, '').trim();
}
const key = `task:${action}:${detail}`;
if (processedTexts.has(key)) return null;
processedTexts.add(key);
return {
type: 'task',
status: isCompleted ? 'completed' : 'ongoing',
action: action,
detail: detail,
level: level
};
}
// 提取Markdown内容
function extractMarkdownContent(matrixMarkdown, processedTexts, skipThinking, level = 0) {
const items = [];
// 提取纯文本内容（排除思考块）
const text = extractTextFromElementExcluding(matrixMarkdown, skipThinking ? '.think-container' : null);
if (text && text.length > 5) {
const key = `assistant:${text.slice(0, 100)}`;
if (!processedTexts.has(key)) {
items.push({
type: 'assistant',
content: text,
level: level
});
processedTexts.add(key);
}
}
return items;
}
// 从元素提取文本（可排除指定选择器）
function extractTextFromElementExcluding(element, excludeSelector) {
if (!element) return '';
let text = '';
const walker = document.createTreeWalker(
element,
NodeFilter.SHOW_TEXT,
{
acceptNode: function(node) {
// 跳过 SVG 内的文本
if (node.parentElement?.closest('svg')) {
return NodeFilter.FILTER_REJECT;
}
// 跳过排除选择器内的文本
if (excludeSelector && node.parentElement?.closest(excludeSelector)) {
return NodeFilter.FILTER_REJECT;
}
// 跳过空文本
if (!node.textContent.trim()) {
return NodeFilter.FILTER_REJECT;
}
return NodeFilter.FILTER_ACCEPT;
}
}
);
let currentNode;
while (currentNode = walker.nextNode()) {
const nodeText = currentNode.textContent.trim();
// 跳过仅包含时间格式的节点
if (nodeText && !nodeText.match(/^\d+\.?\d*s$/)) {
text += nodeText + ' ';
}
}
return cleanText(text);
}
// 从元素提取文本（处理嵌套结构）
function extractTextFromElement(element) {
if (!element) return '';
let text = '';
const walker = document.createTreeWalker(
element,
NodeFilter.SHOW_TEXT,
{
acceptNode: function(node) {
// 跳过 SVG 内的文本
if (node.parentElement?.closest('svg')) {
return NodeFilter.FILTER_REJECT;
}
// 跳过空文本
if (!node.textContent.trim()) {
return NodeFilter.FILTER_REJECT;
}
return NodeFilter.FILTER_ACCEPT;
}
}
);
let node;
while (node = walker.nextNode()) {
const nodeText = node.textContent.trim();
// 跳过仅包含时间格式的节点
if (nodeText && !nodeText.match(/^\d+\.?\d*s$/)) {
text += nodeText + ' ';
}
}
return cleanText(text);
}
// 去重
function deduplicateItems(items) {
const seen = new Set();
return items.filter(item => {
const key = item.type + ':' + (item.content?.slice(0, 50) || item.action || '');
if (seen.has(key)) return false;
if (key.length < 5) return false;
seen.add(key);
return true;
});
}
// 转换为Markdown
function convertToMarkdown(title, items) {
let markdown = `# ${title}\n\n`;
markdown += `> 导出时间: ${new Date().toLocaleString('zh-CN')}\n`;
markdown += `> 导出条数: ${items.length} 条\n`;
markdown += `> 来源: ${window.location.href}\n\n`;
markdown += `---\n\n`;
let currentRole = '';
let currentLevel = 0;
let assistantContentBuffer = [];
const flushAssistantBuffer = () => {
if (assistantContentBuffer.length > 0) {
markdown += assistantContentBuffer.join('\n\n') + '\n\n';
assistantContentBuffer = [];
}
};
// 根据层级获取标题前缀
const getHeadingPrefix = (baseLevel, itemLevel) => {
// baseLevel: 2 = ##, 3 = ###, 4 = ####
const totalLevel = baseLevel + itemLevel;
return '#'.repeat(Math.min(totalLevel, 6)); // 最多 6 级标题
};
items.forEach((item, index) => {
const level = item.level || 0;
switch (item.type) {
case 'user':
flushAssistantBuffer();
markdown += `## 👤 用户\n\n`;
markdown += `${item.content}\n\n`;
currentRole = 'user';
currentLevel = 0;
break;
case 'agent_task':
// 高级任务（深度研究任务、浏览器代理等）- 作为三级标题
flushAssistantBuffer();
const agentHeading = getHeadingPrefix(3, level);
markdown += `${agentHeading} 🔄 ${item.name}\n\n`;
currentRole = 'agent';
currentLevel = level;
break;
case 'assistant':
// 根据层级决定是否需要新的标题
if (currentRole !== 'assistant' || level !== currentLevel) {
flushAssistantBuffer();
if (level === 0) {
markdown += `## 🤖 AI助手\n\n`;
} else if (level === 1) {
// 一级子任务的 AI 响应
markdown += `#### 📌 子任务响应\n\n`;
}
// level >= 2 的内容不加标题，直接作为正文
currentRole = 'assistant';
currentLevel = level;
}
assistantContentBuffer.push(item.content);
break;
case 'thinking':
flushAssistantBuffer();
markdown += `<details>\n`;
markdown += `<summary>💭 思考过程 ${item.duration || ''}</summary>\n\n`;
if (item.content) {
markdown += `${item.content}\n\n`;
} else {
markdown += `*(思考内容未展开)*\n\n`;
}
markdown += `</details>\n\n`;
currentRole = '';
break;
case 'task':
flushAssistantBuffer();
const statusIcon = item.status === 'completed' ? '✅' : '🔄';
// 根据层级添加缩进
const indent = level > 0 ? ' '.repeat(level) : '';
markdown += `${indent}${statusIcon} **${item.action}**`;
if (item.detail) {
markdown += ` \`${item.detail}\``;
}
markdown += `\n\n`;
currentRole = '';
break;
}
});
flushAssistantBuffer();
return markdown;
}
// 备用提取方法 - 基于类名扫描
function extractDialogueFromClasses() {
const items = [];
const processedTexts = new Set();
// 1. 提取所有 .text-pretty 作为可能的用户消息
document.querySelectorAll('.message.sent .text-pretty').forEach(el => {
const text = cleanText(el.textContent || '');
if (text && text.length > 2 && !processedTexts.has(text)) {
items.push({ type: 'user', content: text, level: 0 });
processedTexts.add(text);
}
});
// 2. 提取高级任务（深度研究任务等）
document.querySelectorAll('.tool-agent-name').forEach(el => {
const text = el.textContent.trim();
const key = `agent:${text}`;
if (text && !processedTexts.has(key)) {
const messageEl = el.closest('.message');
const level = messageEl ? getIndentLevel(messageEl) : 0;
items.push({ type: 'agent_task', name: text, level: level });
processedTexts.add(key);
}
});
// 3. 提取思考块
document.querySelectorAll('.think-container').forEach(el => {
const messageEl = el.closest('.message');
const level = messageEl ? getIndentLevel(messageEl) : 0;
const item = extractThinkingBlock(el, processedTexts, level);
if (item) items.push(item);
});
// 4. 提取工具调用
document.querySelectorAll('.tool-name:not(.tool-agent-name)').forEach(el => {
const messageEl = el.closest('.message');
if (messageEl) {
const level = getIndentLevel(messageEl);
const item = extractToolBlock(messageEl, processedTexts, level);
if (item) items.push(item);
}
});
// 5. 提取 AI 响应文本
document.querySelectorAll('.message.received .matrix-markdown').forEach(el => {
// 跳过思考块内的
if (el.closest('.think-container')) return;
const messageEl = el.closest('.message');
const level = messageEl ? getIndentLevel(messageEl) : 0;
const text = extractTextFromElement(el);
if (text && text.length > 10 && !processedTexts.has(text.slice(0, 100))) {
items.push({ type: 'assistant', content: text, level: level });
processedTexts.add(text.slice(0, 100));
}
});
return items;
}
// 获取提取结果
function getExtractedContent() {
const title = getDialogueTitle();
// 首先尝试 DOM 结构提取
let items = extractDialogueFromDOM();
// 如果结果太少，使用备用方法
if (items.length < 3) {
console.log('DOM提取结果较少，尝试备用方法...');
items = extractDialogueFromClasses();
}
// 去重
items = deduplicateItems(items);
return { title, items };
}
// 导出到文件
function exportToFile() {
try {
const { title, items } = getExtractedContent();
if (items.length === 0) {
alert('未能提取到对话内容。\n\n⚠️ 提示：\n1. 此页面是演示动画，请等待动画播放完成后再导出\n2. 确保页面已完全加载\n3. 如果仍无法导出，请尝试刷新页面');
return;
}
const markdown = convertToMarkdown(title, items);
// 下载文件
downloadMarkdown(title, markdown);
console.log(`✅ 成功导出 ${items.length} 条对话内容到文件`);
showToast(`已导出 ${items.length} 条内容到文件`);
} catch (error) {
console.error('导出失败:', error);
alert('导出失败: ' + error.message);
}
}
// 复制到剪贴板
function copyToClipboard() {
try {
const { title, items } = getExtractedContent();
if (items.length === 0) {
alert('未能提取到对话内容。\n\n⚠️ 提示：\n1. 此页面是演示动画，请等待动画播放完成后再导出\n2. 确保页面已完全加载\n3. 如果仍无法导出，请尝试刷新页面');
return;
}
const markdown = convertToMarkdown(title, items);
// 复制到剪贴板
if (typeof GM_setClipboard !== 'undefined') {
GM_setClipboard(markdown, 'text');
console.log(`✅ 成功复制 ${items.length} 条对话内容到剪贴板`);
showToast(`已复制 ${items.length} 条内容到剪贴板`);
} else {
navigator.clipboard.writeText(markdown).then(() => {
console.log(`✅ 成功复制 ${items.length} 条对话内容到剪贴板`);
showToast(`已复制 ${items.length} 条内容到剪贴板`);
}).catch(e => {
console.error('复制到剪贴板失败：', e);
alert('复制失败，请重试');
});
}
} catch (error) {
console.error('复制失败：', error);
alert('复制失败：' + error.message);
}
}
// 显示提示
function showToast(message) {
const toast = document.createElement('div');
toast.textContent = message;
toast.style.cssText = `
position: fixed;
bottom: 80px;
right: 20px;
background: #10B981;
color: white;
padding: 12px 24px;
border-radius: 8px;
font-size: 14px;
font-weight: 500;
z-index: 10000;
box-shadow: 0 4px 12px rgba(16, 185, 129, 0.4);
animation: fadeInOut 2s ease forwards;
`;
// 添加动画
const style = document.createElement('style');
style.textContent = `
@keyframes fadeInOut {
0% { opacity: 0; transform: translateY(10px); }
15% { opacity: 1; transform: translateY(0); }
85% { opacity: 1; transform: translateY(0); }
100% { opacity: 0; transform: translateY(-10px); }
}
`;
document.head.appendChild(style);
document.body.appendChild(toast);
setTimeout(() => {
toast.remove();
style.remove();
}, 2000);
}
// 下载 Markdown 文件
function downloadMarkdown(title, content) {
const filename = sanitizeFilename(title) + '.md';
// 使用 Data URL 方式下载（兼容性最好）
try {
// 将内容转换为 Base64
const base64Content = btoa(unescape(encodeURIComponent(content)));
const dataUrl = `data:text/markdown;charset=utf-8;base64,${base64Content}`;
const a = document.createElement('a');
a.href = dataUrl;
a.download = filename;
a.style.display = 'none';
document.body.appendChild(a);
a.click();
// 延迟移除元素
setTimeout(() => {
document.body.removeChild(a);
}, 100);
console.log(`📥 正在下载：${filename}`);
} catch (e) {
console.error('Data URL 下载失败，尝试 Blob 方式：', e);
// 备用方案：使用 Blob URL
const blob = new Blob([content], { type: 'text/markdown;charset=utf-8' });
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = filename;
a.style.display = 'none';
document.body.appendChild(a);
a.click();
setTimeout(() => {
document.body.removeChild(a);
URL.revokeObjectURL(url);
}, 100);
}
}
// 清理文件名
function sanitizeFilename(name) {
return name
.replace(/[<>:"/\\|?*]/g, '_')
.replace(/\s+/g, '_')
.slice(0, 100);
}
// 初始化
function init() {
// 等待页面加载完成
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', createButtonContainer);
} else {
createButtonContainer();
}
// 监听 URL 变化（SPA 应用）
let lastUrl = location.href;
new MutationObserver(() => {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(createButtonContainer, 1000);
}
}).observe(document.body, { subtree: true, childList: true });
}
init();
})();