TypeError & Working Version

[rebelancap]

Stopped working for me today, with TypeError: undefined is not an object (evaluating 'o.classList [0].split')
Claude suggested the following instead, which now works for me.

// Fixed version of the Claude export script with better error handling
(function() {
    // Helper function to safely get language from classList
    function getLanguageFromClassList(element) {
        if (!element || !element.classList || element.classList.length === 0) {
            return 'text'; // default fallback
        }
        
        // Look for language- classes
        for (let className of element.classList) {
            if (className.startsWith('language-')) {
                return className.split('-')[1] || 'text';
            }
        }
        
        // Fallback: try the first class if it contains a dash
        const firstClass = element.classList[0];
        if (firstClass && firstClass.includes('-')) {
            return firstClass.split('-')[1] || 'text';
        }
        
        return 'text'; // ultimate fallback
    }

    // Save function
    function saveToFile(content, format, filename = '') {
        const mimeType = format === 'json' ? 'application/json' : 'text/plain';
        const extension = format === 'json' ? '.json' : '.md';
        
        let finalFilename = filename ? 
            filename.trim().toLowerCase().replace(/^[^\w\d]+|[^\w\d]+$/g, "").replace(/[\s\W-]+/g, "-") : 
            "claude";
        finalFilename += extension;
        
        if (format === 'json' && typeof content === 'object') {
            content = JSON.stringify(content, null, 2);
        }
        
        const blob = new Blob([content], { type: mimeType });
        const url = window.URL.createObjectURL(blob);
        
        const a = document.createElement('a');
        a.download = finalFilename;
        a.href = url;
        a.click();
        
        window.URL.revokeObjectURL(url);
    }

    // Get current timestamp
    function getCurrentTimestamp() {
        return new Date().toISOString().slice(0, 19).replace("T", " ");
    }

    // Extract conversation data
    function extractConversation() {
        const container = document.querySelector("div.flex-1.flex.flex-col.gap-3.px-4");
        const titleButton = document.querySelector("button[data-testid='chat-menu-trigger']");
        const title = titleButton ? titleButton.textContent : "";
        
        if (!container) {
            console.error("Could not find conversation container");
            return null;
        }
        
        const messageElements = container.querySelectorAll("div.font-claude-message, div.font-user-message");
        
        const conversation = {
            meta: {
                exported_at: getCurrentTimestamp(),
                title: title
            },
            chats: []
        };
        
        for (let i = 0; i < messageElements.length; i++) {
            const element = messageElements[i];
            const message = {
                index: i,
                type: element.classList.contains("font-claude-message") ? "response" : "prompt",
                message: []
            };
            
            const firstChild = element.firstChild;
            if (!firstChild) continue;
            
            let contentNodes = [];
            
            if (firstChild.nodeType === Node.ELEMENT_NODE) {
                if (message.type === "response") {
                    const innerChild = firstChild.firstChild || firstChild;
                    contentNodes = Array.from(innerChild.childNodes);
                } else {
                    contentNodes = Array.from(element.childNodes);
                }
                
                for (const node of contentNodes) {
                    if (node.nodeType === Node.ELEMENT_NODE) {
                        const tagName = node.tagName;
                        const textContent = node.textContent;
                        
                        if (tagName === 'P') {
                            message.message.push({ type: 'p', data: textContent });
                        } else if (tagName === 'OL' || tagName === 'UL') {
                            const items = Array.from(node.querySelectorAll('li')).map(li => ({
                                type: 'li',
                                data: li.textContent
                            }));
                            message.message.push({ 
                                type: tagName.toLowerCase(), 
                                data: items 
                            });
                        } else if (tagName === 'PRE') {
                            const codeElement = node.querySelector('code');
                            if (codeElement) {
                                const code = codeElement.textContent;
                                const language = getLanguageFromClassList(codeElement);
                                message.message.push({
                                    type: 'pre',
                                    language: language,
                                    data: code
                                });
                            }
                        } else if (tagName === 'TABLE') {
                            const tableData = [];
                            const sections = node.querySelectorAll('thead, tbody');
                            
                            sections.forEach(section => {
                                const rows = [];
                                const rowElements = section.querySelectorAll('tr');
                                
                                rowElements.forEach(row => {
                                    const cells = [];
                                    const cellElements = row.querySelectorAll('td, th');
                                    
                                    cellElements.forEach(cell => {
                                        cells.push({
                                            type: cell.tagName.toLowerCase(),
                                            data: cell.textContent
                                        });
                                    });
                                    
                                    rows.push({ type: 'tr', data: cells });
                                });
                                
                                tableData.push({
                                    type: section.tagName.toLowerCase(),
                                    data: rows
                                });
                            });
                            
                            message.message.push({ type: 'table', data: tableData });
                        }
                    }
                }
            } else if (firstChild.nodeType === Node.TEXT_NODE) {
                message.message.push({ type: 'text', data: firstChild.textContent });
            }
            
            conversation.chats.push(message);
        }
        
        return conversation;
    }
    
    // Main execution
    try {
        const conversation = extractConversation();
        if (conversation) {
            console.log("Conversation extracted successfully:", conversation);
            saveToFile(conversation, 'json', conversation.meta.title);
            console.log("✅ Export completed successfully!");
        } else {
            console.error("❌ Failed to extract conversation");
        }
    } catch (error) {
        console.error("❌ Export failed:", error);
    }
})();

[rebelancap]

Actually this one stopped working as well. This one fixed.

// Enhanced Claude export script with aggressive content extraction
(function() {
    // Helper function to safely get language from classList
    function getLanguageFromClassList(element) {
        if (!element || !element.classList || element.classList.length === 0) {
            return 'text';
        }
        
        for (let className of element.classList) {
            if (className.startsWith('language-')) {
                return className.split('-')[1] || 'text';
            }
        }
        
        const firstClass = element.classList[0];
        if (firstClass && firstClass.includes('-')) {
            return firstClass.split('-')[1] || 'text';
        }
        
        return 'text';
    }

    // Save function
    function saveToFile(content, format, filename = '') {
        const mimeType = format === 'json' ? 'application/json' : 'text/plain';
        const extension = format === 'json' ? '.json' : '.md';
        
        let finalFilename = filename ? 
            filename.trim().toLowerCase().replace(/^[^\w\d]+|[^\w\d]+$/g, "").replace(/[\s\W-]+/g, "-") : 
            "claude";
        finalFilename += extension;
        
        if (format === 'json' && typeof content === 'object') {
            content = JSON.stringify(content, null, 2);
        }
        
        const blob = new Blob([content], { type: mimeType });
        const url = window.URL.createObjectURL(blob);
        
        const a = document.createElement('a');
        a.download = finalFilename;
        a.href = url;
        a.click();
        
        window.URL.revokeObjectURL(url);
    }

    // Get current timestamp
    function getCurrentTimestamp() {
        return new Date().toISOString().slice(0, 19).replace("T", " ");
    }

    // Deep clone to avoid circular references
    function safeStringify(obj) {
        const seen = new WeakSet();
        return JSON.stringify(obj, (key, value) => {
            if (typeof value === "object" && value !== null) {
                if (seen.has(value)) {
                    return "[Circular]";
                }
                seen.add(value);
            }
            return value;
        }, 2);
    }

    // Recursively extract all content from an element with depth tracking
    function extractElementContent(element, depth = 0, maxDepth = 20) {
        const content = [];
        
        // Prevent infinite recursion
        if (depth > maxDepth) {
            console.warn(`Max depth ${maxDepth} reached`);
            return content;
        }
        
        // Process text nodes
        if (element.nodeType === Node.TEXT_NODE) {
            const text = element.textContent.trim();
            if (text) {
                return [{ type: 'text', data: text }];
            }
            return [];
        }
        
        // Process element nodes
        if (element.nodeType === Node.ELEMENT_NODE) {
            const tagName = element.tagName;
            
            // Skip certain elements that might cause issues
            if (['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEMPLATE'].includes(tagName)) {
                return [];
            }
            
            // Special handling for different element types
            if (tagName === 'P') {
                // For paragraphs, get all text content including nested elements
                const fullText = element.textContent.trim();
                if (fullText) {
                    content.push({ type: 'p', data: fullText });
                }
            } else if (tagName === 'OL' || tagName === 'UL') {
                const items = Array.from(element.querySelectorAll(':scope > li')).map(li => ({
                    type: 'li',
                    data: li.textContent.trim()
                }));
                if (items.length > 0) {
                    content.push({ 
                        type: tagName.toLowerCase(), 
                        data: items 
                    });
                }
            } else if (tagName === 'PRE') {
                // Handle code blocks
                const codeElement = element.querySelector('code');
                if (codeElement) {
                    const code = codeElement.textContent;
                    const language = getLanguageFromClassList(codeElement);
                    content.push({
                        type: 'pre',
                        language: language,
                        data: code
                    });
                } else {
                    // Pre without code
                    const text = element.textContent;
                    if (text) {
                        content.push({
                            type: 'pre',
                            language: 'text',
                            data: text
                        });
                    }
                }
            } else if (tagName === 'TABLE') {
                const tableData = [];
                const sections = element.querySelectorAll('thead, tbody');
                
                if (sections.length === 0) {
                    // Handle tables without thead/tbody
                    const rows = element.querySelectorAll('tr');
                    const rowsData = [];
                    rows.forEach(row => {
                        const cells = [];
                        const cellElements = row.querySelectorAll('td, th');
                        cellElements.forEach(cell => {
                            cells.push({
                                type: cell.tagName.toLowerCase(),
                                data: cell.textContent.trim()
                            });
                        });
                        if (cells.length > 0) {
                            rowsData.push({ type: 'tr', data: cells });
                        }
                    });
                    if (rowsData.length > 0) {
                        tableData.push({ type: 'tbody', data: rowsData });
                    }
                } else {
                    sections.forEach(section => {
                        const rows = [];
                        const rowElements = section.querySelectorAll('tr');
                        rowElements.forEach(row => {
                            const cells = [];
                            const cellElements = row.querySelectorAll('td, th');
                            cellElements.forEach(cell => {
                                cells.push({
                                    type: cell.tagName.toLowerCase(),
                                    data: cell.textContent.trim()
                                });
                            });
                            if (cells.length > 0) {
                                rows.push({ type: 'tr', data: cells });
                            }
                        });
                        if (rows.length > 0) {
                            tableData.push({
                                type: section.tagName.toLowerCase(),
                                data: rows
                            });
                        }
                    });
                }
                
                if (tableData.length > 0) {
                    content.push({ type: 'table', data: tableData });
                }
            } else if (tagName === 'H1' || tagName === 'H2' || tagName === 'H3' || tagName === 'H4' || tagName === 'H5' || tagName === 'H6') {
                const text = element.textContent.trim();
                if (text) {
                    content.push({ type: tagName.toLowerCase(), data: text });
                }
            } else if (tagName === 'BLOCKQUOTE') {
                const text = element.textContent.trim();
                if (text) {
                    content.push({ type: 'blockquote', data: text });
                }
            } else if (tagName === 'CODE' && element.parentElement?.tagName !== 'PRE') {
                // Inline code
                const text = element.textContent;
                if (text) {
                    content.push({ type: 'code', data: text });
                }
            } else if (tagName === 'IMG') {
                const src = element.getAttribute('src');
                const alt = element.getAttribute('alt');
                if (src) {
                    content.push({ type: 'img', src: src, alt: alt || '' });
                }
            } else if (tagName === 'A') {
                const href = element.getAttribute('href');
                const text = element.textContent.trim();
                if (text) {
                    content.push({ type: 'link', href: href || '#', data: text });
                }
            } else if (tagName === 'BR') {
                content.push({ type: 'br' });
            } else if (tagName === 'HR') {
                content.push({ type: 'hr' });
            } else if (tagName === 'DIV' || tagName === 'SPAN' || tagName === 'SECTION' || tagName === 'ARTICLE') {
                // For container elements, recursively process all children
                const childNodes = Array.from(element.childNodes);
                for (const child of childNodes) {
                    const childContent = extractElementContent(child, depth + 1, maxDepth);
                    content.push(...childContent);
                }
            } else {
                // For any other element, try to get its text content if it has any
                const text = element.textContent.trim();
                if (text && text.length > 0) {
                    content.push({ type: 'text', data: text });
                }
            }
        }
        
        return content;
    }

    // Extract conversation data with better message detection
    function extractConversation() {
        // Try multiple selectors for the conversation container
        const containerSelectors = [
            "div.flex-1.flex.flex-col.gap-3.px-4",
            "[class*='flex-1'][class*='flex-col']",
            "main [class*='flex-col']",
            "[role='main'] > div"
        ];
        
        let container = null;
        for (const selector of containerSelectors) {
            container = document.querySelector(selector);
            if (container) {
                console.log(`Found container with selector: ${selector}`);
                break;
            }
        }
        
        if (!container) {
            console.error("Could not find conversation container with any selector");
            return null;
        }
        
        // Try to find the title
        const titleSelectors = [
            "button[data-testid='chat-menu-trigger']",
            "[class*='font-medium']",
            "h1",
            "header button"
        ];
        
        let title = "";
        for (const selector of titleSelectors) {
            const titleElement = document.querySelector(selector);
            if (titleElement && titleElement.textContent) {
                title = titleElement.textContent.trim();
                if (title) break;
            }
        }
        
        // Find all message elements - try multiple approaches
        let messageElements = container.querySelectorAll("div.font-claude-message, div.font-user-message");
        
        if (messageElements.length === 0) {
            console.log("No messages found with font classes, trying alternative selectors...");
            
            // Try to find messages by structure
            const alternativeSelectors = [
                "[class*='font-'][class*='message']",
                "[data-testid*='message']",
                "[class*='prose']",
                "article"
            ];
            
            for (const selector of alternativeSelectors) {
                messageElements = container.querySelectorAll(selector);
                if (messageElements.length > 0) {
                    console.log(`Found ${messageElements.length} messages with selector: ${selector}`);
                    break;
                }
            }
        }
        
        // If still no messages, try to find by content structure
        if (messageElements.length === 0) {
            console.log("Trying to find messages by content structure...");
            const allDivs = container.querySelectorAll("div");
            const potentialMessages = [];
            
            for (const div of allDivs) {
                // Look for divs that contain substantial text content
                const text = div.textContent.trim();
                if (text.length > 50 && !div.querySelector("[class*='flex-col']")) {
                    // Check if this div is not just a container
                    const childDivs = div.querySelectorAll("div");
                    if (childDivs.length < 5) {
                        potentialMessages.push(div);
                    }
                }
            }
            
            messageElements = potentialMessages;
            console.log(`Found ${messageElements.length} potential messages by structure`);
        }
        
        const conversation = {
            meta: {
                exported_at: getCurrentTimestamp(),
                title: title || "Untitled Conversation",
                message_count: messageElements.length
            },
            chats: []
        };
        
        console.log(`Processing ${messageElements.length} messages...`);
        
        for (let i = 0; i < messageElements.length; i++) {
            const element = messageElements[i];
            
            // Try to determine message type
            let messageType = "unknown";
            const classList = element.className || "";
            
            if (classList.includes("claude") || classList.includes("assistant")) {
                messageType = "response";
            } else if (classList.includes("user") || classList.includes("human")) {
                messageType = "prompt";
            } else {
                // Try to infer from position or content
                messageType = i % 2 === 0 ? "prompt" : "response";
            }
            
            const message = {
                index: i,
                type: messageType,
                message: []
            };
            
            // Extract all content from the element
            console.log(`Processing message ${i + 1}...`);
            
            // Get all child nodes and process them
            const allContent = extractElementContent(element, 0, 30);
            
            // If no content found, try to get raw text content
            if (allContent.length === 0) {
                const rawText = element.textContent.trim();
                if (rawText) {
                    allContent.push({ type: 'text', data: rawText });
                }
            }
            
            message.message = allContent;
            
            // Only add message if it has content
            if (message.message.length > 0) {
                conversation.chats.push(message);
                console.log(`Added message ${i + 1} with ${message.message.length} content items`);
            }
        }
        
        return conversation;
    }
    
    // Main execution
    try {
        console.log("Starting enhanced export...");
        console.log("Page URL:", window.location.href);
        
        const conversation = extractConversation();
        
        if (conversation && conversation.chats.length > 0) {
            console.log(`✅ Conversation extracted successfully!`);
            console.log(`📊 Statistics:`);
            console.log(`   - Total messages: ${conversation.chats.length}`);
            console.log(`   - Title: ${conversation.meta.title}`);
            
            // Log content summary
            let totalContentItems = 0;
            conversation.chats.forEach(chat => {
                totalContentItems += chat.message.length;
            });
            console.log(`   - Total content items: ${totalContentItems}`);
            
            // Save the file
            saveToFile(conversation, 'json', conversation.meta.title);
            console.log("💾 File saved successfully!");
            
            // Log preview
            console.log("\n📋 Preview of extracted data:");
            console.log(safeStringify(conversation).substring(0, 1000) + "...");
        } else {
            console.error("❌ No messages found in conversation");
            console.log("Debug info:");
            console.log("- Document ready state:", document.readyState);
            console.log("- Body classes:", document.body.className);
            
            // Try to provide more debugging info
            const anyContent = document.querySelector("main, [role='main'], .flex-col");
            if (anyContent) {
                console.log("- Found some content container");
                console.log("- Container HTML preview:", anyContent.innerHTML.substring(0, 500));
            }
        }
    } catch (error) {
        console.error("❌ Export failed:", error);
        console.error("Stack trace:", error.stack);
    }
})();