我是一个0代码基础和0开发经验的小白，现在我想完全通过Cursor这款工具开发一个"通过URL将网页...

我是一个0代码基础和0开发经验的小白，现在我想完全通过Cursor这款工具开发一个"通过URL将网页内容按照原始格式保存到Notion"的web应用。

我的设想是这样的：

• 用户打开我这个应用的网址来到应用主页，主页上有个'Notion授权'的按钮，用户点击它之后会进入Notion 的 OAuth 2.0 授权流程，在用户同意授权后，向 Notion 请求获取 access token，此后就能以用户的名义操作 Notion API。
• 然后应用主页还有一个'创建Notion数据库'的按钮，用户点击它之后，系统会通过 notion api 自动在用户的Notion主页里创建一个名字为'Personal database'的数据库，这个数据库要包含这些属性：标题、URL、关键词、摘要、创建时间。
• 应用主页上还要有一个粘贴网址的输入框，输入框下面有两个按钮：'通过AI一键保存'的按钮和'使用元素选择器一件保存'的按钮。'通过AI一键保存'按钮下面要有一行备注：适合用来保存网络文章，'使用元素选择器一件保存'按钮下面也要有一行备注：保存除网络文章外的网页内容。
• 应用主页上需要有一个gemini api key的输入框
• 用户使用'通过AI一键保存'时，流程是这样的：系统获取到这个网址网页里面的全部内容以及原始排版格式（我不知道要用什么技术去实现）→转交给AI语言模型gemini-2.0-flash-exp，gemini-2.0-flash-exp需要做两件事：1.通过精准的系统级提示词让gemini-2.0-flash-exp对接收到的内容进行清洗整理（因为有些网页内容会包含一些导航栏、作者、广告等等信息，这些都是无用的信息，只需要保留网页正文内容（文字、图片、代码块）以及标题即可）；2.通过精准的系统级提示词让gemini-2.0-flash-exp对网页正文内容进行摘要总结，控制在50个字以内，并且提取出5个关键词，这些关键词要跟网页正文的核心内容相关。→转交给系统，系统通过notion api将接收到的数据作为一个新的页面保存到 Notion数据库'Personal database'里，并自动填写"标题、URL、关键词、摘要、创建时间"这些属性的值。可以做一个简单的流程动画来过渡用户等待的时间。
• 用户使用'使用元素选择器一件保存'时，流程是这样的：系统会自动打开用户输入的网址，然后用户会进入一个类似于'浏览器开发者工具'的后台，用户可以使用类似于'元素选择器'这样的工具，在网页上选择其需要的内容（可以多选）当用户选择完毕后需要点确认按钮，当用户确认之后系统会跳转回主页面，并将刚刚用户选择的内容作为一个新的页面保存到Notion数据库'Personal database'里，并自动填写"标题、URL、关键词、摘要、创建时间"这些属性的值。可以做一个简单的流程动画来过渡用户等待的时间。

<notion 官方 api 参考>
<Create a token>
curl --location --request POST 'https://api.notion.com/v1/oauth/token'
--header 'Authorization: Basic '"$BASE64_ENCODED_ID_AND_SECRET"''
--header 'Content-Type: application/json'
--header 'Notion-Version: 2022-06-28'
--data '{
"grant_type": "authorization_code",
"code": "e202e8c9-0990-40af-855f-ff8f872b1ec6",
"redirect_uri": "https://example.com/auth/notion/callback"
}'
</Create a token>

<gemini 官方 api参考>
API_KEY="YOUR_API_KEY"

curl
-X POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent?key=${API_KEY}
-H 'Content-Type: application/json'
-d @<(echo '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "你好"
}
]
}
],
"generationConfig": {
"temperature": 0.5,
"topK": 40,
"topP": 0.95,
"maxOutputTokens": 8192,
"responseMimeType": "text/plain"
}
}')
</gemini 官方 api参考>

以上就是整个项目的开发背景以及一些资料，我再次强调我是0代码基础，我只能借助cursor来开发这个应用，所以我希望你先写出整个项目实现的完整流程方案出来，然后将整个方案拆分成一个个小的任务让Cursor去完成，每次只让cursor去完成一个小的任务，这样它才不会产生幻觉，才能出色的完成任务，然后基于上下文再让cursor去完成下一个小任务，如此迭代下去，cursor就能出色的完成整个应用的开发工作，由于cursor是一款搭载了ai语言模型的工具，所以每个任务你都要提供清晰精准的prompt给到cursor，而不是你告诉我我再去告诉cursor。

3. 实现 Notion OAuth2 授权逻辑：“可以让Cursor自动给你生成一份 .env 文件管理 Notion_CLIENT_ID、Notion_CLIENT_SECRET、以及你的回调URL等。”这一步是不是有些不妥？难道每个使用我应用网站的用户都要去填一遍这些信息吗？如果他们不知道怎么获取这些信息怎么办?而且应用封装过后也没有地方让它们填呀！

好的，我明白了，如图，我在notion开发者平台里创建了公共集成后，它提供了如图所示的数据参数，这些参数我应该用在哪里？

密钥：secret_8eo8zSkt6d2a0CJKMWgm33LwNY60udm8ecYzSDAW03O

id:17ed872b-594c-806f-93eb-00376c2bd922

授权 URL:https://api.notion.com/v1/oauth/authorize?client_id=17ed872b-594c-806f-93eb-00376c2bd922&response_type=code&owner=user&redirect_uri=http%3A%2F%2Flocalhost%3A3000%2Fauth%2Fnotion%2Fcallback

现在整个项目的开发已经进行到“5. “通过AI一键保存”核心流程（网页内容爬取 + 调用Gemini + 写入Notion）”这一步了，但是我在使用“通过AI一键保存”时，系统发出了如图所示的报错，我让Cursor修改了几次代码都没解决这个问题，下面是目前整个项目的文件代码，请你帮我仔细排查出报错原因并给出解决办法，你还可以排查下项目是否存在其他暂未发现的bug

public\index.html：

text
    <div class="input-group">
        <label for="gemini-api-key-input">Gemini API Key:</label>
        <input type="text" id="gemini-api-key-input">
    </div>

    <div class="input-group">
        <label for="web-url-input">输入要保存的网页链接:</label>
        <input type="text" id="web-url-input">
    </div>

    <div>
        <button id="save-by-ai-btn">通过AI一键保存</button>
        <div class="note">适合用来保存网络文章</div>
    </div>

    <div>
        <button id="save-by-selector-btn">使用元素选择器一键保存</button>
        <div class="note">保存除网络文章外的网页内容</div>
    </div>
</div>

<script>
    // 检查授权状态
    async function checkAuthStatus() {
        const response = await fetch('/api/auth/status');
        const { authorized } = await response.json();
        const authBtn = document.getElementById('notion-auth-btn');
        
        if (authorized) {
            authBtn.textContent = 'Notion已授权';
            authBtn.disabled = true;
        }
    }

    // 页面加载时检查授权状态
    checkAuthStatus();

    // Notion授权按钮点击事件
    document.getElementById('notion-auth-btn').addEventListener('click', () => {
        const width = 600;
        const height = 800;
        const left = (screen.width / 2) - (width / 2);
        const top = (screen.height / 2) - (height / 2);
        
        const authWindow = window.open(
            '/auth/notion',
            'Notion Authorization',
            `width=${width},height=${height},left=${left},top=${top}`
        );

        // 监听授权成功消息
        window.addEventListener('message', (event) => {
            if (event.data.type === 'NOTION_AUTH_SUCCESS') {
                checkAuthStatus();
                authWindow.close();
            }
        });
    });

    // 创建数据库按钮点击事件
    document.getElementById('create-notion-db-btn').addEventListener('click', async () => {
        try {
            const response = await fetch('/api/create-database', {
                method: 'POST'
            });
            
            const data = await response.json();
            
            if (data.success) {
                alert(`数据库创建成功！\n点击确定将跳转到新创建的数据库。`);
                window.open(data.database_url, '_blank');
            } else {
                alert('创建失败：' + data.error);
            }
        } catch (error) {
            console.error('Error:', error);
            alert('创建数据库时发生错误，请查看控制台获取详细信息。');
        }
    });

    // 通过AI一键保存按钮点击事件
    document.getElementById('save-by-ai-btn').addEventListener('click', async () => {
        const url = document.getElementById('web-url-input').value;
        const geminiApiKey = document.getElementById('gemini-api-key-input').value;
        
        if (!url || !geminiApiKey) {
            alert('请输入网址和Gemini API Key');
            return;
        }
        
        // 显示加载状态
        const saveBtn = document.getElementById('save-by-ai-btn');
        const originalText = saveBtn.textContent;
        saveBtn.textContent = '保存中...';
        saveBtn.disabled = true;
        
        try {
            const response = await fetch('/api/save-by-ai', {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ url, geminiApiKey })
            });
            
            const data = await response.json();
            
            if (data.success) {
                alert('保存成功！');
                window.open(data.pageUrl, '_blank');
            } else {
                console.error('保存失败:', data);
                alert(`保存失败：${data.error}\n\n${JSON.stringify(data.details, null, 2)}`);
            }
        } catch (error) {
            console.error('Error:', error);
            alert(`保存时发生错误：${error.message}\n请查看控制台获取详细信息。`);
        } finally {
            // 恢复按钮状态
            saveBtn.textContent = originalText;
            saveBtn.disabled = false;
        }
    });
</script>

routes\saveByAi.js：

const express = require('express');
const router = express.Router();
const puppeteer = require('puppeteer');
const { GoogleGenerativeAI } = require('@google/generative-ai');
const axios = require('axios');

// 导入 tokens
const { tokens } = require('../app');

// Gemini系统提示词
const SYSTEM_PROMPT = `你是一个网页内容提取助手。请帮我完成以下任务：

1. 清洗网页内容，只保留:
   • 主要文字内容
   • 图片(用markdown格式)
   • 代码块
   • 重要标题
2. 生成50字以内的中文摘要
3. 生成5个与核心内容相关的关键词(用逗号分隔)

请按以下格式返回：
---TITLE---
{网页标题}
---KEYWORDS---
{关键词1},{关键词2},{关键词3},{关键词4},{关键词5}
---SUMMARY---
{50字摘要}
---CONTENT---
{清洗后的正文内容}`;

// 获取网页内容
async function fetchWebContent(url) {
let browser;
try {
browser = await puppeteer.launch({
headless: 'new',
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
const page = await browser.newPage();

text
    // 设置页面加载超时
    await page.setDefaultNavigationTimeout(30000);
    
    // 添加更多的页面错误监听
    page.on('error', err => {
        console.error('Page error:', err);
    });
    
    page.on('pageerror', err => {
        console.error('Page error:', err);
    });
    
    console.log('正在访问页面:', url);
    await page.goto(url, { 
        waitUntil: 'networkidle0',
        timeout: 30000
    });
    
    console.log('页面加载完成，开始提取内容');
    const content = await page.evaluate(() => {
        // 移除干扰元素
        document.querySelectorAll('script, style, nav, footer, iframe, .ad').forEach(el => el.remove());
        
        return {
            title: document.title,
            content: document.body.innerHTML
        };
    });
    
    return content;
} catch (error) {
    console.error('Error in fetchWebContent:', {
        message: error.message,
        stack: error.stack
    });
    throw new Error(`获取网页内容失败: ${error.message}`);
} finally {
    if (browser) {
        await browser.close();
    }
}

}

// 调用Gemini API处理内容
async function processWithGemini(content, apiKey) {
try {
console.log('初始化 Gemini API...');
const genAI = new GoogleGenerativeAI(apiKey);
const model = genAI.getGenerativeModel({
model: "gemini-2.0-flash-exp", // 改回 flash-exp 模型
generationConfig: {
temperature: 0.5, // 降低温度以获得更稳定的输出
maxOutputTokens: 2048, // 减小输出token限制
topK: 40,
topP: 0.95,
},
});

text
    console.log('准备发送内容到 Gemini...');
    // 进一步限制内容长度，因为flash模型通常接受更短的输入
    const truncatedContent = content.substring(0, 15000); // 减小输入长度限制
    
    const prompt = {
        contents: [{
            parts: [{ text: `${SYSTEM_PROMPT}\n\n${truncatedContent}` }]
        }]
    };

    console.log('调用 Gemini API...');
    const result = await model.generateContent(prompt);
    console.log('Gemini API 响应成功');
    
    const response = await result.response;
    const text = response.text();
    
    // 解析Gemini返回的内容
    const sections = text.split('---').filter(Boolean);
    const parsed = {};
    
    sections.forEach(section => {
        const [type, ...content] = section.trim().split('\n');
        parsed[type.toLowerCase()] = content.join('\n').trim();
    });
    
    // 确保所有必要的字段都存在
    const defaultData = {
        title: '未知标题',
        keywords: '关键词解析失败',
        summary: '摘要生成失败',
        content: '内容处理失败'
    };
    
    return { ...defaultData, ...parsed };
    
} catch (error) {
    console.error('Gemini API 处理失败:', {
        error: error,
        message: error.message,
        details: error.details,
        apiKey: apiKey ? '已提供' : '未提供'
    });
    
    // 抛出更详细的错误
    throw new Error(`Gemini API 处理失败: ${error.message}`);
}

}

// 创建Notion页面
async function createNotionPage(data, databaseId, notionToken) {
const response = await axios.post('https://api.notion.com/v1/pages', {
parent: { database_id: databaseId },
properties: {
Title: {
title: [{ text: { content: data.title } }]
},
URL: {
url: data.url
},
Keywords: {
rich_text: [{ text: { content: data.keywords } }]
},
Summary: {
rich_text: [{ text: { content: data.summary } }]
},
CreatedTime: {
date: { start: new Date().toISOString() }
}
}
}, {
headers: {
'Authorization': Bearer ${notionToken},
'Notion-Version': '2022-06-28',
'Content-Type': 'application/json'
}
});

text
// 添加页面内容
await axios.patch(`https://api.notion.com/v1/blocks/${response.data.id}/children`, {
    children: convertToNotionBlocks(data.content)
}, {
    headers: {
        'Authorization': `Bearer ${notionToken}`,
        'Notion-Version': '2022-06-28',
        'Content-Type': 'application/json'
    }
});

return response.data;

}

// 将内容转换为Notion blocks
function convertToNotionBlocks(content) {
// 这里需要根据实际内容格式进行转换
// 示例：将markdown转换为Notion blocks
return [{
object: 'block',
type: 'paragraph',
paragraph: {
rich_text: [{ type: 'text', text: { content } }]
}
}];
}

// 主路由处理
router.post('/save-by-ai', async (req, res) => {
const { url, geminiApiKey } = req.body;

text
// 验证 API Key
if (!geminiApiKey) {
    return res.status(400).json({
        success: false,
        error: '请提供有效的 Gemini API Key'
    });
}

// 验证 URL
if (!url) {
    return res.status(400).json({
        success: false,
        error: '请提供有效的URL'
    });
}

try {
    console.log('开始处理URL:', url);
    
    // 获取网页内容
    const webContent = await fetchWebContent(url);
    console.log('成功获取网页内容，长度:', webContent.content.length);
    
    // 处理内容
    console.log('开始调用 Gemini API...');
    const processedContent = await processWithGemini(webContent.content, geminiApiKey);
    console.log('Gemini API 处理完成');
    
    // 从请求对象中获取 tokens
    const notionToken = req.tokens ? Array.from(req.tokens.values())[0] : null;
    // 添加 token 检查的日志
    console.log('Notion Token:', notionToken ? '存在' : '不存在');
    
    if (!notionToken) {
        return res.status(401).json({
            success: false,
            error: '未找到 Notion 授权令牌，请先完成授权'
        });
    }

    // 获取数据库 ID
    console.log('开始获取 Notion 数据库信息');
    const dbResponse = await axios.post('https://api.notion.com/v1/search', {
        filter: {
            property: 'object',
            value: 'database'
        }
    }, {
        headers: {
            'Authorization': `Bearer ${notionToken}`,
            'Notion-Version': '2022-06-28'
        }
    });
    
    const database = dbResponse.data.results.find(db => 
        db.title[0]?.plain_text === 'Personal database'
    );
    
    if (!database) {
        throw new Error('未找到 Personal database，请先创建数据库');
    }
    
    console.log('开始创建 Notion 页面');
    const notionPage = await createNotionPage({
        title: webContent.title,
        url,
        keywords: processedContent.keywords,
        summary: processedContent.summary,
        content: processedContent.content
    }, database.id, notionToken);
    
    console.log('保存成功');
    res.json({
        success: true,
        pageUrl: notionPage.url
    });
} catch (error) {
    console.error('处理失败:', {
        error: error,
        message: error.message,
        url: url,
        stack: error.stack
    });
    
    // 返回更友好的错误信息
    res.status(500).json({
        success: false,
        error: '保存失败: ' + (error.message || '未知错误'),
        details: {
            type: error.name,
            message: error.message,
            url: url
        }
    });
}

});

module.exports = router;

.env：

NOTION_CLIENT_ID=17ed872b-594c-806f-93eb-00376c2bd922
NOTION_CLIENT_SECRET=secret_8eo8zSkt6d2a0CJKMWgm33LwNY60udm8ecYzSDAW03O
NOTION_REDIRECT_URI=http://localhost:3000/auth/notion/callback

app.js：

const express = require('express');
const axios = require('axios');
require('dotenv').config();

const app = express();
const port = 3000;

// 将 tokens 声明移到顶部
const tokens = new Map();

// 导出 tokens
module.exports = { tokens, app };

// 设置静态文件目录
app.use(express.static('public'));

// 添加 express.json() 中间件来解析 JSON 请求体
app.use(express.json());

// Notion授权路由
app.get('/auth/notion', (req, res) => {
// Notion OAuth2授权URL
const notionAuthUrl = 'https://api.notion.com/v1/oauth/authorize';
const scopes = [
'read_user',
'read_databases',
'write_databases',
'read_pages',
'write_pages',
'create_pages'
].join(' ');

const authUrl = ${notionAuthUrl}?client_id=${process.env.NOTION_CLIENT_ID}&redirect_uri=${encodeURIComponent(process.env.NOTION_REDIRECT_URI)}&response_type=code&owner=user&scope=${encodeURIComponent(scopes)};

res.redirect(authUrl);
});

// Notion回调路由
app.get('/auth/notion/callback', async (req, res) => {
const { code } = req.query;

if (!code) {
return res.status(400).send('Authorization code not found');
}

try {
// 使用authorization code换取access token
const response = await axios.post('https://api.notion.com/v1/oauth/token', {
grant_type: 'authorization_code',
code: code,
redirect_uri: process.env.NOTION_REDIRECT_URI
}, {
headers: {
'Authorization': Basic ${Buffer.from(${process.env.NOTION_CLIENT_ID}:${process.env.NOTION_CLIENT_SECRET}).toString('base64')},
'Content-Type': 'application/json'
}
});

text
const { access_token, workspace_id } = response.data;

// 存储token（这里简单存储在内存中，实际应该存入数据库）
tokens.set(workspace_id, access_token);

// 修改前端页面，显示授权成功
res.send(`
  <script>
    window.opener && window.opener.postMessage({ type: 'NOTION_AUTH_SUCCESS' }, '*');
    window.close();
  </script>
  <h1>授权成功！请关闭此窗口。</h1>
`);

} catch (error) {
console.error('Error exchanging code for token:', error.response?.data || error.message);
res.status(500).send('Authorization failed');
}
});

// 获取授权状态的API
app.get('/api/auth/status', (req, res) => {
res.json({ authorized: tokens.size > 0 });
});

// 创建数据库的路由
app.post('/api/create-database', async (req, res) => {
try {
const access_token = Array.from(tokens.values())[0];

text
    if (!access_token) {
        return res.status(401).json({ 
            success: false, 
            error: '未找到有效的访问令牌，请先进行Notion授权' 
        });
    }

    // 获取用户信息，包括默认工作区
    const userResponse = await axios.get('https://api.notion.com/v1/users/me', {
        headers: {
            'Authorization': `Bearer ${access_token}`,
            'Notion-Version': '2022-06-28'
        }
    });

    // 获取工作区的根页面
    const searchResponse = await axios.post('https://api.notion.com/v1/search', {
        filter: {
            property: 'object',
            value: 'page'
        },
        sort: {
            direction: 'descending',
            timestamp: 'last_edited_time'
        }
    }, {
        headers: {
            'Authorization': `Bearer ${access_token}`,
            'Notion-Version': '2022-06-28',
            'Content-Type': 'application/json'
        }
    });

    // 找到工作区根页面（通常是第一个页面）
    const rootPage = searchResponse.data.results.find(page => 
        page.parent.type === 'workspace' && 
        page.parent.workspace === true
    );

    if (!rootPage) {
        return res.status(404).json({
            success: false,
            error: '未找到工作区根页面'
        });
    }

    // 创建数据库
    const response = await axios.post('https://api.notion.com/v1/databases', {
        parent: {
            type: "page_id",
            page_id: rootPage.id
        },
        icon: {
            type: "emoji",
            emoji: "📝"
        },
        title: [
            {
                type: "text",
                text: {
                    content: "Personal database"
                }
            }
        ],
        properties: {
            "Title": {
                "title": {}
            },
            "URL": {
                "url": {}
            },
            "Keywords": {
                "rich_text": {}
            },
            "Summary": {
                "rich_text": {}
            },
            "CreatedTime": {
                "date": {}
            }
        }
    }, {
        headers: {
            'Authorization': `Bearer ${access_token}`,
            'Notion-Version': '2022-06-28',
            'Content-Type': 'application/json'
        }
    });

    // 返回成功信息和数据库链接
    const databaseId = response.data.id;
    const databaseUrl = `https://notion.so/${databaseId.replace(/-/g, '')}`;
    
    res.json({ 
        success: true, 
        database_id: databaseId,
        database_url: databaseUrl,
        message: '数据库创建成功！'
    });

} catch (error) {
    console.error('创建数据库失败:', {
        message: error.message,
        response: error.response?.data,
        status: error.response?.status
    });
    res.status(500).json({ 
        success: false, 
        error: error.response?.data?.message || error.message,
        details: error.response?.data
    });
}

});

app.use((req, res, next) => {
req.tokens = tokens;
next();
});

const saveByAiRouter = require('./routes/saveByAi');
app.use('/api', saveByAiRouter);

app.listen(port, () => {
console.log(服务器运行在 http://localhost:${port});
});

package.json：

{
"name": "my-express-app",
"version": "1.0.0",
"description": "A simple Express web application",
"main": "app.js",
"scripts": {
"start": "node app.js",
"test": "echo "Error: no test specified" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
"@google/generative-ai": "^0.21.0",
"axios": "^1.7.9",
"dotenv": "^16.4.7",
"express": "^4.21.2",
"puppeteer": "^24.1.0"
}
}

<gemini 官方 api参考>
API_KEY="YOUR_API_KEY"

curl
-X POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash-exp:generateContent?key=${API_KEY}
-H 'Content-Type: application/json'
-d @<(echo '{
"contents": [
{
"role": "user",
"parts": [
{
"text": "你好"
}
]
}
],
"generationConfig": {
"temperature": 0.5,
"topK": 40,
"topP": 0.95,
"maxOutputTokens": 8192,
"responseMimeType": "text/plain"
}
}')
</gemini 官方 api参考>

问题还是没得到解决，还是同样的报错，下面是cursor修改后的代码

const express = require('express');
const router = express.Router();
const puppeteer = require('puppeteer');
const { GoogleGenerativeAI } = require('@google/generative-ai');
const axios = require('axios');

// 导入 tokens
const { tokens } = require('../app');

// Gemini系统提示词
const SYSTEM_PROMPT = `你是一个网页内容提取助手。请帮我完成以下任务：

1. 清洗网页内容，只保留:
   • 主要文字内容
   • 图片(用markdown格式)
   • 代码块
   • 重要标题
2. 生成50字以内的中文摘要
3. 生成5个与核心内容相关的关键词(用逗号分隔)

请按以下格式返回：
---TITLE---
{网页标题}
---KEYWORDS---
{关键词1},{关键词2},{关键词3},{关键词4},{关键词5}
---SUMMARY---
{50字摘要}
---CONTENT---
{清洗后的正文内容}`;

// 获取网页内容
async function fetchWebContent(url) {
let browser;
try {
browser = await puppeteer.launch({
headless: 'new',
args: ['--no-sandbox', '--disable-setuid-sandbox']
});
const page = await browser.newPage();

text
    // 设置页面加载超时
    await page.setDefaultNavigationTimeout(30000);
    
    // 添加更多的页面错误监听
    page.on('error', err => {
        console.error('Page error:', err);
    });
    
    page.on('pageerror', err => {
        console.error('Page error:', err);
    });
    
    console.log('正在访问页面:', url);
    await page.goto(url, { 
        waitUntil: 'networkidle0',
        timeout: 30000
    });
    
    console.log('页面加载完成，开始提取内容');
    const content = await page.evaluate(() => {
        // 移除干扰元素
        document.querySelectorAll('script, style, nav, footer, iframe, .ad').forEach(el => el.remove());
        
        // 获取处理后的HTML
        const cleanedHtml = document.body.innerHTML;
        console.log('清理后的HTML内容:', cleanedHtml); // 在浏览器控制台输出
        
        return {
            title: document.title,
            content: cleanedHtml
        };
    });
    
    // 在Node.js控制台也输出内容
    console.log('获取到的页面标题:', content.title);
    console.log('获取到的HTML内容长度:', content.content.length);
    console.log('HTML内容预览(前500字符):', content.content.substring(0, 500));
    
    return content;
} catch (error) {
    console.error('Error in fetchWebContent:', {
        message: error.message,
        stack: error.stack
    });
    throw new Error(`获取网页内容失败: ${error.message}`);
} finally {
    if (browser) {
        await browser.close();
    }
}

}

// 调用Gemini API处理内容
async function processWithGemini(content, apiKey) {
try {
console.log('初始化 Gemini API...');
const genAI = new GoogleGenerativeAI(apiKey);
const model = genAI.getGenerativeModel({
model: "gemini-2.0-flash-exp",
generationConfig: {
temperature: 0.5,
maxOutputTokens: 2048,
topK: 40,
topP: 0.95,
},
});

text
    console.log('准备发送内容到 Gemini...');
    // 限制内容长度
    const truncatedContent = content.substring(0, 15000);
    
    const prompt = {
        contents: [{
            parts: [{ text: `${SYSTEM_PROMPT}\n\n${truncatedContent}` }]
        }]
    };

    console.log('调用 Gemini API...');
    const geminiResponse = await model.generateContent(prompt);
    console.log('Gemini API 响应成功, response =', geminiResponse);

    // 从 geminiResponse.candidates[0].output 获取文本
    const text = geminiResponse.candidates?.[0]?.output || '';
    console.log('获取到的文本:', text);

    // 解析返回的文本
    const sections = text.split('---').filter(Boolean);
    const parsed = {};
    
    sections.forEach(section => {
        const [type, ...contentLines] = section.trim().split('\n');
        parsed[type.toLowerCase()] = contentLines.join('\n').trim();
    });

    // 确保所有必要的字段都存在
    const defaultData = {
        title: '未知标题',
        keywords: '关键词解析失败',
        summary: '摘要生成失败',
        content: '内容处理失败'
    };
    
    const processedResult = { ...defaultData, ...parsed };
    console.log('解析后的结果:', processedResult);
    
    return processedResult;
    
} catch (error) {
    console.error('Gemini API 处理失败:', {
        error: error,
        message: error.message,
        stack: error.stack
    });
    
    throw new Error(`Gemini API 处理失败: ${error.message}`);
}

}

// 创建Notion页面
async function createNotionPage(data, databaseId, notionToken) {
const response = await axios.post('https://api.notion.com/v1/pages', {
parent: { database_id: databaseId },
properties: {
Title: {
title: [{ text: { content: data.title } }]
},
URL: {
url: data.url
},
Keywords: {
rich_text: [{ text: { content: data.keywords } }]
},
Summary: {
rich_text: [{ text: { content: data.summary } }]
},
CreatedTime: {
date: { start: new Date().toISOString() }
}
}
}, {
headers: {
'Authorization': Bearer ${notionToken},
'Notion-Version': '2022-06-28',
'Content-Type': 'application/json'
}
});

text
// 添加页面内容
await axios.patch(`https://api.notion.com/v1/blocks/${response.data.id}/children`, {
    children: convertToNotionBlocks(data.content)
}, {
    headers: {
        'Authorization': `Bearer ${notionToken}`,
        'Notion-Version': '2022-06-28',
        'Content-Type': 'application/json'
    }
});

return response.data;

}

// 将内容转换为Notion blocks
function convertToNotionBlocks(content) {
// 这里需要根据实际内容格式进行转换
// 示例：将markdown转换为Notion blocks
return [{
object: 'block',
type: 'paragraph',
paragraph: {
rich_text: [{ type: 'text', text: { content } }]
}
}];
}

// 主路由处理
router.post('/save-by-ai', async (req, res) => {
const { url, geminiApiKey } = req.body;

text
// 验证 API Key
if (!geminiApiKey) {
    return res.status(400).json({
        success: false,
        error: '请提供有效的 Gemini API Key'
    });
}

// 验证 URL
if (!url) {
    return res.status(400).json({
        success: false,
        error: '请提供有效的URL'
    });
}

try {
    console.log('开始处理URL:', url);
    
    // 获取网页内容
    const webContent = await fetchWebContent(url);
    console.log('成功获取网页内容，长度:', webContent.content.length);
    
    // 处理内容
    console.log('开始调用 Gemini API...');
    const processedContent = await processWithGemini(webContent.content, geminiApiKey);
    console.log('Gemini API 处理完成');
    
    // 从请求对象中获取 tokens
    const notionToken = req.tokens ? Array.from(req.tokens.values())[0] : null;
    // 添加 token 检查的日志
    console.log('Notion Token:', notionToken ? '存在' : '不存在');
    
    if (!notionToken) {
        return res.status(401).json({
            success: false,
            error: '未找到 Notion 授权令牌，请先完成授权'
        });
    }

    // 获取数据库 ID
    console.log('开始获取 Notion 数据库信息');
    const dbResponse = await axios.post('https://api.notion.com/v1/search', {
        filter: {
            property: 'object',
            value: 'database'
        }
    }, {
        headers: {
            'Authorization': `Bearer ${notionToken}`,
            'Notion-Version': '2022-06-28'
        }
    });
    
    const database = dbResponse.data.results.find(db => 
        db.title[0]?.plain_text === 'Personal database'
    );
    
    if (!database) {
        throw new Error('未找到 Personal database，请先创建数据库');
    }
    
    console.log('开始创建 Notion 页面');
    const notionPage = await createNotionPage({
        title: webContent.title,
        url,
        keywords: processedContent.keywords,
        summary: processedContent.summary,
        content: processedContent.content
    }, database.id, notionToken);
    
    console.log('保存成功');
    res.json({
        success: true,
        pageUrl: notionPage.url
    });
} catch (error) {
    console.error('处理失败:', {
        error: error,
        message: error.message,
        url: url,
        stack: error.stack
    });
    
    // 返回更友好的错误信息
    res.status(500).json({
        success: false,
        error: '保存失败: ' + (error.message || '未知错误'),
        details: {
            type: error.name,
            message: error.message,
            url: url
        }
    });
}

});

module.exports = router;