Upload 58 files

XPostArchiver-clean-upload-20260711-225630/.cargo/config.toml

@@ -0,0 +1,9 @@
+[source.crates-io]
+replace-with = "rsproxy-sparse"
+
+[source.rsproxy-sparse]
+registry = "sparse+https://rsproxy.cn/index/"
+
+[net]
+git-fetch-with-cli = true
+

XPostArchiver-clean-upload-20260711-225630/.gitignore

@@ -0,0 +1,23 @@
+/target/
+/build/
+/dist/
+/backups/
+
+*.db
+*.sqlite
+*.sqlite3
+*.db-wal
+*.db-shm
+
+*.log
+*.tmp
+*.part
+
+.env
+.env.*
+secrets.*
+credentials.*
+
+.DS_Store
+Thumbs.db
+

XPostArchiver-clean-upload-20260711-225630/CHANGELOG.md

@@ -0,0 +1,56 @@
+# 变更记录
+
+## [未发布]
+
+### 新增
+
+- 初始化 Rust + Slint + Cargo 项目。
+- 配置 RsProxy Cargo 镜像。
+- 添加最小 Slint 中文窗口。
+- 添加 Tokio 后台运行时骨架。
+- 添加统一错误类型和脱敏日志骨架。
+- 添加 SQLx 初始迁移草案。
+- 添加数据库新建/打开服务与非敏感设置保存。
+- 添加媒体、导出、日志、备份和临时下载目录选择与保存。
+- 添加数据库和数据目录位于系统盘时的非阻断提醒。
+- 添加数据库完整性检查和手动备份入口。
+- 将主界面整理为数据库、归档内容、准备采集三步配置流程。
+- 添加保存媒体文件/只保存文本选项，并兼容旧配置文件。
+- 添加 X API Bearer Token 的系统密钥库保存、状态显示和清除入口。
+- 添加 X API Bearer Token 联网校验与 mock 测试。
+- 添加公开账号查询入口，并将账号基础信息保存到数据库。
+- 添加采集任务创建入口，并将任务记录写入数据库。
+- 添加一页公开帖子拉取入口，基于任务 ID 调用官方 X API 拉取少量公开帖子。
+- 将公开帖子基础字段保存/更新到 posts 表，并更新采集任务计数。
+- 添加分页游标保存和断点续采骨架，下一页拉取会从 crawl_checkpoints 继续。
+- 添加 X API 媒体元数据解析，并保存 media 与 post_media 关联。
+- 添加媒体文件下载骨架，将待保存媒体下载到归档内容目录并更新下载状态。
+- 添加自动连续采集 3 页骨架，并在每页之间保守等待。
+- 将自动连续采集改为后台线程执行，避免采集期间阻塞主界面。
+- 添加自动连续采集页数上限与每页等待秒数输入；页数上限为 0 时持续采集到末页或手动停止。
+- 添加自动采集停止入口，并在停止后将任务状态写回数据库。
+- 添加最近采集任务列表查询与刷新入口。
+- 为主窗口添加最小尺寸约束，改善自由缩放体验。
+- 创建任务或刷新任务列表后自动填入最新任务 ID。
+- 将 Bearer Token 输入框改为密码遮罩输入。
+- 将采集任务状态在界面中显示为中文，并显示失败原因。
+- X API 拉取失败时写回任务失败状态、错误次数和错误信息。
+- 添加按任务 ID 预览已保存帖子的入口。
+- 添加将任务帖子导出为 Markdown 文本索引的入口。
+- 添加失败媒体重试下载入口。
+- 自动采集运行中阻止重复启动第二个自动采集任务。
+- 添加后期优化路线文档。
+- 添加维护接手文档，方便后续 AI 或开发者阅读维护。
+- 为主界面添加滚动区域，避免功能区超出窗口后无法访问。
+- 添加数据库迁移集成测试。
+- 通过 `cargo fmt --all -- --check`、`cargo check`、`cargo clippy --all-targets --all-features -- -D warnings` 和 `cargo test --all`。
+- 实际运行 `cargo run` 并启动最小 Slint 窗口。
+- 将项目文档从旧技术路线修订为 Rust 技术路线。
+
+### 环境
+
+- Rust：1.97.0
+- Cargo：1.97.0
+- MSVC Build Tools：Visual Studio Build Tools 2022，17.14.35
+- Windows SDK：10.0.26100.0
+

XPostArchiver-clean-upload-20260711-225630/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "xpost-archiver"
+version = "0.1.0"
+edition = "2024"
+build = "build.rs"
+
+[dependencies]
+slint = "1.13"
+tokio = { version = "1.47", features = ["rt-multi-thread", "macros", "sync", "time", "fs"] }
+tokio-util = { version = "0.7", features = ["rt"] }
+reqwest = { version = "0.12", default-features = false, features = ["json", "stream", "rustls-tls"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+sqlx = { version = "0.8", default-features = false, features = ["runtime-tokio-rustls", "sqlite", "migrate", "macros", "chrono", "json"] }
+rfd = "0.15"
+keyring = "3.6"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+tracing-appender = "0.2"
+thiserror = "2.0"
+anyhow = "1.0"
+chrono = { version = "0.4", features = ["serde"] }
+url = "2.5"
+uuid = { version = "1.18", features = ["v4", "serde"] }
+rust_xlsxwriter = "0.90"
+csv = "1.3"
+sha2 = "0.10"
+directories = "6.0"
+bytes = "1.10"
+futures-util = "0.3"
+
+[build-dependencies]
+slint-build = "1.13"
+
+[dev-dependencies]
+tempfile = "3.21"
+wiremock = "0.6"
+pretty_assertions = "1.4"
+

XPostArchiver-clean-upload-20260711-225630/DECISIONS.md

@@ -0,0 +1,30 @@
+# 技术决策记录
+
+## ADR-001：纯 Rust 桌面架构
+
+项目采用 Rust stable、Edition 2024、Slint、Tokio、reqwest、SQLx、SQLite、keyring、tracing 和 Inno Setup。不得引入 Python、JavaScript、TypeScript、Node.js、Electron、Tauri、WebView、Docker、云数据库或浏览器自动化。
+
+## ADR-002：Slint 作为桌面界面
+
+Slint 提供纯 Rust 桌面 UI，避免网页前端栈。界面运行在主线程；后台任务通过消息通道或 Slint 安全事件循环返回结果，不从后台线程直接修改控件。
+
+## ADR-003：SQLx 运行时查询与迁移
+
+使用 SQLite + SQLx migrations。第一版优先使用运行时 SQL，避免构建期依赖用户数据库或 SQLx 离线元数据。迁移前必须备份用户数据库。
+
+## ADR-004：仅使用官方允许的 X API
+
+不模拟登录，不收集账号密码或 Cookie，不绕过验证码、保护账号、付费权限、访问控制和频率限制。“尽可能完整”仅指 API 当前实际可访问并返回的范围。
+
+## ADR-005：严格分离开发、安装和数据目录
+
+正式程序不得依赖开发路径。安装目录仅放程序文件；数据库、媒体、导出、日志和备份由用户分别选择。配置只保存路径和非敏感偏好，凭据由 keyring 保存。
+
+## ADR-006：数据语义
+
+所有 X ID 按字符串保存；内部时间统一使用 UTC；接口未提供的数值使用 NULL，不用 0 冒充未知。原始 JSON 用于兼容和审计，但默认日志不记录完整响应。
+
+## ADR-007：后台任务和受控写入
+
+Tokio 运行在后台工作线程。网络、分页、导出和媒体下载不阻塞 Slint 主线程；SQLite 使用受控写入队列或单写者策略，防止大量任务无序写入。
+

XPostArchiver-clean-upload-20260711-225630/PUBLIC_SAFETY_NOTES.md

@@ -0,0 +1,8 @@
+# Public Safety Notes
+
+This project is designed to use the official X API only. It does not include credentials, cookies, databases, local archives, logs, or media files.
+
+Bearer Tokens are expected to be stored by the running app in the operating system keyring, not in this source package.
+
+Do not upload your own generated databases, archived media, logs, or keyring exports.
+

XPostArchiver-clean-upload-20260711-225630/README.md

@@ -0,0 +1,30 @@
+# X公开帖子归档器
+
+内部英文标识：`XPostArchiver`。
+
+这是纯本地 Windows 桌面软件项目，采用 Rust + Slint。软件计划通过 X 官方允许的 API，在当前权限、额度和平台可访问范围内尽可能归档公开帖子。
+
+> 本软件会在当前X API权限、账户额度和平台可访问范围内，尽可能完整地获取公开内容。实际可获取数量和时间范围由X平台返回结果决定。
+
+## 技术路线
+
+- Rust stable，Edition 2024
+- Slint 桌面界面
+- Tokio 后台运行时
+- reqwest + rustls 网络请求
+- SQLx + SQLite + SQLx migrations
+- keyring 保存 Windows 凭据
+- tracing 日志
+- rust_xlsxwriter、csv、serde_json 导出
+- Inno Setup 安装程序
+
+## 目录边界
+
+- 开发源码目录：`<project-directory>`，仅供开发，不得写死到正式程序。
+- 安装目录：由最终用户在安装时选择。
+- 数据目录：数据库、媒体、导出、日志和备份分别由用户选择，禁止默认混入开发目录或安装目录。
+
+## 当前状态
+
+第零阶段进行中。Rust 工具链、Cargo、MSVC Build Tools 和 Windows SDK 已安装；最小 Slint 窗口和基础架构正在验收。
+

XPostArchiver-clean-upload-20260711-225630/UPLOAD_MANIFEST.md

@@ -0,0 +1,29 @@
+# Clean Upload Package Manifest
+
+This package is intended for uploading to Hugging Face or another public code hosting platform.
+
+Included:
+
+- Rust source code under `src/`
+- Slint UI under `ui/`
+- SQLite migrations under `migrations/`
+- Tests under `tests/`
+- Public documentation under `docs/`
+- Cargo project files
+- Public changelog and version history
+
+Excluded:
+
+- `.git/`
+- `target/`
+- `backups/`
+- local release staging folders
+- local database files
+- logs
+- media archives
+- system keyring credentials
+- local environment reports
+- machine-specific project state/inventory files
+
+Before public release, review README and docs once more for wording and platform policy fit.
+

XPostArchiver-clean-upload-20260711-225630/VERSION_HISTORY.md

@@ -0,0 +1,31 @@
+# Version History
+
+This file is generated for the clean upload package. It keeps commit hashes and public commit messages only. The `.git` directory is intentionally not included, so local author identity and repository metadata are not packaged.
+
+- `c87d83e` chore: initialize Rust and Slint application architecture
+- `9d0fe80` feat: add database selection and migration foundation
+- `9a060a2` feat: add configurable data directories
+- `465a24c` feat: warn for system drive data paths
+- `e565f9e` feat: add database maintenance actions
+- `97b3c98` feat: add first-run configuration flow
+- `dcd036c` feat: add local X API credential storage
+- `2f2365f` feat: validate X API bearer token
+- `90c0a0b` feat: add public account lookup
+- `977b16d` feat: add crawl task creation skeleton
+- `222e9fb` feat: fetch first page of public posts
+- `39c8fc4` feat: continue public post pagination
+- `eb2e698` feat: store public post media metadata
+- `78f25df` feat: download archived media files
+- `8f6ad1b` feat: add automatic paged crawl skeleton
+- `485e471` feat: run automatic crawl in background
+- `19031e1` feat: add automatic crawl stop and limits
+- `7e2b770` feat: persist stopped crawl status
+- `1a7ce21` feat: show recent crawl tasks
+- `392a4c8` feat: improve resizable window constraints
+- `f4bc9f6` feat: autofill selected crawl task id
+- `e8e4fca` feat: mask bearer token input
+- `39c3741` feat: show crawl status labels and errors
+- `d46776e` feat: preview and export archived posts
+- `c1676f0` feat: retry failed media and guard auto crawl
+- `57275ed` docs: add maintenance and optimization notes
+

XPostArchiver-clean-upload-20260711-225630/build.rs

@@ -0,0 +1,4 @@
+fn main() {
+    slint_build::compile("ui/app-window.slint").expect("failed to compile Slint UI");
+}
+

XPostArchiver-clean-upload-20260711-225630/docs/01-需求规格说明.md

@@ -0,0 +1,38 @@
+# 需求规格说明
+
+## 软件目标
+
+用户输入 `@username`、用户名或 X 账号主页链接，经确认后通过 X 官方允许的 API 创建任务，把接口实际返回的公开帖子保存到用户选择的 SQLite 数据库，并在本地浏览、筛选和导出。
+
+## 支持范围
+
+- 查询并确认公开账号。
+- 保存原创、回复、转发、引用及其原始引用关系。
+- 保存接口返回的正文、长文信息、互动指标和媒体元数据。
+- 分页、去重、断点续传、增量更新、暂停、继续和停止。
+- 可选媒体下载及失败重试。
+- 本地搜索、筛选和排序。
+- 导出 Excel、CSV、JSON、JSON Lines、Markdown 和 TXT。
+
+## 不能保证
+
+软件不保证获得已删除、受保护、无权访问、被平台隐藏、超出 API 权限或额度、接口没有返回的帖子和媒体，也不保证取得账号创建以来绝对完整的历史内容。
+
+界面统一显示：
+
+> 本软件会在当前X API权限、账户额度和平台可访问范围内，尽可能完整地获取公开内容。实际可获取数量和时间范围由X平台返回结果决定。
+
+## 核心约束
+
+- 用户确认目标账号后才能采集。
+- 不绕过登录、验证码、付费、访问控制和频率限制。
+- 不要求 X 账号密码，不窃取 Cookie。
+- X ID 必须按字符串保存；时间内部统一为 UTC。
+- 未返回字段使用空值，并区分明确为 0、未提供、权限不足和解析失败。
+- 数据库路径失效时不得自动建立替代空库。
+- 正式程序不得依赖开发目录。
+
+## 验收原则
+
+每阶段必须运行相关测试并实际启动检查。测试失败、环境缺失或未实际运行时，不得宣称阶段完成或软件正常运行。
+

XPostArchiver-clean-upload-20260711-225630/docs/02-技术架构.md

@@ -0,0 +1,33 @@
+# 技术架构
+
+## 技术栈
+
+项目使用 Rust stable、Edition 2024、Slint、Tokio、reqwest + rustls、serde、SQLx + SQLite + SQLx migrations、rfd、keyring、tracing、thiserror、anyhow、chrono、url、uuid、rust_xlsxwriter、csv、sha2、directories、Inno Setup。
+
+## 模块分层
+
+- `ui`：Slint 界面文件。
+- `ui_bridge`：Rust 与 Slint 的回调、模型和通知桥接。
+- `api`：官方 X API 客户端、认证、账号、帖子、分页、限流、响应和错误分类。
+- `database`：SQLx 连接、迁移、仓储、账号、帖子、任务、断点和媒体访问。
+- `domain`：账号、帖子、媒体、采集任务和断点领域模型。
+- `tasks`：Tokio 运行时、命令、事件、采集工作者、单一数据库写入任务、媒体工作者和取消控制。
+- `services`：账号、采集、媒体、数据库和导出应用服务。
+- `exporters`：Excel、CSV、JSON、Markdown、TXT。
+- `config`：非敏感设置和路径。
+- `security`：Windows 凭据保存和脱敏。
+- `logging`：tracing 日志和轮转。
+- `utils`：文件名、时间、URL 和磁盘工具。
+
+## 线程与异步
+
+Slint 界面运行在主线程。Tokio 后台运行时处理 HTTP、分页、媒体下载、导出和数据库写入命令。后台任务不得直接修改 Slint 控件；必须通过消息通道或 Slint 安全事件循环返回结果。
+
+## 数据库并发
+
+使用 SQLx 连接用户选择的 SQLite 文件。采用多个受控读取连接和单一数据库写入任务。每页帖子在事务中保存，提交成功后才更新断点。
+
+## 禁止方案
+
+不得引入覆盖指令禁止的跨语言脚本栈、网页前端栈、浏览器壳、浏览器自动化、远程服务器、云数据库或容器化方案。
+

XPostArchiver-clean-upload-20260711-225630/docs/03-数据库设计.md

@@ -0,0 +1,52 @@
+# 数据库设计
+
+## 原则
+
+数据库由用户新建或选择。使用 SQLite、SQLx 和 SQLx migrations。迁移前创建备份，失败时保留原数据库。X ID 使用 TEXT，时间统一存 UTC，未知指标使用 NULL，API 凭据绝不入库。
+
+## 迁移
+
+迁移文件保存在 `migrations`。构建软件时不得要求用户数据库存在。第一版优先使用 SQLx 运行时查询接口，不依赖构建期数据库连接或离线查询元数据。
+
+## 数据表
+
+### app_metadata
+
+保存数据库创建时间、结构版本、应用版本、最后打开时间等非敏感数据库级信息。
+
+### accounts
+
+保存 `x_user_id`（唯一）、用户名、显示名、简介、头像、X 创建时间、protected、verified、粉丝/关注/帖子数量、首次和最后发现时间、raw_json。
+
+### posts
+
+保存 `x_post_id`（唯一）、作者账号 ID/用户名/显示名、正文、发布时间、原始链接、语言、conversation_id、回复对象、帖子分类、长文标记、可空互动指标、媒体标志、首次和最后采集时间、数据来源、来源任务及 raw_json。
+
+### post_references
+
+保存 source_post_id、reference_type 和 target_x_post_id。类型包括 `replied_to`、`quoted`、`reposted`，允许一条帖子存在多种关系。
+
+### media 与 post_media
+
+媒体表保存 media_key、类型、原始/预览 URL、相对媒体根目录路径、MIME、文件大小、宽高、时长、下载状态、时间、校验和、错误及 raw_json；关联表保存帖子、媒体和显示顺序。
+
+### crawl_jobs
+
+保存目标、任务模式、日期、数量上限、类型开关、媒体开关、状态、时间和统计。状态至少包括 pending、running、pausing、paused、completed、completed_with_warnings、failed、cancelled、rate_limited、quota_exhausted。
+
+### crawl_checkpoints
+
+保存任务、分页令牌、最早/最新帖子 ID 和时间、成功页数、最后成功请求时间和更新时间。
+
+### fetch_errors
+
+保存任务、阶段、脱敏请求标识、错误类别、HTTP 状态、消息、是否可重试、重试次数、创建和解决时间。
+
+## 去重、分页和事务
+
+以 `x_post_id` 唯一约束和 upsert 双重去重。重复返回时更新接口实际提供的字段，不用缺失字段覆盖已有有效值。每页数据成功提交后才更新断点；失败回滚本页，不破坏此前页面。
+
+## 打开、检查和迁移
+
+检查 SQLite 文件头、读写权限、完整性、迁移版本和必要数据表。迁移前复制备份；失败则关闭连接并保留原库。不得覆盖同名数据库或在旧路径失效时创建替代空库。
+

XPostArchiver-clean-upload-20260711-225630/docs/04-界面与交互设计.md

@@ -0,0 +1,30 @@
+# 界面与交互设计
+
+## 首次启动向导
+
+1. 欢迎页说明 API 权限、额度和可访问范围限制。
+2. 新建数据库、打开已有数据库或退出。无有效数据库时禁止采集。
+3. 选择媒体目录，或暂不下载媒体。
+4. 分别设置导出、日志、临时和备份目录。
+5. 设置 Bearer Token 等必要凭据，提供保存、测试、删除和状态显示，不完整展示已保存密钥。
+6. 汇总数据库、各目录、API 状态、写权限和磁盘空间。
+
+新建数据库自动补 `.db`，同名文件存在时不得覆盖。打开已有库需要检查 SQLite 有效性、读写权限、结构版本、必要表和完整性；迁移先备份，失败恢复。
+
+## 页面
+
+- 首页／新建任务：账号输入、查询、预览、范围、日期、数量、类型、媒体选项、当前数据库和 API 状态。
+- 任务管理：状态、页数、接收/新增/更新/重复、媒体数量、当前日期和最近错误；支持开始、暂停、继续、停止、重试、报告和日志。总量未知时不显示虚假百分比。
+- 帖子数据库：账号、关键词、日期、类型、媒体和互动指标筛选；分页列表、详情和多种排序。
+- 数据库管理：新建、打开、切换、备份、检查、统计、迁移和打开文件夹。
+- 导出：当前筛选、账号、任务、日期范围或勾选项。
+- 设置：API、数据库、媒体、导出、日志、备份、网络重试、界面、隐私和关于。
+
+## 账号输入
+
+去除首尾空格和开头 `@`；解析 x.com / www.x.com 主页链接并去掉查询参数和多余斜杠；拒绝帖子链接及明显无效用户名。查询只显示预览，用户点击确认后才创建任务。
+
+## 路径失效
+
+上次数据库不可访问时，提示用户连接对应磁盘或重新选择文件；不自动建空库、不改用系统盘、不删除路径记录，也不武断声称数据丢失。
+

XPostArchiver-clean-upload-20260711-225630/docs/05-X接口与权限说明.md

@@ -0,0 +1,26 @@
+# X接口与权限说明
+
+## 官方接口
+
+软件只使用 X 官方当前允许的 API 和用户自行申请的凭据。第一版至少支持 Bearer Token。具体 endpoint、字段、分页令牌、历史范围和价格在实现时必须依据当时官方文档核验，不能把易变化的套餐能力写成永久承诺。
+
+## 权限、额度和费用
+
+不同 API 产品和账号层级可能具有不同额度、历史范围、字段和媒体 URL 权限，并可能收费。401 通常表示认证失败；403 可能是权限、保护状态或产品限制；404 表示不存在或不可见；429 表示频率限制；额度耗尽时必须停止请求并报告。
+
+## 可获取边界
+
+软件不保证取得已删除、受保护、隐藏、超历史范围、超额度、无权限或接口未返回的数据和媒体源文件。“尽可能完整”只是沿当前接口分页获取实际可访问的公开内容。
+
+当权限不足时显示：
+
+> 当前接口权限无法继续获取更早的数据。本次任务已经保存所有实际返回的内容，但不能据此保证账号历史内容绝对完整。
+
+## 合规要求
+
+不绕过登录、验证码、付费、保护账号、访问控制和频率限制；不轮换账号或密钥规避限制；不使用浏览器自动化；不索取账号密码；不窃取 Cookie。
+
+## 错误与重试
+
+只重试可能恢复的错误，使用有限指数退避并尊重 Retry-After 等限流信息。401、403 不无限重试。任务报告应说明分页末尾、日期/数量停止、限流、额度、权限及仍可能缺失的内容。
+

XPostArchiver-clean-upload-20260711-225630/docs/06-安装与数据目录设计.md

@@ -0,0 +1,28 @@
+# 安装与数据目录设计
+
+## 三类目录
+
+- 开发目录固定为 `<project-directory>`，只保存源码、测试、脚本、文档和构建结果；正式程序不得依赖或写死该路径。
+- 安装目录由用户在安装程序中选择，只保存 EXE、DLL、Qt 资源、图标、必要资源和卸载程序。
+- 数据目录由用户分别选择数据库、媒体、导出、日志、临时下载和备份位置，不默认写入开发目录或安装目录。
+
+## 配置与凭据
+
+使用 platformdirs 对应的 Windows 用户配置目录保存上次数据库路径、媒体/导出/日志/备份目录、界面设置和非敏感偏好。API 凭据使用 Windows 凭据管理能力和 keyring，不得写入配置文件、SQLite 或日志。
+
+## 路径兼容
+
+使用 pathlib 与 Qt 路径 API，支持中文、空格、不同盘符、外接硬盘和较长目录名。媒体记录保存相对于媒体根目录的路径，并允许用户移动后重新绑定。磁盘断开时保留原设置，禁止自动转到系统盘或创建空库。
+
+## 系统盘提醒
+
+安装时和首次选择数据库或媒体目录时检测 Windows 系统盘。若选择系统盘，建议改用空间充足的非系统盘，但允许继续；数据位置提醒可选择不再提示，避免反复弹窗。推荐安装目录不得是开发目录。
+
+## 卸载和升级
+
+卸载默认只删除程序文件，并明确说明不会删除用户数据库、媒体、导出和备份；可以让用户选择删除小型设置，但不得默认删除数据。升级保留路径、凭据和媒体；数据库结构升级前先备份，失败恢复。
+
+## 便携版
+
+便携版仍允许选择独立数据库和媒体目录，不把“便携”解释为所有数据必须放在程序目录。
+

XPostArchiver-clean-upload-20260711-225630/docs/07-测试方案.md

@@ -0,0 +1,45 @@
+# 测试方案
+
+## 基础命令
+
+每个阶段至少执行：
+
+```powershell
+cargo fmt --all -- --check
+cargo clippy --all-targets --all-features -- -D warnings
+cargo test --all
+cargo check
+```
+
+完成可运行阶段后还必须执行：
+
+```powershell
+cargo run
+```
+
+发布前执行：
+
+```powershell
+cargo build --release
+```
+
+## 单元测试
+
+覆盖用户名规范化、X 主页链接解析和帖子链接拒绝、帖子分类、ID 去重、UTC/本地时间转换、路径处理、Windows 文件名清理、分页断点、API 错误分类、敏感信息脱敏、各导出格式和数据库迁移。
+
+## 数据库测试
+
+覆盖新建、打开、拒绝无效库、重复帖子 upsert、字段更新、断点恢复、迁移前备份、迁移失败回滚、未知值与 0 区分、长 ID 字符串保存。
+
+## 界面测试
+
+覆盖首次向导、无数据库时禁止采集、API 失败中文提示、开始/暂停/恢复/停止、切换数据库、导出筛选结果、路径失效提示和主线程响应性。每阶段必须实际检查 Slint 窗口能打开、移动和关闭。
+
+## 模拟 API 测试
+
+使用 wiremock 模拟正常分页、空结果、无下一页、401、403、404、429、5xx、额度不足、超时、字段缺失、重复帖子和媒体失败。自动测试不得大量调用真实 X API，不使用真实密钥。
+
+## 发布验收
+
+在无 Rust 开发环境的 Windows 10/11 上测试 release 程序；验证中文和空格路径、不同盘符、安装、卸载、升级、数据库备份恢复、磁盘断开和数据保留。
+

XPostArchiver-clean-upload-20260711-225630/docs/08-打包发布方案.md

@@ -0,0 +1,28 @@
+# 打包发布方案
+
+## Release 构建
+
+开发阶段使用 `cargo run`。发布构建使用：
+
+```powershell
+cargo build --release
+```
+
+生成的可执行文件通常位于 `target\release\xpost-archiver.exe`。最终发布文件复制到 `dist`。不得要求最终用户安装 Rust、Cargo 或开发工具链。
+
+## 资源
+
+打包时包含 EXE、必要动态库、Slint 运行资源、图标和软件内部只读资源。数据库、媒体、导出和备份不得默认写入安装目录。
+
+## Inno Setup
+
+安装器允许用户选择安装位置，显示目标磁盘剩余空间和快捷方式选项。若安装到系统盘，只提醒并提供返回修改或继续安装，不强制阻止。
+
+## 卸载和升级
+
+卸载默认保留数据库、媒体、导出和备份，只删除程序文件；小型设置可由用户选择删除。升级保留路径、凭据和用户数据，数据库迁移前创建备份，并显示版本变化。
+
+## 发布检查
+
+执行全量 Cargo 测试、安全与隐私检查、安装/卸载/升级测试、备份恢复和无开发环境启动测试。最终输出安装版 EXE、便携版 ZIP、`SHA256SUMS.txt` 和发布说明。
+

XPostArchiver-clean-upload-20260711-225630/docs/09-隐私与安全说明.md

@@ -0,0 +1,22 @@
+# 隐私与安全说明
+
+## 数据最小化
+
+软件第一版纯本地运行，不主动上传用户数据库、媒体、导出或诊断信息。默认日志不记录完整帖子正文和完整 API 响应。
+
+## 凭据
+
+Bearer Token、API Secret 等仅由 keyring 保存；界面只显示状态或掩码。禁止将密钥写入源码、Git、SQLite、日志、错误弹窗、诊断报告、导出文件和测试。复制诊断信息时清理 Authorization、token、secret、cookie 等敏感字段。
+
+## 文件安全
+
+新建数据库不得覆盖同名文件；迁移前备份，失败恢复。媒体使用临时扩展名下载，成功后原子重命名，可校验文件大小和 SHA-256。磁盘断开时安全停止，不删除原路径或已有数据。
+
+## 平台边界
+
+不索取 X 密码、不窃取 Cookie、不绕过验证码、登录、保护账号、付费权限、访问控制和频率限制，不轮换密钥，不以高并发轰炸接口，不使用来源不明的代理或免登录库。
+
+## 日志与诊断
+
+日志按日期或大小轮转，可设置保留天数。诊断报告只包含软件版本、Windows 版本、打包版本、数据库结构版本、错误类别、脱敏请求信息和任务状态，不包含凭据和不必要的完整个人数据。
+

XPostArchiver-clean-upload-20260711-225630/docs/10-开发阶段计划.md

@@ -0,0 +1,21 @@
+# 开发阶段计划
+
+## 阶段
+
+0. Rust 项目初始化：检查 Rust 环境、Cargo 项目、Slint、Tokio、基础依赖、统一错误、脱敏日志、SQLx 迁移草案、文档修订、Cargo 验收和实际窗口运行。
+1. 数据库与首次启动向导：用户选择数据库、新建/打开 SQLite、SQLx 迁移、备份、路径设置、配置文件和无效路径提示。
+2. X API 凭据和账号查询：Windows 凭据管理、Bearer Token 测试、用户名规范化、账号查询、账号确认和 API 错误分类。
+3. 保存一页帖子：获取帖子、解析、保存数据库、唯一去重、本地列表和详情查看。
+4. 分页和断点续传：自动分页、任务状态机、数据库检查点、暂停、继续、停止和软件重启恢复。
+5. 搜索和筛选：关键词搜索、日期筛选、帖子类型筛选、排序、本地分页和大数据量列表优化。
+6. 媒体下载：流式下载、临时文件、重试、校验、目录重新绑定和下载失败记录。
+7. 导出：Excel、CSV、JSON、JSON Lines、Markdown、TXT。
+8. Release 构建：release 编译、Windows 图标、版本资源、独立电脑测试和运行依赖检查。
+9. 安装程序：Inno Setup、自定义安装目录、系统盘提醒、快捷方式、卸载、升级保留配置和用户数据保留。
+
+## 每次工作顺序
+
+读取 `PROJECT_STATE.md`；检查 Git 状态；检查当前可运行版本；只处理一个阶段；做最少必要修改；运行 Cargo 验收；实际启动；更新状态和变更记录；建立提交。
+
+不得因局部错误推倒重写，也不得未经备份使用 `git reset --hard`、`git clean -fd`、清空目录、覆盖数据库等危险操作。
+

XPostArchiver-clean-upload-20260711-225630/docs/11-后期优化路线.md

@@ -0,0 +1,155 @@
+# 后期优化路线
+
+本文记录暂缓但值得后续继续做的优化。当前软件已经具备本地配置、官方 X API 凭据保存、公开账号查询、采集任务、分页采集、媒体下载、失败写回、归档预览和 Markdown 导出能力。后续优化优先围绕减少手动操作、增强长期运行稳定性和提升导出可用性。
+
+## 一、任务操作体验
+
+### 1. 真正可点击任务列表
+
+当前任务列表是文本展示，并会自动把最新任务 ID 填入输入框。后续可改成可选择列表：
+
+- 点击某个任务后自动设置为当前任务。
+- 当前任务用于拉取下一页、自动采集、预览、导出和媒体下载。
+- 任务行显示账号、中文状态、页数、保存数量、失败原因。
+- 失败任务可突出显示，但不要用吓人的警告样式。
+
+实现建议：
+
+- 优先保持数据库结构不变。
+- 如果 Slint 标准控件不方便做表格，先做简单列表加“选择第 N 个任务”也可以。
+- 不要为了这个功能引入 WebView、Electron、Tauri 或前端框架。
+
+### 2. 任务详情区
+
+点击任务后显示更清楚的任务详情：
+
+- 任务 ID
+- 目标账号
+- 当前状态
+- 已采集页数
+- 收到/保存/更新/重复帖子数量
+- 最近错误
+- 下一页游标是否存在
+- 创建、开始、暂停、完成时间
+
+## 二、采集任务长期运行
+
+### 1. 暂停和恢复
+
+当前有“停止自动采集”，并会写回 `stopped`。后续可以把“停止”细分为：
+
+- 暂停：保留分页游标，状态写为 `paused` 或继续使用 `stopped` 但 UI 显示为“已暂停”。
+- 恢复：从 `crawl_checkpoints.pagination_token` 继续采集。
+
+注意：如果要新增状态值，必须同步更新 UI 中文状态映射和测试。
+
+### 2. 更清楚的运行保护
+
+当前已阻止自动采集运行中重复启动第二个自动采集。后续可继续增强：
+
+- 切换数据库前检查是否有运行任务。
+- 关闭窗口前提示是否仍有后台采集。
+- 记录自动采集开始和结束日志。
+- 长时间无进度时显示“仍在运行”而不是让用户以为卡住。
+
+### 3. 速率限制处理
+
+官方 X API 可能返回 429。后续可做：
+
+- 识别 429 并显示“达到 X API 频率限制”。
+- 如果响应头包含重置时间，显示大概可继续时间。
+- 不绕过、不并发冲击、不伪造登录状态。
+
+## 三、媒体下载
+
+### 1. 重试策略细化
+
+当前已有“重试失败媒体”入口，会把 `metadata_only` 和 `failed` 状态的媒体纳入下载。后续可继续：
+
+- 区分临时失败和永久失败。
+- 记录每个媒体的重试次数。
+- 对 404 或无 URL 的媒体减少重复重试。
+- 显示最近失败媒体列表。
+
+如需增加字段，优先新增迁移，不要直接修改历史迁移文件。
+
+### 2. 文件校验
+
+后续可补：
+
+- 下载后记录文件大小。
+- 可选 checksum。
+- 本地文件丢失时重新下载。
+
+## 四、归档查看和导出
+
+### 1. 导出格式扩展
+
+当前支持按任务导出 Markdown 文本索引。后续可扩展：
+
+- CSV
+- JSON
+- XLSX
+- 带媒体相对路径的 Markdown
+- 按账号导出
+- 按时间范围导出
+
+导出仍应写入用户选择的导出目录，不要默认写入开发目录或 C 盘。
+
+### 2. 归档搜索
+
+后续可做简单本地搜索：
+
+- 按账号
+- 按关键词
+- 按任务
+- 按是否含媒体
+- 按采集时间或 X 发布时间
+
+第一版建议直接使用 SQLite 查询，不引入额外搜索引擎。
+
+## 五、数据库维护
+
+### 1. 恢复备份
+
+当前已有检查和备份入口。后续可以加恢复功能：
+
+- 恢复前必须再次备份当前数据库。
+- 恢复时不能有运行中的采集任务。
+- 恢复后重新检查数据库完整性。
+
+### 2. 数据统计页
+
+可以显示：
+
+- 总账号数
+- 总任务数
+- 总帖子数
+- 总媒体数
+- 已下载媒体数
+- 失败媒体数
+- 数据库文件大小
+
+## 六、打包和安装
+
+后续正式发版前需要：
+
+- 更新 README 当前状态。
+- 检查安装程序是否不写死开发目录。
+- 确认配置目录、日志目录、数据库目录可由用户选择。
+- 在干净机器或新用户环境测试启动。
+
+## 七、优先级建议
+
+建议顺序：
+
+1. 真正可点击任务列表。
+2. 任务详情区。
+3. 导出 CSV/JSON。
+4. 暂停/恢复语义优化。
+5. 数据库恢复 UI。
+6. 速率限制友好提示。
+7. 归档搜索。
+
+每个优化继续保持小步提交：实现、严格验收、窗口确认、更新文档、提交。
+

XPostArchiver-clean-upload-20260711-225630/migrations/0001_initial.sql

@@ -0,0 +1,142 @@
+CREATE TABLE IF NOT EXISTS app_metadata (
+    key TEXT PRIMARY KEY NOT NULL,
+    value TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS accounts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    x_user_id TEXT NOT NULL UNIQUE,
+    username TEXT NOT NULL,
+    display_name TEXT,
+    description TEXT,
+    profile_image_url TEXT,
+    created_at_x TEXT,
+    protected INTEGER,
+    verified INTEGER,
+    followers_count INTEGER,
+    following_count INTEGER,
+    post_count INTEGER,
+    first_seen_at TEXT NOT NULL,
+    last_seen_at TEXT NOT NULL,
+    raw_json TEXT
+);
+
+CREATE TABLE IF NOT EXISTS posts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    x_post_id TEXT NOT NULL UNIQUE,
+    author_x_user_id TEXT NOT NULL,
+    author_username TEXT,
+    author_display_name TEXT,
+    text TEXT,
+    created_at_x TEXT,
+    original_url TEXT,
+    language TEXT,
+    conversation_id TEXT,
+    in_reply_to_user_id TEXT,
+    in_reply_to_post_id TEXT,
+    quote_target_post_id TEXT,
+    repost_source_post_id TEXT,
+    post_type TEXT,
+    possibly_long_text INTEGER,
+    like_count INTEGER,
+    reply_count INTEGER,
+    repost_count INTEGER,
+    quote_count INTEGER,
+    bookmark_count INTEGER,
+    view_count INTEGER,
+    has_media INTEGER NOT NULL DEFAULT 0,
+    first_fetched_at TEXT NOT NULL,
+    last_fetched_at TEXT NOT NULL,
+    source_job_id TEXT,
+    raw_json TEXT,
+    data_source TEXT
+);
+
+CREATE TABLE IF NOT EXISTS post_references (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    source_post_id TEXT NOT NULL,
+    reference_type TEXT NOT NULL,
+    target_x_post_id TEXT NOT NULL,
+    UNIQUE(source_post_id, reference_type, target_x_post_id)
+);
+
+CREATE TABLE IF NOT EXISTS media (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    media_key TEXT NOT NULL UNIQUE,
+    media_type TEXT NOT NULL,
+    original_url TEXT,
+    preview_url TEXT,
+    local_relative_path TEXT,
+    mime_type TEXT,
+    file_size INTEGER,
+    width INTEGER,
+    height INTEGER,
+    duration_ms INTEGER,
+    download_status TEXT NOT NULL,
+    downloaded_at TEXT,
+    checksum TEXT,
+    last_error TEXT,
+    raw_json TEXT
+);
+
+CREATE TABLE IF NOT EXISTS post_media (
+    post_id TEXT NOT NULL,
+    media_key TEXT NOT NULL,
+    display_order INTEGER NOT NULL,
+    PRIMARY KEY (post_id, media_key)
+);
+
+CREATE TABLE IF NOT EXISTS crawl_jobs (
+    id TEXT PRIMARY KEY NOT NULL,
+    target_x_user_id TEXT,
+    target_username TEXT NOT NULL,
+    task_mode TEXT NOT NULL,
+    date_start TEXT,
+    date_end TEXT,
+    maximum_posts INTEGER,
+    include_original INTEGER NOT NULL,
+    include_replies INTEGER NOT NULL,
+    include_reposts INTEGER NOT NULL,
+    include_quotes INTEGER NOT NULL,
+    download_media INTEGER NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    started_at TEXT,
+    paused_at TEXT,
+    finished_at TEXT,
+    pages_fetched INTEGER NOT NULL DEFAULT 0,
+    posts_received INTEGER NOT NULL DEFAULT 0,
+    posts_inserted INTEGER NOT NULL DEFAULT 0,
+    posts_updated INTEGER NOT NULL DEFAULT 0,
+    posts_duplicated INTEGER NOT NULL DEFAULT 0,
+    media_downloaded INTEGER NOT NULL DEFAULT 0,
+    error_count INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT
+);
+
+CREATE TABLE IF NOT EXISTS crawl_checkpoints (
+    job_id TEXT PRIMARY KEY NOT NULL,
+    pagination_token TEXT,
+    oldest_post_id TEXT,
+    oldest_post_time TEXT,
+    newest_post_id TEXT,
+    newest_post_time TEXT,
+    last_successful_page INTEGER NOT NULL DEFAULT 0,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS fetch_errors (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    job_id TEXT,
+    stage TEXT NOT NULL,
+    request_identifier TEXT,
+    error_category TEXT NOT NULL,
+    http_status INTEGER,
+    message TEXT NOT NULL,
+    retryable INTEGER NOT NULL,
+    retry_count INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL,
+    resolved_at TEXT
+);
+

XPostArchiver-clean-upload-20260711-225630/migrations/README.md

@@ -0,0 +1,4 @@
+# SQLx Migrations
+
+数据库迁移文件必须随源码提交。程序打开用户选择的 SQLite 数据库时运行迁移；迁移前必须先备份用户数据库。
+

XPostArchiver-clean-upload-20260711-225630/src/api/mod.rs

@@ -0,0 +1,2 @@
+
+

XPostArchiver-clean-upload-20260711-225630/src/app.rs

@@ -0,0 +1,824 @@
+use std::cell::RefCell;
+use std::path::Path;
+use std::rc::Rc;
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
+use std::thread;
+use std::time::Duration;
+
+use crate::config::settings::{AppSettings, ConfigPathKind};
+use crate::logging::rotation::redact_secret;
+use crate::logging::{LoggingGuard, init_logging};
+use crate::services::account_service::lookup_account;
+use crate::services::archive_export_service::{
+    export_posts_for_job_markdown, preview_posts_for_job,
+};
+use crate::services::crawl_task_service::{create_crawl_task, list_recent_crawl_tasks};
+use crate::services::credential_service::{
+    bearer_token_status, clear_bearer_token, read_bearer_token, save_bearer_token,
+};
+use crate::services::database_service::{
+    backup_current_database, check_current_database, choose_existing_database, create_database,
+};
+use crate::services::media_download_service::{download_pending_media, retry_failed_media};
+use crate::services::path_service::choose_config_directory;
+use crate::services::post_fetch_service::{
+    auto_fetch_pages_for_task_owned_async, fetch_one_page_for_task,
+};
+use crate::services::x_api_service::validate_bearer_token;
+use crate::tasks::runtime::BackgroundRuntime;
+
+slint::include_modules!();
+
+pub struct App {
+    _logging: LoggingGuard,
+    runtime: Rc<BackgroundRuntime>,
+    settings: Rc<RefCell<AppSettings>>,
+}
+
+impl App {
+    pub fn bootstrap() -> anyhow::Result<Self> {
+        let logging = init_logging()?;
+        tracing::info!(
+            module = "app",
+            "{}",
+            redact_secret("starting XPostArchiver")
+        );
+        let runtime = Rc::new(BackgroundRuntime::new()?);
+        let settings = Rc::new(RefCell::new(AppSettings::load()?));
+        Ok(Self {
+            _logging: logging,
+            runtime,
+            settings,
+        })
+    }
+
+    pub fn run(self) -> anyhow::Result<()> {
+        let _shutdown_token = self.runtime.cancellation_token();
+        let window = AppWindow::new()?;
+        load_saved_settings(&window, &self.settings.borrow());
+        register_database_callbacks(&window, Rc::clone(&self.runtime), Rc::clone(&self.settings));
+        register_path_callbacks(&window, Rc::clone(&self.settings));
+        register_media_mode_callbacks(&window, Rc::clone(&self.settings));
+        register_credential_callbacks(&window, Rc::clone(&self.runtime));
+        register_account_callbacks(&window, Rc::clone(&self.runtime), Rc::clone(&self.settings));
+        register_crawl_task_callbacks(&window, Rc::clone(&self.runtime), Rc::clone(&self.settings));
+
+        window.run()?;
+        tracing::info!(module = "app", "application closed");
+        Ok(())
+    }
+}
+
+fn load_saved_settings(window: &AppWindow, settings: &AppSettings) {
+    if let Some(path) = settings.last_database_path.as_ref() {
+        window.set_database_path(display_path(path).into());
+        if path.exists() {
+            window.set_status_message("已加载上次数据库路径。".into());
+            window.set_database_ready(true);
+        } else {
+            window.set_status_message(
+                "上次使用的数据库当前无法访问。请连接对应磁盘，或重新选择数据库文件。".into(),
+            );
+            window.set_database_ready(false);
+        }
+    }
+
+    set_optional_path(
+        window,
+        ConfigPathKind::MediaRoot,
+        settings.get_path(ConfigPathKind::MediaRoot),
+    );
+    set_optional_path(
+        window,
+        ConfigPathKind::ExportDir,
+        settings.get_path(ConfigPathKind::ExportDir),
+    );
+    set_optional_path(
+        window,
+        ConfigPathKind::LogDir,
+        settings.get_path(ConfigPathKind::LogDir),
+    );
+    set_optional_path(
+        window,
+        ConfigPathKind::BackupDir,
+        settings.get_path(ConfigPathKind::BackupDir),
+    );
+    set_optional_path(
+        window,
+        ConfigPathKind::TempDir,
+        settings.get_path(ConfigPathKind::TempDir),
+    );
+    window.set_save_media_files(settings.save_media_files);
+    set_credential_status(window);
+}
+
+fn register_database_callbacks(
+    window: &AppWindow,
+    runtime: Rc<BackgroundRuntime>,
+    settings: Rc<RefCell<AppSettings>>,
+) {
+    {
+        let weak_window = window.as_weak();
+        let runtime = Rc::clone(&runtime);
+        let settings = Rc::clone(&settings);
+        window.on_create_database(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match create_database(&runtime, &mut settings.borrow_mut()) {
+                Ok(Some(result)) => {
+                    window.set_database_path(display_path(&result.path).into());
+                    window.set_status_message(result.message.into());
+                    window.set_database_ready(true);
+                }
+                Ok(None) => {
+                    window.set_status_message("已取消新建数据库。".into());
+                }
+                Err(error) => {
+                    window.set_status_message(format!("新建数据库失败：{error}").into());
+                    window.set_database_ready(false);
+                }
+            }
+        });
+    }
+
+    {
+        let weak_window = window.as_weak();
+        let runtime = Rc::clone(&runtime);
+        let settings = Rc::clone(&settings);
+        window.on_open_database(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match choose_existing_database(&runtime, &mut settings.borrow_mut()) {
+                Ok(Some(result)) => {
+                    window.set_database_path(display_path(&result.path).into());
+                    window.set_status_message(result.message.into());
+                    window.set_database_ready(true);
+                }
+                Ok(None) => {
+                    window.set_status_message("已取消打开数据库。".into());
+                }
+                Err(error) => {
+                    window.set_status_message(format!("打开数据库失败：{error}").into());
+                    window.set_database_ready(false);
+                }
+            }
+        });
+    }
+
+    {
+        let weak_window = window.as_weak();
+        let runtime = Rc::clone(&runtime);
+        let settings = Rc::clone(&settings);
+        window.on_check_database(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match check_current_database(&runtime, &settings.borrow()) {
+                Ok(result) => {
+                    window.set_status_message(result.message.into());
+                }
+                Err(error) => {
+                    window.set_status_message(format!("检查数据库失败：{error}").into());
+                }
+            }
+        });
+    }
+
+    {
+        let weak_window = window.as_weak();
+        let settings = Rc::clone(&settings);
+        window.on_backup_database(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match backup_current_database(&settings.borrow()) {
+                Ok(result) => {
+                    window.set_status_message(result.message.into());
+                }
+                Err(error) => {
+                    window.set_status_message(format!("备份数据库失败：{error}").into());
+                }
+            }
+        });
+    }
+}
+
+fn register_path_callbacks(window: &AppWindow, settings: Rc<RefCell<AppSettings>>) {
+    register_one_path_callback(window, Rc::clone(&settings), ConfigPathKind::MediaRoot);
+    register_one_path_callback(window, Rc::clone(&settings), ConfigPathKind::ExportDir);
+    register_one_path_callback(window, Rc::clone(&settings), ConfigPathKind::LogDir);
+    register_one_path_callback(window, Rc::clone(&settings), ConfigPathKind::BackupDir);
+    register_one_path_callback(window, settings, ConfigPathKind::TempDir);
+}
+
+fn register_one_path_callback(
+    window: &AppWindow,
+    settings: Rc<RefCell<AppSettings>>,
+    kind: ConfigPathKind,
+) {
+    let weak_window = window.as_weak();
+    let callback = move || {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        match choose_config_directory(kind, &mut settings.borrow_mut()) {
+            Ok(Some(result)) => {
+                set_optional_path(&window, result.kind, Some(&result.path));
+                window.set_status_message(result.message.into());
+            }
+            Ok(None) => {
+                window.set_status_message(format!("已取消设置{}。", kind.label()).into());
+            }
+            Err(error) => {
+                window.set_status_message(format!("设置{}失败：{error}", kind.label()).into());
+            }
+        }
+    };
+
+    match kind {
+        ConfigPathKind::MediaRoot => window.on_choose_media_root(callback),
+        ConfigPathKind::ExportDir => window.on_choose_export_dir(callback),
+        ConfigPathKind::LogDir => window.on_choose_log_dir(callback),
+        ConfigPathKind::BackupDir => window.on_choose_backup_dir(callback),
+        ConfigPathKind::TempDir => window.on_choose_temp_dir(callback),
+    }
+}
+
+fn register_account_callbacks(
+    window: &AppWindow,
+    runtime: Rc<BackgroundRuntime>,
+    settings: Rc<RefCell<AppSettings>>,
+) {
+    let weak_window = window.as_weak();
+    window.on_lookup_account(move |username| {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let Some(database_path) = settings.borrow().last_database_path.clone() else {
+            window.set_account_status("请先选择或新建数据库。".into());
+            return;
+        };
+        match lookup_account(&runtime, &database_path, username.as_str()) {
+            Ok(result) => {
+                let display_name = result
+                    .display_name
+                    .unwrap_or_else(|| "未提供显示名".to_owned());
+                window.set_account_status(
+                    format!(
+                        "{} 显示名：{} 用户名：@{}",
+                        result.message, display_name, result.username
+                    )
+                    .into(),
+                );
+            }
+            Err(error) => {
+                window.set_account_status(format!("查询账号失败：{error}").into());
+            }
+        }
+    });
+}
+
+fn register_crawl_task_callbacks(
+    window: &AppWindow,
+    runtime: Rc<BackgroundRuntime>,
+    settings: Rc<RefCell<AppSettings>>,
+) {
+    let auto_stop_signal: Rc<RefCell<Option<Arc<AtomicBool>>>> = Rc::new(RefCell::new(None));
+    let auto_running = Arc::new(AtomicBool::new(false));
+
+    let weak_window = window.as_weak();
+    let create_runtime = Rc::clone(&runtime);
+    let create_settings = Rc::clone(&settings);
+    window.on_create_crawl_task(move |username| {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = create_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_crawl_task_status("请先选择或新建数据库。".into());
+            return;
+        };
+        match create_runtime.block_on(create_crawl_task(
+            database_path,
+            username.as_str(),
+            &settings_ref,
+        )) {
+            Ok(Ok(result)) => {
+                window.set_selected_job_id(result.job_id.clone().into());
+                window.set_crawl_task_status(
+                    format!("{} 任务ID：{}", result.message, result.job_id).into(),
+                );
+            }
+            Ok(Err(error)) | Err(error) => {
+                window.set_crawl_task_status(format!("创建采集任务失败：{error}").into());
+            }
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let list_runtime = Rc::clone(&runtime);
+    let list_settings = Rc::clone(&settings);
+    window.on_refresh_crawl_tasks(move || {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = list_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_crawl_task_list("请先选择或新建数据库。".into());
+            return;
+        };
+        match list_runtime.block_on(list_recent_crawl_tasks(database_path, 8)) {
+            Ok(Ok(tasks)) => {
+                if tasks.is_empty() {
+                    window.set_crawl_task_list("当前数据库还没有采集任务。".into());
+                } else {
+                    if let Some(first_task) = tasks.first() {
+                        window.set_selected_job_id(first_task.job_id.clone().into());
+                    }
+                    let lines = tasks
+                        .iter()
+                        .map(|task| {
+                            let error_suffix = task
+                                .last_error
+                                .as_ref()
+                                .map(|error| format!("  错误：{}", error))
+                                .unwrap_or_default();
+                            format!(
+                                "{}  @{}  状态：{}  页：{}  收到：{}  保存：{}  创建：{}{}",
+                                task.job_id,
+                                task.username,
+                                crawl_status_label(&task.status),
+                                task.pages_fetched,
+                                task.posts_received,
+                                task.posts_inserted,
+                                task.created_at,
+                                error_suffix
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                        .join("\n");
+                    window.set_crawl_task_list(lines.into());
+                }
+            }
+            Ok(Err(error)) | Err(error) => {
+                window.set_crawl_task_list(format!("刷新任务列表失败：{error}").into());
+            }
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let fetch_runtime = Rc::clone(&runtime);
+    let fetch_settings = Rc::clone(&settings);
+    window.on_fetch_one_page(move |job_id| {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = fetch_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_fetch_status("请先选择或新建数据库。".into());
+            return;
+        };
+        match fetch_one_page_for_task(&fetch_runtime, database_path, job_id.as_str()) {
+            Ok(result) => window.set_fetch_status(
+                format!(
+                    "{} 收到：{} 保存：{} 媒体：{} 状态：{}",
+                    result.message,
+                    result.received,
+                    result.saved,
+                    result.media_saved,
+                    if result.has_next_page {
+                        "可继续"
+                    } else {
+                        "已完成"
+                    }
+                )
+                .into(),
+            ),
+            Err(error) => window.set_fetch_status(format!("拉取帖子失败：{error}").into()),
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let auto_settings = Rc::clone(&settings);
+    let auto_stop_signal_for_start = Rc::clone(&auto_stop_signal);
+    let auto_running_for_start = Arc::clone(&auto_running);
+    window.on_auto_fetch_pages(move |job_id, page_limit, delay_seconds| {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = auto_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref().cloned() else {
+            window.set_auto_crawl_status("请先选择或新建数据库。".into());
+            return;
+        };
+        let token = match read_bearer_token() {
+            Ok(Some(token)) => token,
+            Ok(None) => {
+                window.set_auto_crawl_status("请先保存 X API Bearer Token。".into());
+                return;
+            }
+            Err(error) => {
+                window.set_auto_crawl_status(format!("读取系统密钥库失败：{error}").into());
+                return;
+            }
+        };
+        let page_limit = match page_limit.trim().parse::<usize>() {
+            Ok(value) => value,
+            Err(_) => {
+                window
+                    .set_auto_crawl_status("页数上限请输入数字；0 表示直到末页或手动停止。".into());
+                return;
+            }
+        };
+        let delay_seconds = match delay_seconds.trim().parse::<u64>() {
+            Ok(value) => value,
+            Err(_) => {
+                window.set_auto_crawl_status("每页等待秒数请输入数字。".into());
+                return;
+            }
+        };
+        let job_id = job_id.to_string();
+        if job_id.trim().is_empty() {
+            window.set_auto_crawl_status("请先填写任务 ID。".into());
+            return;
+        }
+        if auto_running_for_start.swap(true, Ordering::Relaxed) {
+            window.set_auto_crawl_status("已有自动采集正在运行，请先停止或等待完成。".into());
+            return;
+        }
+        let completion_window = weak_window.clone();
+        let running_signal = Arc::clone(&auto_running_for_start);
+        let stop_requested = Arc::new(AtomicBool::new(false));
+        *auto_stop_signal_for_start.borrow_mut() = Some(Arc::clone(&stop_requested));
+        window.set_auto_crawl_status(
+            format!(
+                "自动采集已在后台启动；页数上限：{}；每页等待：{} 秒。",
+                if page_limit == 0 {
+                    "直到末页或手动停止".to_owned()
+                } else {
+                    page_limit.to_string()
+                },
+                delay_seconds
+            )
+            .into(),
+        );
+        thread::spawn(move || {
+            let result = tokio::runtime::Builder::new_current_thread()
+                .enable_all()
+                .build()
+                .map_err(anyhow::Error::from)
+                .and_then(|runtime| {
+                    runtime.block_on(auto_fetch_pages_for_task_owned_async(
+                        database_path,
+                        job_id,
+                        token,
+                        page_limit,
+                        Duration::from_secs(delay_seconds),
+                        stop_requested,
+                    ))
+                });
+            let message = match result {
+                Ok(result) => format!(
+                    "{} 页数：{} 收到：{} 保存：{} 媒体：{} 状态：{}",
+                    result.message,
+                    result.pages_fetched,
+                    result.posts_received,
+                    result.posts_saved,
+                    result.media_saved,
+                    if result.stopped_by_request {
+                        "已停止"
+                    } else if result.stopped_because_complete {
+                        "已完成"
+                    } else {
+                        "可继续"
+                    }
+                ),
+                Err(error) => format!("自动采集失败：{error}"),
+            };
+            running_signal.store(false, Ordering::Relaxed);
+            let _ = slint::invoke_from_event_loop(move || {
+                if let Some(window) = completion_window.upgrade() {
+                    window.set_auto_crawl_status(message.into());
+                }
+            });
+        });
+    });
+
+    let weak_window = window.as_weak();
+    let auto_stop_signal_for_stop = Rc::clone(&auto_stop_signal);
+    window.on_stop_auto_crawl(move || {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        if let Some(stop_requested) = auto_stop_signal_for_stop.borrow().as_ref() {
+            stop_requested.store(true, Ordering::Relaxed);
+            window.set_auto_crawl_status("已请求停止自动采集；当前页完成后会停下。".into());
+        } else {
+            window.set_auto_crawl_status("当前没有正在运行的自动采集。".into());
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let preview_runtime = Rc::clone(&runtime);
+    let preview_settings = Rc::clone(&settings);
+    window.on_preview_archive(move |job_id| {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = preview_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_archive_preview("请先选择或新建数据库。".into());
+            return;
+        };
+        match preview_runtime.block_on(preview_posts_for_job(database_path, job_id.as_str(), 5)) {
+            Ok(Ok(result)) => {
+                if result.posts.is_empty() {
+                    window.set_archive_preview("这个任务还没有已保存帖子。".into());
+                } else {
+                    let lines = result
+                        .posts
+                        .iter()
+                        .map(|post| {
+                            format!(
+                                "{}  @{}  {}\n{}",
+                                post.x_post_id,
+                                post.author_username.as_deref().unwrap_or("未知账号"),
+                                post.created_at_x.as_deref().unwrap_or("未知时间"),
+                                post.text.as_deref().unwrap_or("")
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                        .join("\n---\n");
+                    window.set_archive_preview(format!("{}\n{}", result.message, lines).into());
+                }
+            }
+            Ok(Err(error)) | Err(error) => {
+                window.set_archive_preview(format!("预览归档失败：{error}").into());
+            }
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let export_runtime = Rc::clone(&runtime);
+    let export_settings = Rc::clone(&settings);
+    window.on_export_archive(move |job_id| {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = export_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_archive_preview("请先选择或新建数据库。".into());
+            return;
+        };
+        let Some(export_dir) = settings_ref.export_dir.as_ref() else {
+            window.set_archive_preview("请先选择导出目录。".into());
+            return;
+        };
+        match export_runtime.block_on(export_posts_for_job_markdown(
+            database_path,
+            export_dir,
+            job_id.as_str(),
+        )) {
+            Ok(Ok(result)) => window.set_archive_preview(
+                format!(
+                    "{} 文件：{} 帖子数：{}",
+                    result.message,
+                    result.path.display(),
+                    result.post_count
+                )
+                .into(),
+            ),
+            Ok(Err(error)) | Err(error) => {
+                window.set_archive_preview(format!("导出归档失败：{error}").into());
+            }
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let download_runtime = Rc::clone(&runtime);
+    let download_settings = Rc::clone(&settings);
+    window.on_download_media(move || {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = download_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_media_download_status("请先选择或新建数据库。".into());
+            return;
+        };
+        let Some(archive_root) = settings_ref.media_root.as_ref() else {
+            window.set_media_download_status("请先选择归档内容目录。".into());
+            return;
+        };
+        if !settings_ref.save_media_files {
+            window.set_media_download_status("当前设置为只保存文本，已跳过媒体文件下载。".into());
+            return;
+        }
+        match download_pending_media(&download_runtime, database_path, archive_root, 20) {
+            Ok(result) => window.set_media_download_status(
+                format!(
+                    "{} 尝试：{} 成功：{} 跳过：{} 失败：{}",
+                    result.message,
+                    result.attempted,
+                    result.downloaded,
+                    result.skipped,
+                    result.failed
+                )
+                .into(),
+            ),
+            Err(error) => window.set_media_download_status(format!("下载媒体失败：{error}").into()),
+        }
+    });
+
+    let weak_window = window.as_weak();
+    let retry_runtime = Rc::clone(&runtime);
+    let retry_settings = Rc::clone(&settings);
+    window.on_retry_failed_media(move || {
+        let Some(window) = weak_window.upgrade() else {
+            return;
+        };
+        let settings_ref = retry_settings.borrow();
+        let Some(database_path) = settings_ref.last_database_path.as_ref() else {
+            window.set_media_download_status("请先选择或新建数据库。".into());
+            return;
+        };
+        let Some(archive_root) = settings_ref.media_root.as_ref() else {
+            window.set_media_download_status("请先选择归档内容目录。".into());
+            return;
+        };
+        if !settings_ref.save_media_files {
+            window.set_media_download_status("当前设置为只保存文本，已跳过媒体文件下载。".into());
+            return;
+        }
+        match retry_failed_media(&retry_runtime, database_path, archive_root, 20) {
+            Ok(result) => window.set_media_download_status(
+                format!(
+                    "{} 尝试：{} 成功：{} 跳过：{} 失败：{}",
+                    result.message,
+                    result.attempted,
+                    result.downloaded,
+                    result.skipped,
+                    result.failed
+                )
+                .into(),
+            ),
+            Err(error) => {
+                window.set_media_download_status(format!("重试失败媒体失败：{error}").into());
+            }
+        }
+    });
+}
+
+fn register_credential_callbacks(window: &AppWindow, runtime: Rc<BackgroundRuntime>) {
+    {
+        let weak_window = window.as_weak();
+        window.on_save_bearer_token(move |token| {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match save_bearer_token(token.as_str()) {
+                Ok(status) => apply_credential_status(&window, status),
+                Err(error) => {
+                    window.set_credentials_ready(false);
+                    window.set_credential_status(format!("保存凭据失败：{error}").into());
+                }
+            }
+        });
+    }
+
+    {
+        let weak_window = window.as_weak();
+        let runtime = Rc::clone(&runtime);
+        window.on_validate_bearer_token(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match read_bearer_token() {
+                Ok(Some(token)) => match runtime.block_on(validate_bearer_token(&token)) {
+                    Ok(Ok(result)) => {
+                        window.set_credentials_ready(result.valid);
+                        window.set_credential_status(result.message.into());
+                    }
+                    Ok(Err(error)) | Err(error) => {
+                        window.set_credentials_ready(false);
+                        window.set_credential_status(format!("检查凭据失败：{error}").into());
+                    }
+                },
+                Ok(None) => {
+                    window.set_credentials_ready(false);
+                    window.set_credential_status("请先保存 X API Bearer Token。".into());
+                }
+                Err(error) => {
+                    window.set_credentials_ready(false);
+                    window.set_credential_status(format!("读取系统密钥库失败：{error}").into());
+                }
+            }
+        });
+    }
+
+    {
+        let weak_window = window.as_weak();
+        window.on_clear_bearer_token(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            match clear_bearer_token() {
+                Ok(status) => apply_credential_status(&window, status),
+                Err(error) => {
+                    window.set_credentials_ready(false);
+                    window.set_credential_status(format!("清除凭据失败：{error}").into());
+                }
+            }
+        });
+    }
+}
+
+fn set_credential_status(window: &AppWindow) {
+    apply_credential_status(window, bearer_token_status());
+}
+
+fn apply_credential_status(
+    window: &AppWindow,
+    status: crate::services::credential_service::CredentialStatus,
+) {
+    window.set_credentials_ready(status.configured);
+    window.set_credential_status(status.message.into());
+}
+
+fn register_media_mode_callbacks(window: &AppWindow, settings: Rc<RefCell<AppSettings>>) {
+    {
+        let weak_window = window.as_weak();
+        let settings = Rc::clone(&settings);
+        window.on_enable_media_files(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            let mut settings = settings.borrow_mut();
+            settings.save_media_files = true;
+            match settings.save() {
+                Ok(()) => {
+                    window.set_save_media_files(true);
+                    window.set_status_message("已设置为保存文本和媒体文件。".into());
+                }
+                Err(error) => {
+                    window.set_status_message(format!("保存媒体设置失败：{error}").into());
+                }
+            }
+        });
+    }
+
+    {
+        let weak_window = window.as_weak();
+        window.on_disable_media_files(move || {
+            let Some(window) = weak_window.upgrade() else {
+                return;
+            };
+            let mut settings = settings.borrow_mut();
+            settings.save_media_files = false;
+            match settings.save() {
+                Ok(()) => {
+                    window.set_save_media_files(false);
+                    window.set_status_message("已设置为只保存文本和媒体链接信息。".into());
+                }
+                Err(error) => {
+                    window.set_status_message(format!("保存媒体设置失败：{error}").into());
+                }
+            }
+        });
+    }
+}
+
+fn set_optional_path(window: &AppWindow, kind: ConfigPathKind, path: Option<&Path>) {
+    let value = path
+        .map(display_path)
+        .unwrap_or_else(|| "未设置".to_owned());
+    match kind {
+        ConfigPathKind::MediaRoot => window.set_media_root(value.into()),
+        ConfigPathKind::ExportDir => window.set_export_dir(value.into()),
+        ConfigPathKind::LogDir => window.set_log_dir(value.into()),
+        ConfigPathKind::BackupDir => window.set_backup_dir(value.into()),
+        ConfigPathKind::TempDir => window.set_temp_dir(value.into()),
+    }
+}
+
+fn crawl_status_label(status: &str) -> &'static str {
+    match status {
+        "created" => "已创建",
+        "running" => "正在采集",
+        "page_fetched" => "可继续",
+        "completed" => "已完成",
+        "stopped" => "已停止",
+        "failed" => "失败",
+        _ => "未知",
+    }
+}
+
+fn display_path(path: &Path) -> String {
+    path.display().to_string()
+}
+

XPostArchiver-clean-upload-20260711-225630/src/config/mod.rs

@@ -0,0 +1,3 @@
+pub mod paths;
+pub mod settings;
+

XPostArchiver-clean-upload-20260711-225630/src/config/paths.rs

@@ -0,0 +1,13 @@
+use std::path::PathBuf;
+
+use directories::ProjectDirs;
+
+pub fn project_dirs() -> anyhow::Result<ProjectDirs> {
+    ProjectDirs::from("cn", "XPostArchiver", "XPostArchiver")
+        .ok_or_else(|| anyhow::anyhow!("无法取得用户配置目录"))
+}
+
+pub fn config_file_path() -> anyhow::Result<PathBuf> {
+    Ok(project_dirs()?.config_dir().join("settings.json"))
+}
+

XPostArchiver-clean-upload-20260711-225630/src/config/settings.rs

@@ -0,0 +1,105 @@
+use std::path::{Path, PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+use crate::config::paths::config_file_path;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AppSettings {
+    pub last_database_path: Option<PathBuf>,
+    pub media_root: Option<PathBuf>,
+    pub export_dir: Option<PathBuf>,
+    pub log_dir: Option<PathBuf>,
+    pub backup_dir: Option<PathBuf>,
+    pub temp_dir: Option<PathBuf>,
+    #[serde(default = "default_save_media_files")]
+    pub save_media_files: bool,
+    pub system_drive_warning_acknowledged: bool,
+}
+
+fn default_save_media_files() -> bool {
+    true
+}
+
+impl Default for AppSettings {
+    fn default() -> Self {
+        Self {
+            last_database_path: None,
+            media_root: None,
+            export_dir: None,
+            log_dir: None,
+            backup_dir: None,
+            temp_dir: None,
+            save_media_files: true,
+            system_drive_warning_acknowledged: false,
+        }
+    }
+}
+
+impl AppSettings {
+    pub fn load() -> anyhow::Result<Self> {
+        let path = config_file_path()?;
+        if !path.exists() {
+            return Ok(Self::default());
+        }
+        let text = std::fs::read_to_string(path)?;
+        Ok(serde_json::from_str(&text)?)
+    }
+
+    pub fn save(&self) -> anyhow::Result<()> {
+        let path = config_file_path()?;
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent)?;
+        }
+        let text = serde_json::to_string_pretty(self)?;
+        std::fs::write(path, text)?;
+        Ok(())
+    }
+
+    pub fn set_database_path(&mut self, path: impl AsRef<Path>) {
+        self.last_database_path = Some(path.as_ref().to_path_buf());
+    }
+
+    pub fn set_path(&mut self, kind: ConfigPathKind, path: impl AsRef<Path>) {
+        let path = Some(path.as_ref().to_path_buf());
+        match kind {
+            ConfigPathKind::MediaRoot => self.media_root = path,
+            ConfigPathKind::ExportDir => self.export_dir = path,
+            ConfigPathKind::LogDir => self.log_dir = path,
+            ConfigPathKind::BackupDir => self.backup_dir = path,
+            ConfigPathKind::TempDir => self.temp_dir = path,
+        }
+    }
+
+    pub fn get_path(&self, kind: ConfigPathKind) -> Option<&Path> {
+        match kind {
+            ConfigPathKind::MediaRoot => self.media_root.as_deref(),
+            ConfigPathKind::ExportDir => self.export_dir.as_deref(),
+            ConfigPathKind::LogDir => self.log_dir.as_deref(),
+            ConfigPathKind::BackupDir => self.backup_dir.as_deref(),
+            ConfigPathKind::TempDir => self.temp_dir.as_deref(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum ConfigPathKind {
+    MediaRoot,
+    ExportDir,
+    LogDir,
+    BackupDir,
+    TempDir,
+}
+
+impl ConfigPathKind {
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::MediaRoot => "归档内容目录",
+            Self::ExportDir => "导出目录",
+            Self::LogDir => "日志目录",
+            Self::BackupDir => "备份目录",
+            Self::TempDir => "临时下载目录",
+        }
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/database/connection.rs

@@ -0,0 +1,34 @@
+use std::path::Path;
+
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+
+use crate::database::migrations::run_migrations;
+
+pub async fn open_or_create_database(path: &Path) -> anyhow::Result<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    let options = SqliteConnectOptions::new()
+        .filename(path)
+        .create_if_missing(true);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+    connection.close().await?;
+    Ok(())
+}
+
+pub async fn open_existing_database(path: &Path) -> anyhow::Result<()> {
+    if !path.exists() {
+        anyhow::bail!("数据库文件不存在：{}", path.display());
+    }
+
+    let options = SqliteConnectOptions::new()
+        .filename(path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+    connection.close().await?;
+    Ok(())
+}
+

XPostArchiver-clean-upload-20260711-225630/src/database/maintenance.rs

@@ -0,0 +1,64 @@
+use std::path::{Path, PathBuf};
+
+use chrono::Local;
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+
+#[derive(Debug, Clone)]
+pub struct DatabaseBackupResult {
+    pub path: PathBuf,
+}
+
+pub async fn check_database_integrity(path: &Path) -> anyhow::Result<String> {
+    if !path.exists() {
+        anyhow::bail!("数据库文件不存在：{}", path.display());
+    }
+
+    let options = SqliteConnectOptions::new()
+        .filename(path)
+        .read_only(true)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    let result: String = sqlx::query_scalar("PRAGMA integrity_check;")
+        .fetch_one(&mut connection)
+        .await?;
+    connection.close().await?;
+
+    if result == "ok" {
+        Ok("数据库完整性检查通过。".to_owned())
+    } else {
+        anyhow::bail!("数据库完整性检查异常：{result}");
+    }
+}
+
+pub fn backup_database(
+    database_path: &Path,
+    backup_dir: &Path,
+) -> anyhow::Result<DatabaseBackupResult> {
+    if !database_path.exists() {
+        anyhow::bail!("数据库文件不存在：{}", database_path.display());
+    }
+
+    std::fs::create_dir_all(backup_dir)?;
+    if !backup_dir.is_dir() {
+        anyhow::bail!("备份位置不是目录：{}", backup_dir.display());
+    }
+
+    let stem = database_path
+        .file_stem()
+        .and_then(|name| name.to_str())
+        .unwrap_or("X公开帖子归档");
+    let extension = database_path
+        .extension()
+        .and_then(|name| name.to_str())
+        .unwrap_or("db");
+    let timestamp = Local::now().format("%Y%m%d-%H%M%S");
+    let backup_path = backup_dir.join(format!("{stem}-{timestamp}.{extension}"));
+
+    if backup_path.exists() {
+        anyhow::bail!("备份文件已存在，请稍后重试：{}", backup_path.display());
+    }
+
+    std::fs::copy(database_path, &backup_path)?;
+    Ok(DatabaseBackupResult { path: backup_path })
+}
+

XPostArchiver-clean-upload-20260711-225630/src/database/migrations.rs

@@ -0,0 +1,9 @@
+use sqlx::{SqliteConnection, migrate::Migrator};
+
+static MIGRATOR: Migrator = sqlx::migrate!("./migrations");
+
+pub async fn run_migrations(connection: &mut SqliteConnection) -> anyhow::Result<()> {
+    MIGRATOR.run(connection).await?;
+    Ok(())
+}
+

XPostArchiver-clean-upload-20260711-225630/src/database/mod.rs

@@ -0,0 +1,4 @@
+pub mod connection;
+pub mod maintenance;
+pub mod migrations;
+

XPostArchiver-clean-upload-20260711-225630/src/domain/mod.rs

@@ -0,0 +1,2 @@
+
+

XPostArchiver-clean-upload-20260711-225630/src/error.rs

@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+use thiserror::Error;
+
+#[allow(dead_code)]
+#[derive(Debug, Error)]
+pub enum AppError {
+    #[error("API请求失败：{0}")]
+    Api(String),
+    #[error("数据库错误：{0}")]
+    Database(String),
+    #[error("凭据错误：{0}")]
+    Credential(String),
+    #[error("导出失败：{0}")]
+    Export(String),
+    #[error("媒体处理失败：{0}")]
+    Media(String),
+    #[error("配置错误：{0}")]
+    Configuration(String),
+    #[error("任务错误：{0}")]
+    Task(String),
+    #[error("路径不可用：{path}")]
+    PathUnavailable { path: PathBuf },
+    #[error("操作已取消")]
+    Cancelled,
+}
+

XPostArchiver-clean-upload-20260711-225630/src/exporters/mod.rs

@@ -0,0 +1,2 @@
+
+

XPostArchiver-clean-upload-20260711-225630/src/lib.rs

@@ -0,0 +1,8 @@
+pub mod config;
+pub mod database;
+pub mod error;
+pub mod logging;
+pub mod services;
+pub mod tasks;
+pub mod utils;
+

XPostArchiver-clean-upload-20260711-225630/src/logging/mod.rs

@@ -0,0 +1,37 @@
+pub mod rotation;
+
+use std::path::PathBuf;
+
+use directories::ProjectDirs;
+use tracing_subscriber::{EnvFilter, Layer, layer::SubscriberExt, util::SubscriberInitExt};
+
+pub struct LoggingGuard {
+    _file_guard: tracing_appender::non_blocking::WorkerGuard,
+}
+
+pub fn init_logging() -> anyhow::Result<LoggingGuard> {
+    let log_dir = default_log_dir()?;
+    std::fs::create_dir_all(&log_dir)?;
+
+    let file_appender = tracing_appender::rolling::daily(&log_dir, "xpost-archiver.log");
+    let (file_writer, file_guard) = tracing_appender::non_blocking(file_appender);
+
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+    let file_layer = tracing_subscriber::fmt::layer()
+        .with_ansi(false)
+        .with_writer(file_writer)
+        .with_filter(filter);
+
+    tracing_subscriber::registry().with(file_layer).try_init()?;
+
+    Ok(LoggingGuard {
+        _file_guard: file_guard,
+    })
+}
+
+fn default_log_dir() -> anyhow::Result<PathBuf> {
+    let dirs = ProjectDirs::from("cn", "XPostArchiver", "XPostArchiver")
+        .ok_or_else(|| anyhow::anyhow!("无法取得用户配置目录"))?;
+    Ok(dirs.data_local_dir().join("logs"))
+}
+

XPostArchiver-clean-upload-20260711-225630/src/logging/rotation.rs

@@ -0,0 +1,34 @@
+pub fn redact_secret(input: &str) -> String {
+    let mut output = input.to_owned();
+    for marker in [
+        "Bearer ",
+        "token=",
+        "api_key=",
+        "api_secret=",
+        "Authorization:",
+    ] {
+        if let Some(index) = output
+            .to_ascii_lowercase()
+            .find(&marker.to_ascii_lowercase())
+        {
+            let end = output[index..]
+                .find(['\n', '\r', '&'])
+                .map(|offset| index + offset)
+                .unwrap_or(output.len());
+            output.replace_range(index..end, "[REDACTED]");
+        }
+    }
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::redact_secret;
+
+    #[test]
+    fn redacts_bearer_token() {
+        let text = "Authorization: Bearer abcdefghijklmnopqrstuvwxyz";
+        assert!(!redact_secret(text).contains("abcdefghijklmnopqrstuvwxyz"));
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/main.rs

@@ -0,0 +1,13 @@
+mod app;
+mod config;
+mod database;
+mod error;
+mod logging;
+mod services;
+mod tasks;
+mod utils;
+
+fn main() -> anyhow::Result<()> {
+    app::App::bootstrap()?.run()
+}
+

XPostArchiver-clean-upload-20260711-225630/src/security/mod.rs

@@ -0,0 +1,2 @@
+
+

XPostArchiver-clean-upload-20260711-225630/src/services/account_service.rs

@@ -0,0 +1,137 @@
+use chrono::Utc;
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+
+use crate::database::migrations::run_migrations;
+use crate::services::credential_service::read_bearer_token;
+use crate::services::x_api_service::{XAccountProfile, lookup_public_account};
+use crate::tasks::runtime::BackgroundRuntime;
+
+#[derive(Debug, Clone)]
+pub struct AccountLookupResult {
+    pub username: String,
+    pub display_name: Option<String>,
+    pub message: String,
+}
+
+pub fn lookup_account(
+    runtime: &BackgroundRuntime,
+    database_path: &std::path::Path,
+    username: &str,
+) -> anyhow::Result<AccountLookupResult> {
+    let token =
+        read_bearer_token()?.ok_or_else(|| anyhow::anyhow!("请先保存 X API Bearer Token。"))?;
+    let profile = runtime.block_on(lookup_public_account(&token, username))??;
+    runtime.block_on(save_account_profile(database_path, &profile))??;
+
+    Ok(AccountLookupResult {
+        username: profile.username.clone(),
+        display_name: profile.name.clone(),
+        message: format!("已查询并保存公开账号：@{}。", profile.username),
+    })
+}
+
+pub async fn save_account_profile(
+    database_path: &std::path::Path,
+    profile: &XAccountProfile,
+) -> anyhow::Result<()> {
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+
+    let now = Utc::now().to_rfc3339();
+    let metrics = profile.public_metrics.as_ref();
+    sqlx::query(
+        r#"
+        INSERT INTO accounts (
+            x_user_id, username, display_name, description, profile_image_url, created_at_x,
+            protected, verified, followers_count, following_count, post_count,
+            first_seen_at, last_seen_at, raw_json
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(x_user_id) DO UPDATE SET
+            username = excluded.username,
+            display_name = excluded.display_name,
+            description = excluded.description,
+            profile_image_url = excluded.profile_image_url,
+            created_at_x = excluded.created_at_x,
+            protected = excluded.protected,
+            verified = excluded.verified,
+            followers_count = excluded.followers_count,
+            following_count = excluded.following_count,
+            post_count = excluded.post_count,
+            last_seen_at = excluded.last_seen_at,
+            raw_json = excluded.raw_json
+        "#,
+    )
+    .bind(&profile.id)
+    .bind(&profile.username)
+    .bind(&profile.name)
+    .bind(&profile.description)
+    .bind(&profile.profile_image_url)
+    .bind(&profile.created_at)
+    .bind(profile.protected.map(bool_to_i64))
+    .bind(profile.verified.map(bool_to_i64))
+    .bind(metrics.and_then(|value| value.followers_count))
+    .bind(metrics.and_then(|value| value.following_count))
+    .bind(metrics.and_then(|value| value.tweet_count))
+    .bind(&now)
+    .bind(&now)
+    .bind(serde_json::to_string(&profile.raw_json)?)
+    .execute(&mut connection)
+    .await?;
+
+    connection.close().await?;
+    Ok(())
+}
+
+fn bool_to_i64(value: bool) -> i64 {
+    if value { 1 } else { 0 }
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+
+    use super::save_account_profile;
+    use crate::database::connection::open_or_create_database;
+    use crate::services::x_api_service::{XAccountProfile, XAccountPublicMetrics};
+
+    #[tokio::test]
+    async fn saves_account_profile() -> anyhow::Result<()> {
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+
+        let profile = XAccountProfile {
+            id: "123".to_owned(),
+            username: "alice".to_owned(),
+            name: Some("Alice".to_owned()),
+            description: Some("public".to_owned()),
+            profile_image_url: None,
+            created_at: None,
+            protected: Some(false),
+            verified: Some(true),
+            public_metrics: Some(XAccountPublicMetrics {
+                followers_count: Some(10),
+                following_count: Some(2),
+                tweet_count: Some(30),
+            }),
+            raw_json: serde_json::json!({"data":{"id":"123"}}),
+        };
+
+        save_account_profile(&database_path, &profile).await?;
+
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        let username: String =
+            sqlx::query_scalar("SELECT username FROM accounts WHERE x_user_id = '123'")
+                .fetch_one(&pool)
+                .await?;
+
+        assert_eq!(username, "alice");
+        Ok(())
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/archive_export_service.rs

@@ -0,0 +1,167 @@
+use chrono::Utc;
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+use std::path::{Path, PathBuf};
+
+use crate::database::migrations::run_migrations;
+
+#[derive(Debug, Clone)]
+pub struct ArchivedPostSummary {
+    pub x_post_id: String,
+    pub author_username: Option<String>,
+    pub text: Option<String>,
+    pub created_at_x: Option<String>,
+    pub original_url: Option<String>,
+}
+
+#[derive(Debug, Clone)]
+pub struct ArchivePreviewResult {
+    pub posts: Vec<ArchivedPostSummary>,
+    pub message: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct ArchiveExportResult {
+    pub path: PathBuf,
+    pub post_count: usize,
+    pub message: String,
+}
+
+pub async fn preview_posts_for_job(
+    database_path: &Path,
+    job_id: &str,
+    limit: i64,
+) -> anyhow::Result<ArchivePreviewResult> {
+    let posts = load_posts_for_job(database_path, job_id, limit.clamp(1, 50)).await?;
+    Ok(ArchivePreviewResult {
+        message: format!("已读取 {} 条已保存帖子。", posts.len()),
+        posts,
+    })
+}
+
+pub async fn export_posts_for_job_markdown(
+    database_path: &Path,
+    export_dir: &Path,
+    job_id: &str,
+) -> anyhow::Result<ArchiveExportResult> {
+    let posts = load_posts_for_job(database_path, job_id, 500).await?;
+    std::fs::create_dir_all(export_dir)?;
+    let safe_job_id = job_id
+        .trim()
+        .replace(|ch: char| !ch.is_ascii_alphanumeric() && ch != '-', "_");
+    let path = export_dir.join(format!(
+        "x-posts-{}-{}.md",
+        safe_job_id,
+        Utc::now().format("%Y%m%d-%H%M%S")
+    ));
+    std::fs::write(&path, render_markdown(job_id, &posts))?;
+    Ok(ArchiveExportResult {
+        path,
+        post_count: posts.len(),
+        message: format!("已导出 {} 条帖子。", posts.len()),
+    })
+}
+
+async fn load_posts_for_job(
+    database_path: &Path,
+    job_id: &str,
+    limit: i64,
+) -> anyhow::Result<Vec<ArchivedPostSummary>> {
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+    let rows = sqlx::query_as::<
+        _,
+        (
+            String,
+            Option<String>,
+            Option<String>,
+            Option<String>,
+            Option<String>,
+        ),
+    >(
+        r#"
+        SELECT x_post_id, author_username, text, created_at_x, original_url
+        FROM posts
+        WHERE source_job_id = ?
+        ORDER BY COALESCE(created_at_x, first_fetched_at) DESC
+        LIMIT ?
+        "#,
+    )
+    .bind(job_id.trim())
+    .bind(limit)
+    .fetch_all(&mut connection)
+    .await?;
+    connection.close().await?;
+    Ok(rows
+        .into_iter()
+        .map(
+            |(x_post_id, author_username, text, created_at_x, original_url)| ArchivedPostSummary {
+                x_post_id,
+                author_username,
+                text,
+                created_at_x,
+                original_url,
+            },
+        )
+        .collect())
+}
+
+fn render_markdown(job_id: &str, posts: &[ArchivedPostSummary]) -> String {
+    let mut text = format!(
+        "# X 帖子归档\n\n任务 ID：`{}`\n\n共 {} 条帖子。\n\n",
+        job_id,
+        posts.len()
+    );
+    for post in posts {
+        text.push_str(&format!("## {}\n\n", post.x_post_id));
+        if let Some(author) = &post.author_username {
+            text.push_str(&format!("账号：@{}\n\n", author));
+        }
+        if let Some(created_at) = &post.created_at_x {
+            text.push_str(&format!("时间：{}\n\n", created_at));
+        }
+        if let Some(body) = &post.text {
+            text.push_str(body);
+            text.push_str("\n\n");
+        }
+        if let Some(url) = &post.original_url {
+            text.push_str(&format!("原始链接：{}\n\n", url));
+        }
+        text.push_str("---\n\n");
+    }
+    text
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+
+    use super::{export_posts_for_job_markdown, preview_posts_for_job};
+    use crate::database::connection::open_or_create_database;
+
+    #[tokio::test]
+    async fn previews_and_exports_posts_for_job() -> anyhow::Result<()> {
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        sqlx::query(
+            "INSERT INTO posts (x_post_id, author_x_user_id, author_username, text, created_at_x, original_url, first_fetched_at, last_fetched_at, source_job_id) VALUES ('post-1', '123', 'alice', 'hello', '2026-07-11T00:00:00Z', 'https://x.com/alice/status/post-1', 'now', 'now', 'job-1')",
+        )
+        .execute(&pool)
+        .await?;
+
+        let preview = preview_posts_for_job(&database_path, "job-1", 10).await?;
+        assert_eq!(preview.posts.len(), 1);
+        let export =
+            export_posts_for_job_markdown(&database_path, temp_dir.path(), "job-1").await?;
+        let exported = std::fs::read_to_string(export.path)?;
+        assert!(exported.contains("hello"));
+        assert_eq!(export.post_count, 1);
+        Ok(())
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/crawl_task_service.rs

@@ -0,0 +1,199 @@
+use chrono::Utc;
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+use uuid::Uuid;
+
+use crate::config::settings::AppSettings;
+use crate::database::migrations::run_migrations;
+
+#[derive(Debug, Clone)]
+pub struct CrawlTaskResult {
+    pub job_id: String,
+    pub message: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct CrawlTaskSummary {
+    pub job_id: String,
+    pub username: String,
+    pub status: String,
+    pub pages_fetched: i64,
+    pub posts_received: i64,
+    pub posts_inserted: i64,
+    pub last_error: Option<String>,
+    pub created_at: String,
+}
+
+pub async fn create_crawl_task(
+    database_path: &std::path::Path,
+    username: &str,
+    settings: &AppSettings,
+) -> anyhow::Result<CrawlTaskResult> {
+    let username = username.trim().trim_start_matches('@');
+    if username.is_empty() {
+        anyhow::bail!("用户名不能为空。")
+    }
+
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+
+    let account_exists: Option<String> = sqlx::query_scalar(
+        "SELECT x_user_id FROM accounts WHERE lower(username) = lower(?) LIMIT 1",
+    )
+    .bind(username)
+    .fetch_optional(&mut connection)
+    .await?;
+
+    let Some(target_x_user_id) = account_exists else {
+        anyhow::bail!("请先查询并保存公开账号：@{}。", username)
+    };
+
+    let job_id = Uuid::new_v4().to_string();
+    let now = Utc::now().to_rfc3339();
+    sqlx::query(
+        r#"
+        INSERT INTO crawl_jobs (
+            id, target_x_user_id, target_username, task_mode,
+            include_original, include_replies, include_reposts, include_quotes,
+            download_media, status, created_at
+        )
+        VALUES (?, ?, ?, 'timeline', 1, 1, 0, 1, ?, 'created', ?)
+        "#,
+    )
+    .bind(&job_id)
+    .bind(&target_x_user_id)
+    .bind(username)
+    .bind(if settings.save_media_files {
+        1_i64
+    } else {
+        0_i64
+    })
+    .bind(&now)
+    .execute(&mut connection)
+    .await?;
+
+    connection.close().await?;
+    Ok(CrawlTaskResult {
+        job_id,
+        message: format!(
+            "已创建采集任务：@{}。当前只建立任务，不拉取帖子。",
+            username
+        ),
+    })
+}
+
+pub async fn list_recent_crawl_tasks(
+    database_path: &std::path::Path,
+    limit: i64,
+) -> anyhow::Result<Vec<CrawlTaskSummary>> {
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+
+    let rows = sqlx::query_as::<_, (String, String, String, i64, i64, i64, Option<String>, String)>(
+        r#"
+        SELECT id, target_username, status, pages_fetched, posts_received, posts_inserted, last_error, created_at
+        FROM crawl_jobs
+        ORDER BY created_at DESC
+        LIMIT ?
+        "#,
+    )
+    .bind(limit.clamp(1, 50))
+    .fetch_all(&mut connection)
+    .await?;
+
+    connection.close().await?;
+    Ok(rows
+        .into_iter()
+        .map(
+            |(
+                job_id,
+                username,
+                status,
+                pages_fetched,
+                posts_received,
+                posts_inserted,
+                last_error,
+                created_at,
+            )| CrawlTaskSummary {
+                job_id,
+                username,
+                status,
+                pages_fetched,
+                posts_received,
+                posts_inserted,
+                last_error,
+                created_at,
+            },
+        )
+        .collect())
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+
+    use super::{create_crawl_task, list_recent_crawl_tasks};
+    use crate::config::settings::AppSettings;
+    use crate::database::connection::open_or_create_database;
+    use crate::services::account_service::save_account_profile;
+    use crate::services::x_api_service::XAccountProfile;
+
+    #[tokio::test]
+    async fn creates_crawl_task_for_saved_account() -> anyhow::Result<()> {
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        save_account_profile(&database_path, &test_profile()).await?;
+
+        let result = create_crawl_task(&database_path, "alice", &AppSettings::default()).await?;
+
+        assert!(result.message.contains("已创建采集任务"));
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        let status: String = sqlx::query_scalar("SELECT status FROM crawl_jobs WHERE id = ?")
+            .bind(result.job_id)
+            .fetch_one(&pool)
+            .await?;
+        assert_eq!(status, "created");
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn lists_recent_crawl_tasks() -> anyhow::Result<()> {
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        save_account_profile(&database_path, &test_profile()).await?;
+        let created = create_crawl_task(&database_path, "alice", &AppSettings::default()).await?;
+
+        let tasks = list_recent_crawl_tasks(&database_path, 10).await?;
+
+        assert_eq!(tasks.len(), 1);
+        assert_eq!(tasks[0].job_id, created.job_id);
+        assert_eq!(tasks[0].username, "alice");
+        assert_eq!(tasks[0].status, "created");
+        assert_eq!(tasks[0].pages_fetched, 0);
+        Ok(())
+    }
+
+    fn test_profile() -> XAccountProfile {
+        XAccountProfile {
+            id: "123".to_owned(),
+            username: "alice".to_owned(),
+            name: Some("Alice".to_owned()),
+            description: None,
+            profile_image_url: None,
+            created_at: None,
+            protected: Some(false),
+            verified: None,
+            public_metrics: None,
+            raw_json: serde_json::json!({"data":{"id":"123"}}),
+        }
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/credential_service.rs

@@ -0,0 +1,69 @@
+use keyring::Entry;
+
+const SERVICE_NAME: &str = "XPostArchiver";
+const BEARER_TOKEN_ACCOUNT: &str = "x-api-bearer-token";
+
+#[derive(Debug, Clone)]
+pub struct CredentialStatus {
+    pub configured: bool,
+    pub message: String,
+}
+
+pub fn save_bearer_token(token: &str) -> anyhow::Result<CredentialStatus> {
+    let token = token.trim();
+    if token.is_empty() {
+        anyhow::bail!("Bearer Token 不能为空。")
+    }
+
+    let entry = bearer_token_entry()?;
+    entry.set_password(token)?;
+    Ok(CredentialStatus {
+        configured: true,
+        message: "X API Bearer Token 已保存到系统密钥库。".to_owned(),
+    })
+}
+
+pub fn clear_bearer_token() -> anyhow::Result<CredentialStatus> {
+    let entry = bearer_token_entry()?;
+    match entry.delete_credential() {
+        Ok(()) => {}
+        Err(keyring::Error::NoEntry) => {}
+        Err(error) => return Err(error.into()),
+    }
+
+    Ok(CredentialStatus {
+        configured: false,
+        message: "X API Bearer Token 已清除。".to_owned(),
+    })
+}
+
+pub fn bearer_token_status() -> CredentialStatus {
+    match read_bearer_token() {
+        Ok(Some(_)) => CredentialStatus {
+            configured: true,
+            message: "已配置 X API Bearer Token。".to_owned(),
+        },
+        Ok(None) => CredentialStatus {
+            configured: false,
+            message: "尚未配置 X API Bearer Token。".to_owned(),
+        },
+        Err(error) => CredentialStatus {
+            configured: false,
+            message: format!("读取系统密钥库失败：{error}"),
+        },
+    }
+}
+
+pub fn read_bearer_token() -> anyhow::Result<Option<String>> {
+    let entry = bearer_token_entry()?;
+    match entry.get_password() {
+        Ok(token) => Ok(Some(token)),
+        Err(keyring::Error::NoEntry) => Ok(None),
+        Err(error) => Err(error.into()),
+    }
+}
+
+fn bearer_token_entry() -> anyhow::Result<Entry> {
+    Ok(Entry::new(SERVICE_NAME, BEARER_TOKEN_ACCOUNT)?)
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/database_service.rs

@@ -0,0 +1,110 @@
+use std::path::{Path, PathBuf};
+
+use rfd::FileDialog;
+
+use crate::config::settings::AppSettings;
+use crate::database::connection::{open_existing_database, open_or_create_database};
+use crate::database::maintenance::{backup_database, check_database_integrity};
+use crate::tasks::runtime::BackgroundRuntime;
+use crate::utils::disk::system_drive_warning;
+
+#[derive(Debug, Clone)]
+pub struct DatabaseSelectionResult {
+    pub path: PathBuf,
+    pub message: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct DatabaseMaintenanceResult {
+    pub message: String,
+}
+
+pub fn choose_existing_database(
+    runtime: &BackgroundRuntime,
+    settings: &mut AppSettings,
+) -> anyhow::Result<Option<DatabaseSelectionResult>> {
+    let Some(path) = FileDialog::new()
+        .add_filter("SQLite 数据库", &["db", "sqlite", "sqlite3"])
+        .pick_file()
+    else {
+        return Ok(None);
+    };
+
+    runtime.block_on(open_existing_database(&path))??;
+    settings.set_database_path(&path);
+    settings.save()?;
+    Ok(Some(DatabaseSelectionResult {
+        message: message_with_warning("已打开数据库", &path),
+        path,
+    }))
+}
+
+pub fn create_database(
+    runtime: &BackgroundRuntime,
+    settings: &mut AppSettings,
+) -> anyhow::Result<Option<DatabaseSelectionResult>> {
+    let Some(mut path) = FileDialog::new()
+        .add_filter("SQLite 数据库", &["db"])
+        .set_file_name("X公开帖子归档.db")
+        .save_file()
+    else {
+        return Ok(None);
+    };
+
+    if path.extension().is_none() {
+        path.set_extension("db");
+    }
+
+    if path.exists() {
+        anyhow::bail!(
+            "文件已存在，请选择打开已有数据库或更换文件名：{}",
+            path.display()
+        );
+    }
+
+    runtime.block_on(open_or_create_database(&path))??;
+
+    settings.set_database_path(&path);
+    settings.save()?;
+    Ok(Some(DatabaseSelectionResult {
+        message: message_with_warning("已创建数据库", &path),
+        path,
+    }))
+}
+
+pub fn check_current_database(
+    runtime: &BackgroundRuntime,
+    settings: &AppSettings,
+) -> anyhow::Result<DatabaseMaintenanceResult> {
+    let database_path = settings
+        .last_database_path
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("请先选择或新建数据库。"))?;
+    let message = runtime.block_on(check_database_integrity(database_path))??;
+    Ok(DatabaseMaintenanceResult { message })
+}
+
+pub fn backup_current_database(
+    settings: &AppSettings,
+) -> anyhow::Result<DatabaseMaintenanceResult> {
+    let database_path = settings
+        .last_database_path
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("请先选择或新建数据库。"))?;
+    let backup_dir = settings
+        .backup_dir
+        .as_deref()
+        .ok_or_else(|| anyhow::anyhow!("请先设置备份目录。"))?;
+    let result = backup_database(database_path, backup_dir)?;
+    Ok(DatabaseMaintenanceResult {
+        message: format!("数据库已备份到：{}", result.path.display()),
+    })
+}
+
+fn message_with_warning(action: &str, path: &Path) -> String {
+    match system_drive_warning(path) {
+        Some(warning) => format!("{action}。{warning}"),
+        None => action.to_owned(),
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/media_download_service.rs

@@ -0,0 +1,324 @@
+use std::path::{Path, PathBuf};
+
+use chrono::Utc;
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+
+use crate::database::migrations::run_migrations;
+use crate::tasks::runtime::BackgroundRuntime;
+
+#[derive(Debug, Clone)]
+pub struct MediaDownloadResult {
+    pub attempted: usize,
+    pub downloaded: usize,
+    pub skipped: usize,
+    pub failed: usize,
+    pub message: String,
+}
+
+#[derive(Debug)]
+struct PendingMedia {
+    media_key: String,
+    media_type: String,
+    original_url: Option<String>,
+    preview_url: Option<String>,
+}
+
+pub fn download_pending_media(
+    runtime: &BackgroundRuntime,
+    database_path: &Path,
+    media_root: &Path,
+    max_items: usize,
+) -> anyhow::Result<MediaDownloadResult> {
+    runtime.block_on(download_pending_media_async(
+        database_path,
+        media_root,
+        max_items,
+    ))?
+}
+
+pub fn retry_failed_media(
+    runtime: &BackgroundRuntime,
+    database_path: &Path,
+    media_root: &Path,
+    max_items: usize,
+) -> anyhow::Result<MediaDownloadResult> {
+    runtime.block_on(download_media_async(
+        database_path,
+        media_root,
+        max_items,
+        true,
+    ))?
+}
+
+pub async fn download_pending_media_async(
+    database_path: &Path,
+    media_root: &Path,
+    max_items: usize,
+) -> anyhow::Result<MediaDownloadResult> {
+    download_media_async(database_path, media_root, max_items, false).await
+}
+
+async fn download_media_async(
+    database_path: &Path,
+    media_root: &Path,
+    max_items: usize,
+    include_failed: bool,
+) -> anyhow::Result<MediaDownloadResult> {
+    if max_items == 0 {
+        anyhow::bail!("下载数量必须大于 0。")
+    }
+    std::fs::create_dir_all(media_root)?;
+
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+
+    let status_filter = if include_failed {
+        "download_status IN ('metadata_only', 'failed')"
+    } else {
+        "download_status = 'metadata_only'"
+    };
+    let pending_query = format!(
+        "SELECT media_key, media_type, original_url, preview_url FROM media WHERE {status_filter} LIMIT ?"
+    );
+    let pending_rows: Vec<(String, String, Option<String>, Option<String>)> =
+        sqlx::query_as(&pending_query)
+            .bind(max_items as i64)
+            .fetch_all(&mut connection)
+            .await?;
+    let pending: Vec<PendingMedia> = pending_rows
+        .into_iter()
+        .map(
+            |(media_key, media_type, original_url, preview_url)| PendingMedia {
+                media_key,
+                media_type,
+                original_url,
+                preview_url,
+            },
+        )
+        .collect();
+
+    let client = reqwest::Client::new();
+    let mut downloaded = 0_usize;
+    let mut skipped = 0_usize;
+    let mut failed = 0_usize;
+
+    for item in &pending {
+        let Some(url) = item.original_url.as_ref().or(item.preview_url.as_ref()) else {
+            mark_media_failed(&mut connection, &item.media_key, "没有可下载的媒体 URL。").await?;
+            skipped += 1;
+            continue;
+        };
+
+        match download_one_media(&client, media_root, item, url).await {
+            Ok(relative_path) => {
+                mark_media_downloaded(&mut connection, &item.media_key, &relative_path).await?;
+                downloaded += 1;
+            }
+            Err(error) => {
+                mark_media_failed(&mut connection, &item.media_key, &error.to_string()).await?;
+                failed += 1;
+            }
+        }
+    }
+
+    connection.close().await?;
+    Ok(MediaDownloadResult {
+        attempted: pending.len(),
+        downloaded,
+        skipped,
+        failed,
+        message: format!(
+            "媒体下载完成：尝试 {} 个，成功 {} 个，跳过 {} 个，失败 {} 个。",
+            pending.len(),
+            downloaded,
+            skipped,
+            failed
+        ),
+    })
+}
+
+async fn download_one_media(
+    client: &reqwest::Client,
+    media_root: &Path,
+    item: &PendingMedia,
+    url: &str,
+) -> anyhow::Result<String> {
+    let response = client.get(url).send().await?;
+    if !response.status().is_success() {
+        anyhow::bail!("媒体下载返回状态：{}。", response.status().as_u16())
+    }
+    let content_type = response
+        .headers()
+        .get(reqwest::header::CONTENT_TYPE)
+        .and_then(|value| value.to_str().ok())
+        .map(str::to_owned);
+    let bytes = response.bytes().await?;
+    if bytes.is_empty() {
+        anyhow::bail!("媒体响应为空。")
+    }
+
+    let extension = extension_for(url, content_type.as_deref(), &item.media_type);
+    let relative_path = PathBuf::from("media").join(format!("{}.{}", item.media_key, extension));
+    let absolute_path = media_root.join(&relative_path);
+    if let Some(parent) = absolute_path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    std::fs::write(&absolute_path, &bytes)?;
+    Ok(relative_path.to_string_lossy().replace('\\', "/"))
+}
+
+fn extension_for(url: &str, content_type: Option<&str>, media_type: &str) -> &'static str {
+    if let Some(content_type) = content_type {
+        if content_type.contains("png") {
+            return "png";
+        }
+        if content_type.contains("webp") {
+            return "webp";
+        }
+        if content_type.contains("gif") {
+            return "gif";
+        }
+        if content_type.contains("mp4") {
+            return "mp4";
+        }
+        if content_type.contains("jpeg") || content_type.contains("jpg") {
+            return "jpg";
+        }
+    }
+    let lower_url = url.to_ascii_lowercase();
+    for extension in ["png", "webp", "gif", "mp4", "jpg", "jpeg"] {
+        if lower_url.contains(&format!(".{extension}")) {
+            return if extension == "jpeg" {
+                "jpg"
+            } else {
+                extension
+            };
+        }
+    }
+    match media_type {
+        "video" | "animated_gif" => "mp4",
+        _ => "jpg",
+    }
+}
+
+async fn mark_media_downloaded(
+    connection: &mut SqliteConnection,
+    media_key: &str,
+    relative_path: &str,
+) -> anyhow::Result<()> {
+    sqlx::query(
+        "UPDATE media SET download_status = 'downloaded', local_relative_path = ?, downloaded_at = ?, last_error = NULL WHERE media_key = ?",
+    )
+    .bind(relative_path)
+    .bind(Utc::now().to_rfc3339())
+    .bind(media_key)
+    .execute(connection)
+    .await?;
+    Ok(())
+}
+
+async fn mark_media_failed(
+    connection: &mut SqliteConnection,
+    media_key: &str,
+    error: &str,
+) -> anyhow::Result<()> {
+    sqlx::query("UPDATE media SET download_status = 'failed', last_error = ? WHERE media_key = ?")
+        .bind(error)
+        .bind(media_key)
+        .execute(connection)
+        .await?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+    use wiremock::matchers::{method, path};
+    use wiremock::{Mock, MockServer, ResponseTemplate};
+
+    use super::{download_media_async, download_pending_media_async};
+    use crate::database::connection::open_or_create_database;
+
+    #[tokio::test]
+    async fn downloads_pending_media_file() -> anyhow::Result<()> {
+        let server = MockServer::start().await;
+        Mock::given(method("GET"))
+            .and(path("/image.jpg"))
+            .respond_with(
+                ResponseTemplate::new(200)
+                    .insert_header("content-type", "image/jpeg")
+                    .set_body_bytes(vec![1_u8, 2, 3]),
+            )
+            .mount(&server)
+            .await;
+
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        let media_root = temp_dir.path().join("archive");
+        open_or_create_database(&database_path).await?;
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        sqlx::query(
+            "INSERT INTO media (media_key, media_type, original_url, download_status) VALUES ('media-1', 'photo', ?, 'metadata_only')",
+        )
+        .bind(format!("{}/image.jpg", server.uri()))
+        .execute(&pool)
+        .await?;
+
+        let result = download_pending_media_async(&database_path, &media_root, 10).await?;
+
+        assert_eq!(result.attempted, 1);
+        assert_eq!(result.downloaded, 1);
+        let relative_path: String =
+            sqlx::query_scalar("SELECT local_relative_path FROM media WHERE media_key = 'media-1'")
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(relative_path, "media/media-1.jpg");
+        assert!(media_root.join(relative_path).exists());
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn retries_failed_media_file() -> anyhow::Result<()> {
+        let server = MockServer::start().await;
+        Mock::given(method("GET"))
+            .and(path("/image.jpg"))
+            .respond_with(
+                ResponseTemplate::new(200)
+                    .insert_header("content-type", "image/jpeg")
+                    .set_body_bytes(vec![4_u8, 5, 6]),
+            )
+            .mount(&server)
+            .await;
+
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        let media_root = temp_dir.path().join("archive");
+        open_or_create_database(&database_path).await?;
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        sqlx::query(
+            "INSERT INTO media (media_key, media_type, original_url, download_status, last_error) VALUES ('media-retry', 'photo', ?, 'failed', 'old error')",
+        )
+        .bind(format!("{}/image.jpg", server.uri()))
+        .execute(&pool)
+        .await?;
+
+        let result = download_media_async(&database_path, &media_root, 10, true).await?;
+
+        assert_eq!(result.attempted, 1);
+        assert_eq!(result.downloaded, 1);
+        let (status, last_error): (String, Option<String>) = sqlx::query_as(
+            "SELECT download_status, last_error FROM media WHERE media_key = 'media-retry'",
+        )
+        .fetch_one(&pool)
+        .await?;
+        assert_eq!(status, "downloaded");
+        assert_eq!(last_error, None);
+        Ok(())
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/mod.rs

@@ -0,0 +1,10 @@
+pub mod account_service;
+pub mod archive_export_service;
+pub mod crawl_task_service;
+pub mod credential_service;
+pub mod database_service;
+pub mod media_download_service;
+pub mod path_service;
+pub mod post_fetch_service;
+pub mod x_api_service;
+

XPostArchiver-clean-upload-20260711-225630/src/services/path_service.rs

@@ -0,0 +1,44 @@
+use std::path::{Path, PathBuf};
+
+use rfd::FileDialog;
+
+use crate::config::settings::{AppSettings, ConfigPathKind};
+use crate::utils::disk::system_drive_warning;
+
+#[derive(Debug, Clone)]
+pub struct PathSelectionResult {
+    pub kind: ConfigPathKind,
+    pub path: PathBuf,
+    pub message: String,
+}
+
+pub fn choose_config_directory(
+    kind: ConfigPathKind,
+    settings: &mut AppSettings,
+) -> anyhow::Result<Option<PathSelectionResult>> {
+    let Some(path) = FileDialog::new().set_title(kind.label()).pick_folder() else {
+        return Ok(None);
+    };
+
+    if !path.exists() {
+        anyhow::bail!("目录不存在：{}", path.display());
+    }
+
+    settings.set_path(kind, &path);
+    settings.save()?;
+
+    Ok(Some(PathSelectionResult {
+        kind,
+        message: message_with_warning(kind, &path),
+        path,
+    }))
+}
+
+fn message_with_warning(kind: ConfigPathKind, path: &Path) -> String {
+    let action = format!("已设置{}", kind.label());
+    match system_drive_warning(path) {
+        Some(warning) => format!("{action}。{warning}"),
+        None => action,
+    }
+}
+

XPostArchiver-clean-upload-20260711-225630/src/services/post_fetch_service.rs

@@ -0,0 +1,649 @@
+use chrono::Utc;
+use sqlx::{Connection, SqliteConnection, sqlite::SqliteConnectOptions};
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
+use std::time::Duration;
+
+use crate::database::migrations::run_migrations;
+use crate::services::credential_service::read_bearer_token;
+use crate::services::x_api_service::{XMedia, XPost, fetch_user_posts_page};
+use crate::tasks::runtime::BackgroundRuntime;
+
+#[derive(Debug, Clone)]
+pub struct PostFetchResult {
+    pub received: usize,
+    pub saved: usize,
+    pub media_saved: usize,
+    pub has_next_page: bool,
+    pub message: String,
+}
+
+#[derive(Debug, Clone)]
+pub struct AutoCrawlResult {
+    pub pages_fetched: usize,
+    pub posts_received: usize,
+    pub posts_saved: usize,
+    pub media_saved: usize,
+    pub stopped_because_complete: bool,
+    pub stopped_by_request: bool,
+    pub message: String,
+}
+
+pub fn fetch_one_page_for_task(
+    runtime: &BackgroundRuntime,
+    database_path: &std::path::Path,
+    job_id: &str,
+) -> anyhow::Result<PostFetchResult> {
+    let token =
+        read_bearer_token()?.ok_or_else(|| anyhow::anyhow!("请先保存 X API Bearer Token。"))?;
+    runtime.block_on(fetch_one_page_for_task_async(database_path, job_id, &token))?
+}
+
+pub async fn auto_fetch_pages_for_task_owned_async(
+    database_path: std::path::PathBuf,
+    job_id: String,
+    token: String,
+    max_pages: usize,
+    delay_between_pages: Duration,
+    stop_requested: Arc<AtomicBool>,
+) -> anyhow::Result<AutoCrawlResult> {
+    auto_fetch_pages_for_task_async(
+        &database_path,
+        &job_id,
+        &token,
+        max_pages,
+        delay_between_pages,
+        &stop_requested,
+    )
+    .await
+}
+
+pub async fn auto_fetch_pages_for_task_async(
+    database_path: &std::path::Path,
+    job_id: &str,
+    token: &str,
+    max_pages: usize,
+    delay_between_pages: Duration,
+    stop_requested: &AtomicBool,
+) -> anyhow::Result<AutoCrawlResult> {
+    let mut pages_fetched = 0_usize;
+    let mut posts_received = 0_usize;
+    let mut posts_saved = 0_usize;
+    let mut media_saved = 0_usize;
+    let mut stopped_because_complete = false;
+    let mut stopped_by_request = false;
+
+    while max_pages == 0 || pages_fetched < max_pages {
+        if stop_requested.load(Ordering::Relaxed) {
+            stopped_by_request = true;
+            break;
+        }
+        let page = match fetch_one_page_for_task_async(database_path, job_id, token).await {
+            Ok(page) => page,
+            Err(error) => {
+                mark_job_failed(database_path, job_id, &error.to_string()).await?;
+                return Err(error);
+            }
+        };
+        pages_fetched += 1;
+        posts_received += page.received;
+        posts_saved += page.saved;
+        media_saved += page.media_saved;
+        if !page.has_next_page {
+            stopped_because_complete = true;
+            break;
+        }
+        if (max_pages == 0 || pages_fetched < max_pages) && !delay_between_pages.is_zero() {
+            tokio::time::sleep(delay_between_pages).await;
+        }
+        if stop_requested.load(Ordering::Relaxed) {
+            stopped_by_request = true;
+            mark_job_stopped(database_path, job_id).await?;
+            break;
+        }
+    }
+
+    if stopped_by_request && pages_fetched == 0 {
+        mark_job_stopped(database_path, job_id).await?;
+    }
+
+    Ok(AutoCrawlResult {
+        pages_fetched,
+        posts_received,
+        posts_saved,
+        media_saved,
+        stopped_because_complete,
+        stopped_by_request,
+        message: format!(
+            "自动采集结束：拉取 {} 页，收到 {} 条，保存 {} 条，记录媒体 {} 个。{}",
+            pages_fetched,
+            posts_received,
+            posts_saved,
+            media_saved,
+            if stopped_by_request {
+                "已按停止请求结束。"
+            } else if stopped_because_complete {
+                "任务已到末页。"
+            } else {
+                "已达到本次页数上限。"
+            }
+        ),
+    })
+}
+
+async fn mark_job_stopped(database_path: &std::path::Path, job_id: &str) -> anyhow::Result<()> {
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    sqlx::query(
+        "UPDATE crawl_jobs SET status = 'stopped', finished_at = ?, paused_at = ? WHERE id = ?",
+    )
+    .bind(Utc::now().to_rfc3339())
+    .bind(Utc::now().to_rfc3339())
+    .bind(job_id.trim())
+    .execute(&mut connection)
+    .await?;
+    Ok(())
+}
+
+async fn mark_job_failed(
+    database_path: &std::path::Path,
+    job_id: &str,
+    error: &str,
+) -> anyhow::Result<()> {
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    sqlx::query(
+        "UPDATE crawl_jobs SET status = 'failed', finished_at = ?, error_count = error_count + 1, last_error = ? WHERE id = ?",
+    )
+    .bind(Utc::now().to_rfc3339())
+    .bind(error.chars().take(1000).collect::<String>())
+    .bind(job_id.trim())
+    .execute(&mut connection)
+    .await?;
+    Ok(())
+}
+
+pub async fn fetch_one_page_for_task_async(
+    database_path: &std::path::Path,
+    job_id: &str,
+    token: &str,
+) -> anyhow::Result<PostFetchResult> {
+    let options = SqliteConnectOptions::new()
+        .filename(database_path)
+        .create_if_missing(false);
+    let mut connection = SqliteConnection::connect_with(&options).await?;
+    run_migrations(&mut connection).await?;
+
+    let job: Option<(String, String)> = sqlx::query_as(
+        "SELECT target_x_user_id, target_username FROM crawl_jobs WHERE id = ? LIMIT 1",
+    )
+    .bind(job_id.trim())
+    .fetch_optional(&mut connection)
+    .await?;
+    let Some((target_x_user_id, target_username)) = job else {
+        anyhow::bail!("未找到采集任务：{}。", job_id)
+    };
+
+    sqlx::query("UPDATE crawl_jobs SET status = 'running', started_at = COALESCE(started_at, ?) WHERE id = ?")
+        .bind(Utc::now().to_rfc3339())
+        .bind(job_id)
+        .execute(&mut connection)
+        .await?;
+
+    let pagination_token: Option<String> = sqlx::query_scalar(
+        "SELECT pagination_token FROM crawl_checkpoints WHERE job_id = ? LIMIT 1",
+    )
+    .bind(job_id.trim())
+    .fetch_optional(&mut connection)
+    .await?;
+    let page = match fetch_user_posts_page(
+        token,
+        &target_x_user_id,
+        10,
+        pagination_token.as_deref(),
+    )
+    .await
+    {
+        Ok(page) => page,
+        Err(error) => {
+            let now = Utc::now().to_rfc3339();
+            sqlx::query(
+                "UPDATE crawl_jobs SET status = 'failed', finished_at = ?, error_count = error_count + 1, last_error = ? WHERE id = ?",
+            )
+            .bind(&now)
+            .bind(error.to_string().chars().take(1000).collect::<String>())
+            .bind(job_id.trim())
+            .execute(&mut connection)
+            .await?;
+            return Err(error);
+        }
+    };
+    let posts = page.posts;
+    let media = page.media;
+    let received = posts.len();
+    let mut media_saved = 0_usize;
+    for item in &media {
+        save_media(&mut connection, item).await?;
+        media_saved += 1;
+    }
+    let mut saved = 0_usize;
+    for post in &posts {
+        save_post(
+            &mut connection,
+            post,
+            &target_x_user_id,
+            &target_username,
+            job_id,
+        )
+        .await?;
+        saved += 1;
+    }
+
+    let has_next_page = page.next_token.is_some();
+    let next_status = if has_next_page {
+        "page_fetched"
+    } else {
+        "completed"
+    };
+    let checkpoint_updated_at = Utc::now().to_rfc3339();
+    sqlx::query(
+        "INSERT INTO crawl_checkpoints (job_id, pagination_token, last_successful_page, updated_at) VALUES (?, ?, 1, ?) ON CONFLICT(job_id) DO UPDATE SET pagination_token = excluded.pagination_token, last_successful_page = crawl_checkpoints.last_successful_page + 1, updated_at = excluded.updated_at",
+    )
+    .bind(job_id)
+    .bind(&page.next_token)
+    .bind(&checkpoint_updated_at)
+    .execute(&mut connection)
+    .await?;
+
+    sqlx::query(
+        "UPDATE crawl_jobs SET status = ?, finished_at = ?, pages_fetched = pages_fetched + 1, posts_received = posts_received + ?, posts_inserted = posts_inserted + ? WHERE id = ?",
+    )
+    .bind(next_status)
+    .bind(Utc::now().to_rfc3339())
+    .bind(received as i64)
+    .bind(saved as i64)
+    .bind(job_id)
+    .execute(&mut connection)
+    .await?;
+
+    connection.close().await?;
+    Ok(PostFetchResult {
+        received,
+        saved,
+        media_saved,
+        has_next_page,
+        message: format!(
+            "已拉取下一页公开帖子：收到 {} 条，保存 {} 条，记录媒体 {} 个。{}",
+            received,
+            saved,
+            media_saved,
+            if has_next_page {
+                "还有下一页。"
+            } else {
+                "已经没有下一页。"
+            }
+        ),
+    })
+}
+
+async fn save_post(
+    connection: &mut SqliteConnection,
+    post: &XPost,
+    author_x_user_id: &str,
+    author_username: &str,
+    job_id: &str,
+) -> anyhow::Result<()> {
+    let now = Utc::now().to_rfc3339();
+    let original_url = format!("https://x.com/{}/status/{}", author_username, post.id);
+    sqlx::query(
+        r#"
+        INSERT INTO posts (
+            x_post_id, author_x_user_id, author_username, text, created_at_x,
+            original_url, conversation_id, like_count, reply_count, repost_count, quote_count,
+            first_fetched_at, last_fetched_at, source_job_id, raw_json, data_source
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'x_api')
+        ON CONFLICT(x_post_id) DO UPDATE SET
+            text = excluded.text,
+            created_at_x = excluded.created_at_x,
+            original_url = excluded.original_url,
+            conversation_id = excluded.conversation_id,
+            like_count = excluded.like_count,
+            reply_count = excluded.reply_count,
+            repost_count = excluded.repost_count,
+            quote_count = excluded.quote_count,
+            last_fetched_at = excluded.last_fetched_at,
+            source_job_id = excluded.source_job_id,
+            raw_json = excluded.raw_json,
+            data_source = excluded.data_source
+        "#,
+    )
+    .bind(&post.id)
+    .bind(author_x_user_id)
+    .bind(author_username)
+    .bind(&post.text)
+    .bind(&post.created_at)
+    .bind(original_url)
+    .bind(&post.conversation_id)
+    .bind(
+        post.public_metrics
+            .as_ref()
+            .and_then(|value| value.like_count),
+    )
+    .bind(
+        post.public_metrics
+            .as_ref()
+            .and_then(|value| value.reply_count),
+    )
+    .bind(
+        post.public_metrics
+            .as_ref()
+            .and_then(|value| value.retweet_count),
+    )
+    .bind(
+        post.public_metrics
+            .as_ref()
+            .and_then(|value| value.quote_count),
+    )
+    .bind(&now)
+    .bind(&now)
+    .bind(job_id)
+    .bind(serde_json::to_string(&post.raw_json)?)
+    .execute(&mut *connection)
+    .await?;
+
+    for (index, media_key) in post.media_keys.iter().enumerate() {
+        sqlx::query(
+            "INSERT OR REPLACE INTO post_media (post_id, media_key, display_order) VALUES (?, ?, ?)",
+        )
+        .bind(&post.id)
+        .bind(media_key)
+        .bind(index as i64)
+        .execute(&mut *connection)
+        .await?;
+    }
+    Ok(())
+}
+
+async fn save_media(connection: &mut SqliteConnection, media: &XMedia) -> anyhow::Result<()> {
+    sqlx::query(
+        r#"
+        INSERT INTO media (
+            media_key, media_type, original_url, preview_url, width, height, duration_ms,
+            download_status, raw_json
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, 'metadata_only', ?)
+        ON CONFLICT(media_key) DO UPDATE SET
+            media_type = excluded.media_type,
+            original_url = excluded.original_url,
+            preview_url = excluded.preview_url,
+            width = excluded.width,
+            height = excluded.height,
+            duration_ms = excluded.duration_ms,
+            raw_json = excluded.raw_json
+        "#,
+    )
+    .bind(&media.media_key)
+    .bind(&media.media_type)
+    .bind(&media.url)
+    .bind(&media.preview_image_url)
+    .bind(media.width)
+    .bind(media.height)
+    .bind(media.duration_ms)
+    .bind(serde_json::to_string(&media.raw_json)?)
+    .execute(connection)
+    .await?;
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use sqlx::{Connection, SqliteConnection};
+    use std::sync::atomic::AtomicBool;
+    use std::time::Duration;
+    use tempfile::tempdir;
+    use wiremock::matchers::{header, method, path, query_param};
+    use wiremock::{Mock, MockServer, ResponseTemplate};
+
+    use super::{auto_fetch_pages_for_task_async, fetch_one_page_for_task_async};
+    use crate::config::settings::AppSettings;
+    use crate::database::connection::open_or_create_database;
+    use crate::services::account_service::save_account_profile;
+    use crate::services::crawl_task_service::create_crawl_task;
+    use crate::services::x_api_service::{XAccountProfile, set_scoped_test_base_url};
+
+    #[tokio::test]
+    async fn fetches_and_saves_one_page() -> anyhow::Result<()> {
+        let server = MockServer::start().await;
+        let _base_url_guard = set_scoped_test_base_url(server.uri());
+        Mock::given(method("GET"))
+            .and(path("/2/users/123/tweets"))
+            .and(query_param("max_results", "10"))
+            .and(header("authorization", "Bearer test-token"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "data": [
+                    { "id": "post-1", "text": "hello", "created_at": "2026-07-11T00:00:00Z", "public_metrics": { "like_count": 1, "reply_count": 2, "retweet_count": 3, "quote_count": 4 }, "attachments": { "media_keys": ["media-1"] } }
+                ],
+                "includes": {
+                    "media": [
+                        { "media_key": "media-1", "type": "photo", "url": "https://example.com/image.jpg", "width": 640, "height": 480 }
+                    ]
+                },
+                "meta": { "next_token": "next-page" }
+            })))
+            .up_to_n_times(1)
+            .mount(&server)
+            .await;
+        Mock::given(method("GET"))
+            .and(path("/2/users/123/tweets"))
+            .and(query_param("max_results", "10"))
+            .and(query_param("pagination_token", "next-page"))
+            .and(header("authorization", "Bearer test-token"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "data": [
+                    { "id": "post-2", "text": "world", "created_at": "2026-07-11T00:01:00Z" }
+                ],
+                "meta": { "result_count": 1 }
+            })))
+            .mount(&server)
+            .await;
+
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        save_account_profile(&database_path, &test_profile()).await?;
+        let job = create_crawl_task(&database_path, "alice", &AppSettings::default()).await?;
+
+        let result =
+            fetch_one_page_for_task_async(&database_path, &job.job_id, "test-token").await?;
+
+        assert_eq!(result.received, 1);
+        assert_eq!(result.saved, 1);
+        assert_eq!(result.media_saved, 1);
+        assert!(result.has_next_page);
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        let text: String = sqlx::query_scalar("SELECT text FROM posts WHERE x_post_id = 'post-1'")
+            .fetch_one(&pool)
+            .await?;
+        assert_eq!(text, "hello");
+        let media_type: String =
+            sqlx::query_scalar("SELECT media_type FROM media WHERE media_key = 'media-1'")
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(media_type, "photo");
+        let linked_media: String =
+            sqlx::query_scalar("SELECT media_key FROM post_media WHERE post_id = 'post-1'")
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(linked_media, "media-1");
+        let checkpoint: String =
+            sqlx::query_scalar("SELECT pagination_token FROM crawl_checkpoints WHERE job_id = ?")
+                .bind(&job.job_id)
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(checkpoint, "next-page");
+
+        let second_result =
+            fetch_one_page_for_task_async(&database_path, &job.job_id, "test-token").await?;
+        assert_eq!(second_result.received, 1);
+        assert_eq!(second_result.saved, 1);
+        assert_eq!(second_result.media_saved, 0);
+        assert!(!second_result.has_next_page);
+        let second_text: String =
+            sqlx::query_scalar("SELECT text FROM posts WHERE x_post_id = 'post-2'")
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(second_text, "world");
+        let checkpoint_after_second: Option<String> =
+            sqlx::query_scalar("SELECT pagination_token FROM crawl_checkpoints WHERE job_id = ?")
+                .bind(&job.job_id)
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(checkpoint_after_second, None);
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn marks_job_failed_when_post_fetch_fails() -> anyhow::Result<()> {
+        let server = MockServer::start().await;
+        let _base_url_guard = set_scoped_test_base_url(server.uri());
+        Mock::given(method("GET"))
+            .and(path("/2/users/123/tweets"))
+            .and(query_param("max_results", "10"))
+            .and(header("authorization", "Bearer test-token"))
+            .respond_with(ResponseTemplate::new(500).set_body_string("server error"))
+            .mount(&server)
+            .await;
+
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        save_account_profile(&database_path, &test_profile()).await?;
+        let job = create_crawl_task(&database_path, "alice", &AppSettings::default()).await?;
+
+        let result = fetch_one_page_for_task_async(&database_path, &job.job_id, "test-token").await;
+
+        assert!(result.is_err());
+        let pool =
+            sqlx::SqlitePool::connect(&format!("sqlite://{}", database_path.display())).await?;
+        let (status, error_count, last_error): (String, i64, Option<String>) =
+            sqlx::query_as("SELECT status, error_count, last_error FROM crawl_jobs WHERE id = ?")
+                .bind(&job.job_id)
+                .fetch_one(&pool)
+                .await?;
+        assert_eq!(status, "failed");
+        assert_eq!(error_count, 1);
+        assert!(
+            last_error
+                .unwrap_or_default()
+                .contains("X API 返回异常状态")
+        );
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn auto_fetches_until_last_page() -> anyhow::Result<()> {
+        let server = MockServer::start().await;
+        let _base_url_guard = set_scoped_test_base_url(server.uri());
+        Mock::given(method("GET"))
+            .and(path("/2/users/123/tweets"))
+            .and(query_param("max_results", "10"))
+            .and(header("authorization", "Bearer test-token"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "data": [{ "id": "post-a", "text": "first" }],
+                "meta": { "next_token": "next-page" }
+            })))
+            .up_to_n_times(1)
+            .mount(&server)
+            .await;
+        Mock::given(method("GET"))
+            .and(path("/2/users/123/tweets"))
+            .and(query_param("max_results", "10"))
+            .and(query_param("pagination_token", "next-page"))
+            .and(header("authorization", "Bearer test-token"))
+            .respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
+                "data": [{ "id": "post-b", "text": "second" }],
+                "meta": { "result_count": 1 }
+            })))
+            .mount(&server)
+            .await;
+
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        save_account_profile(&database_path, &test_profile()).await?;
+        let job = create_crawl_task(&database_path, "alice", &AppSettings::default()).await?;
+
+        let stop_requested = AtomicBool::new(false);
+        let result = auto_fetch_pages_for_task_async(
+            &database_path,
+            &job.job_id,
+            "test-token",
+            3,
+            Duration::ZERO,
+            &stop_requested,
+        )
+        .await?;
+
+        assert_eq!(result.pages_fetched, 2);
+        assert_eq!(result.posts_received, 2);
+        assert!(result.stopped_because_complete);
+        assert!(!result.stopped_by_request);
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn auto_fetch_respects_stop_request_before_next_page() -> anyhow::Result<()> {
+        let temp_dir = tempdir()?;
+        let database_path = temp_dir.path().join("archive.db");
+        open_or_create_database(&database_path).await?;
+        save_account_profile(&database_path, &test_profile()).await?;
+        let job = create_crawl_task(&database_path, "alice", &AppSettings::default()).await?;
+
+        let stop_requested = AtomicBool::new(true);
+        let result = auto_fetch_pages_for_task_async(
+            &database_path,
+            &job.job_id,
+            "test-token",
+            3,
+            Duration::ZERO,
+            &stop_requested,
+        )
+        .await?;
+
+        let status: String = sqlx::query_scalar("SELECT status FROM crawl_jobs WHERE id = ?")
+            .bind(&job.job_id)
+            .fetch_one(&mut SqliteConnection::connect(&database_path.to_string_lossy()).await?)
+            .await?;
+
+        assert_eq!(result.pages_fetched, 0);
+        assert_eq!(result.posts_received, 0);
+        assert!(result.stopped_by_request);
+        assert!(!result.stopped_because_complete);
+        assert_eq!(status, "stopped");
+        Ok(())
+    }
+
+    fn test_profile() -> XAccountProfile {
+        XAccountProfile {
+            id: "123".to_owned(),
+            username: "alice".to_owned(),
+            name: Some("Alice".to_owned()),
+            description: None,
+            profile_image_url: None,
+            created_at: None,
+            protected: Some(false),
+            verified: None,
+            public_metrics: None,
+            raw_json: serde_json::json!({"data":{"id":"123"}}),
+        }
+    }
+}
+