fix: ignore resolution checks on packet iterleaving stream

* feat: add tool for agent

* feat: archive management

.cursor/rules/ai-features.mdc

@@ -0,0 +1,51 @@
+# AI Features and LangChain Integration
+
+## AI Components
+
+- **LangChain Integration**: Uses `@langchain/core`, `@langchain/deepseek`,
+  `@langchain/langgraph`, `@langchain/ollama`
+- **Whisper Transcription**: Local and online transcription via `whisper-rs` in
+  Rust backend
+- **AI Agent**: Located in [src/lib/agent/](mdc:src/lib/agent/) directory
+
+## Frontend AI Features
+
+- **AI Page**: [src/page/AI.svelte](mdc:src/page/AI.svelte) - Main AI interface
+- **Agent Logic**: [src/lib/agent/](mdc:src/lib/agent/) - AI agent implementation
+- **Interface**: [src/lib/interface.ts](mdc:src/lib/interface.ts)
+  \- AI communication layer
+
+## Backend AI Features
+
+- **Subtitle Generation**:
+  [src-tauri/src/subtitle_generator/](mdc:src-tauri/src/subtitle_generator/) -
+  AI-powered subtitle creation
+- **Whisper Integration**:
+  [src-tauri/src/subtitle_generator.rs](mdc:src-tauri/src/subtitle_generator.rs)
+  \- Speech-to-text processing
+- **CUDA Support**: Optional CUDA acceleration for Whisper via feature flag
+
+## AI Workflows
+
+- **Live Transcription**: Real-time speech-to-text during live streams
+- **Content Summarization**: AI-powered content analysis and summarization
+- **Smart Editing**: AI-assisted video editing and clip generation
+- **Danmaku Processing**: AI analysis of danmaku (bullet comments) streams
+
+## Configuration
+
+- **LLM Settings**: Configure AI models in [src-tauri/config.example.toml](mdc:src-tauri/config.example.toml)
+- **Whisper Models**: Local model configuration for offline transcription
+- **API Keys**: External AI service configuration for online features
+
+## Development Notes
+
+- AI features require proper model configuration
+- CUDA feature enables GPU acceleration for Whisper
+- LangChain integration supports multiple AI providers
+- AI agent can work with both local and cloud-based models
+  description:
+  globs:
+  alwaysApply: true
+
+---

.cursor/rules/build-deployment.mdc

@@ -0,0 +1,62 @@
+# Build and Deployment Configuration
+
+## Build Scripts
+
+- **PowerShell**: [build.ps1](mdc:build.ps1) - Windows build script
+- **FFmpeg Setup**: [ffmpeg_setup.ps1](mdc:ffmpeg_setup.ps1)
+  \- FFmpeg installation script
+- **Version Bump**: [scripts/bump.cjs](mdc:scripts/bump.cjs)
+  \- Version management script
+
+## Package Management
+
+- **Node.js**: [package.json](mdc:package.json) - Frontend dependencies and scripts
+- **Rust**: [src-tauri/Cargo.toml](mdc:src-tauri/Cargo.toml)
+  \- Backend dependencies and features
+- **Lock Files**: [yarn.lock](mdc:yarn.lock) - Yarn dependency lock
+
+## Build Configuration
+
+- **Vite**: [vite.config.ts](mdc:vite.config.ts) - Frontend build tool configuration
+- **Tailwind**: [tailwind.config.cjs](mdc:tailwind.config.cjs) - CSS framework configuration
+- **PostCSS**: [postcss.config.cjs](mdc:postcss.config.cjs) - CSS processing configuration
+- **TypeScript**: [tsconfig.json](mdc:tsconfig.json),
+  [tsconfig.node.json](mdc:tsconfig.node.json) - TypeScript configuration
+
+## Tauri Configuration
+
+- **Main Config**: [src-tauri/tauri.conf.json](mdc:src-tauri/tauri.conf.json)
+  \- Core Tauri settings
+- **Platform Configs**:
+  - [src-tauri/tauri.macos.conf.json](mdc:src-tauri/tauri.macos.conf.json)
+    \- macOS specific
+  - [src-tauri/tauri.linux.conf.json](mdc:src-tauri/tauri.linux.conf.json)
+    \- Linux specific
+  - [src-tauri/tauri.windows.conf.json](mdc:src-tauri/tauri.windows.conf.json)
+    \- Windows specific
+  - [src-tauri/tauri.windows.cuda.conf.json](mdc:src-tauri/tauri.windows.cuda.conf.json)
+    \- Windows with CUDA
+
+## Docker Support
+
+- **Dockerfile**: [Dockerfile](mdc:Dockerfile) - Container deployment configuration
+- **Documentation**: [docs/](mdc:docs/) - VitePress-based documentation site
+
+## Build Commands
+
+- **Frontend**: `yarn build` - Build production frontend
+- **Tauri**: `yarn tauri build` - Build desktop application
+- **Documentation**: `yarn docs:build` - Build documentation site
+- **Type Check**: `yarn check` - TypeScript and Svelte validation
+
+## Deployment Targets
+
+- **Desktop**: Native Tauri applications for Windows, macOS, Linux
+- **Docker**: Containerized deployment option
+- **Documentation**: Static site deployment via VitePress
+- **Assets**: Static asset distribution for web components
+  description:
+  globs:
+  alwaysApply: true
+
+---

.cursor/rules/database-data.mdc

@@ -0,0 +1,61 @@
+# Database and Data Management
+
+## Database Architecture
+
+- **SQLite Database**: Primary data storage using `sqlx` with async runtime
+- **Database Module**: [src-tauri/src/database/](mdc:src-tauri/src/database/)
+  \- Core database operations
+- **Migration System**: [src-tauri/src/migration.rs](mdc:src-tauri/src/migration.rs)
+  \- Database schema management
+
+## Data Models
+
+- **Recording Data**: Stream metadata, recording sessions, and file information
+- **Room Configuration**: Stream room settings and platform credentials
+- **Task Management**: Recording task status and progress tracking
+- **User Preferences**: Application settings and user configurations
+
+## Frontend Data Layer
+
+- **Database Interface**: [src/lib/db.ts](mdc:src/lib/db.ts)
+  \- Frontend database operations
+- **Stores**: [src/lib/stores/](mdc:src/lib/stores/) - State management for data
+- **Version Management**: [src/lib/stores/version.ts](mdc:src/lib/stores/version.ts)
+  \- Version tracking
+
+## Data Operations
+
+- **CRUD Operations**: Create, read, update, delete for all data entities
+- **Query Optimization**: Efficient SQL queries with proper indexing
+- **Transaction Support**: ACID compliance for critical operations
+- **Data Validation**: Input validation and sanitization
+
+## File Management
+
+- **Cache Directory**: [src-tauri/cache/](mdc:src-tauri/cache/)
+  \- Temporary file storage
+- **Upload Directory**: [src-tauri/cache/uploads/](mdc:src-tauri/cache/uploads/)
+  \- User upload storage
+- **Bilibili Cache**: [src-tauri/cache/bilibili/](mdc:src-tauri/cache/bilibili/)
+  \- Platform-specific cache
+
+## Data Persistence
+
+- **SQLite Files**: [src-tauri/data/data_v2.db](mdc:src-tauri/data/data_v2.db)
+  \- Main database file
+- **Write-Ahead Logging**: WAL mode for concurrent access and performance
+- **Backup Strategy**: Database backup and recovery procedures
+- **Migration Handling**: Automatic schema updates and data migration
+
+## Development Guidelines
+
+- Use prepared statements to prevent SQL injection
+- Implement proper error handling for database operations
+- Use transactions for multi-step operations
+- Follow database naming conventions consistently
+- Test database operations with sample data
+  description:
+  globs:
+  alwaysApply: true
+
+---

.cursor/rules/frontend-development.mdc

@@ -0,0 +1,47 @@
+# Frontend Development Guidelines
+
+## Svelte 3 Best Practices
+
+- Use Svelte 3 syntax with `<script>` tags for component logic
+- Prefer reactive statements with `$:` for derived state
+- Use stores from [src/lib/stores/](mdc:src/lib/stores/) for global state management
+- Import components from [src/lib/components/](mdc:src/lib/components/)
+
+## TypeScript Configuration
+
+- Follow the configuration in [tsconfig.json](mdc:tsconfig.json)
+- Use strict type checking with `checkJs: true`
+- Extends `@tsconfig/svelte` for Svelte-specific TypeScript settings
+- Base URL is set to workspace root for clean imports
+
+## Component Structure
+
+- **Page components**: Located in [src/page/](mdc:src/page/) directory
+- **Reusable components**: Located in [src/lib/components/](mdc:src/lib/components/)
+  directory
+- **Layout components**: [src/App.svelte](mdc:src/App.svelte),
+  [src/AppClip.svelte](mdc:src/AppClip.svelte), [src/AppLive.svelte](mdc:src/AppLive.svelte)
+
+## Styling
+
+- Use Tailwind CSS classes for styling
+- Configuration in [tailwind.config.cjs](mdc:tailwind.config.cjs)
+- PostCSS configuration in [postcss.config.cjs](mdc:postcss.config.cjs)
+- Global styles in [src/styles.css](mdc:src/styles.css)
+
+## Entry Points
+
+- **Main app**: [src/main.ts](mdc:src/main.ts) - Main application entry
+- **Clip mode**: [src/main_clip.ts](mdc:src/main_clip.ts) - Clip editing interface
+- **Live mode**: [src/main_live.ts](mdc:src/main_live.ts) - Live streaming interface
+
+## Development Workflow
+
+- Use `yarn dev` for frontend-only development
+- Use `yarn tauri dev` for full Tauri development
+- Use `yarn check` for TypeScript and Svelte type checking
+  description:
+  globs:
+  alwaysApply: true
+
+---

.cursor/rules/project-overview.mdc

@@ -0,0 +1,53 @@
+# BiliBili ShadowReplay Project Overview
+
+This is a Tauri-based desktop application for caching live streams and performing
+real-time editing and submission. It supports Bilibili and Douyin platforms.
+
+## Project Structure
+
+### Frontend (Svelte + TypeScript)
+
+- **Main entry points**: [src/main.ts](mdc:src/main.ts),
+  [src/main_clip.ts](mdc:src/main_clip.ts), [src/main_live.ts](mdc:src/main_live.ts)
+- **App components**: [src/App.svelte](mdc:src/App.svelte),
+  [src/AppClip.svelte](mdc:src/AppClip.svelte), [src/AppLive.svelte](mdc:src/AppLive.svelte)
+- **Pages**: Located in [src/page/](mdc:src/page/) directory
+- **Components**: Located in [src/lib/components/](mdc:src/lib/components/) directory
+- **Stores**: Located in [src/lib/stores/](mdc:src/lib/stores/) directory
+
+### Backend (Rust + Tauri)
+
+- **Main entry**: [src-tauri/src/main.rs](mdc:src-tauri/src/main.rs)
+- **Core modules**:
+  - [src-tauri/src/recorder/](mdc:src-tauri/src/recorder/) - Stream recording functionality
+  - [src-tauri/src/database/](mdc:src-tauri/src/database/) - Database operations
+  - [src-tauri/src/handlers/](mdc:src-tauri/src/handlers/) - Tauri command handlers
+- **Custom crate**:
+  [src-tauri/crates/danmu_stream/](mdc:src-tauri/crates/danmu_stream/) -
+  Danmaku stream processing
+
+### Configuration
+
+- **Frontend config**: [tsconfig.json](mdc:tsconfig.json),
+  [vite.config.ts](mdc:vite.config.ts), [tailwind.config.cjs](mdc:tailwind.config.cjs)
+- **Backend config**: [src-tauri/Cargo.toml](mdc:src-tauri/Cargo.toml), [src-tauri/tauri.conf.json](mdc:src-tauri/tauri.conf.json)
+- **Example config**: [src-tauri/config.example.toml](mdc:src-tauri/config.example.toml)
+
+## Key Technologies
+
+- **Frontend**: Svelte 3, TypeScript, Tailwind CSS, Flowbite
+- **Backend**: Rust, Tauri 2, SQLite, FFmpeg
+- **AI Features**: LangChain, Whisper for transcription
+- **Build Tools**: Vite, VitePress for documentation
+
+## Development Commands
+
+- `yarn dev` - Start development server
+- `yarn tauri dev` - Start Tauri development
+- `yarn build` - Build frontend
+- `yarn docs:dev` - Start documentation server
+  description:
+  globs:
+  alwaysApply: true
+
+---

.cursor/rules/rust-backend.mdc

@@ -0,0 +1,56 @@
+# Rust Backend Development Guidelines
+
+## Project Structure
+
+- **Main entry**: [src-tauri/src/main.rs](mdc:src-tauri/src/main.rs)
+  \- Application entry point
+- **Core modules**:
+  - [src-tauri/src/recorder/](mdc:src-tauri/src/recorder/)
+    \- Stream recording and management
+  - [src-tauri/src/database/](mdc:src-tauri/src/database/)
+    \- SQLite database operations
+  - [src-tauri/src/handlers/](mdc:src-tauri/src/handlers/)
+    \- Tauri command handlers
+  - [src-tauri/src/subtitle_generator/](mdc:src-tauri/src/subtitle_generator/)
+    \- AI-powered subtitle generation
+
+## Custom Crates
+
+- **danmu_stream**: [src-tauri/crates/danmu_stream/](mdc:src-tauri/crates/danmu_stream/)
+  \- Danmaku stream processing library
+
+## Dependencies
+
+- **Tauri 2**: Core framework for desktop app functionality
+- **FFmpeg**: Video/audio processing via `async-ffmpeg-sidecar`
+- **Whisper**: AI transcription via `whisper-rs` (CUDA support available)
+- **LangChain**: AI agent functionality
+- **SQLite**: Database via `sqlx` with async runtime
+
+## Configuration
+
+- **Cargo.toml**: [src-tauri/Cargo.toml](mdc:src-tauri/Cargo.toml)
+  \- Dependencies and features
+- **Tauri config**: [src-tauri/tauri.conf.json](mdc:src-tauri/tauri.conf.json)
+  \- App configuration
+- **Example config**: [src-tauri/config.example.toml](mdc:src-tauri/config.example.toml)
+  \- User configuration template
+
+## Features
+
+- **default**: Includes GUI and core functionality
+- **cuda**: Enables CUDA acceleration for Whisper transcription
+- **headless**: Headless mode without GUI
+- **custom-protocol**: Required for production builds
+
+## Development Commands
+
+- `yarn tauri dev` - Start Tauri development with hot reload
+- `yarn tauri build` - Build production application
+- `cargo check` - Check Rust code without building
+- `cargo test` - Run Rust tests
+  description:
+  globs:
+  alwaysApply: true
+
+---

.cursor/rules/streaming-recording.mdc

@@ -0,0 +1,60 @@
+# Streaming and Recording System
+
+## Core Recording Components
+
+- **Recorder Manager**: [src-tauri/src/recorder_manager.rs](mdc:src-tauri/src/recorder_manager.rs)
+  \- Main recording orchestration
+- **Recorder**: [src-tauri/src/recorder/](mdc:src-tauri/src/recorder/)
+  \- Individual stream recording logic
+- **Danmaku Stream**: [src-tauri/crates/danmu_stream/](mdc:src-tauri/crates/danmu_stream/)
+  \- Custom crate for bullet comment processing
+
+## Supported Platforms
+
+- **Bilibili**: Main platform support with live stream caching
+- **Douyin**: TikTok's Chinese platform support
+- **Multi-stream**: Support for recording multiple streams simultaneously
+
+## Recording Features
+
+- **Live Caching**: Real-time stream recording and buffering
+- **Time-based Clipping**: Extract specific time segments from recorded streams
+- **Danmaku Capture**: Record bullet comments and chat messages
+- **Quality Control**: Configurable recording quality and format options
+
+## Frontend Interfaces
+
+- **Live Mode**: [src/AppLive.svelte](mdc:src/AppLive.svelte)
+  \- Live streaming interface
+- **Clip Mode**: [src/AppClip.svelte](mdc:src/AppClip.svelte)
+  \- Video editing and clipping
+- **Room Management**: [src/page/Room.svelte](mdc:src/page/Room.svelte)
+  \- Stream room configuration
+- **Task Management**: [src/page/Task.svelte](mdc:src/page/Task.svelte)
+  \- Recording task monitoring
+
+## Technical Implementation
+
+- **FFmpeg Integration**: Video/audio processing via `async-ffmpeg-sidecar`
+- **M3U8 Support**: HLS stream processing with `m3u8-rs`
+- **Async Processing**: Non-blocking I/O with `tokio` runtime
+- **Database Storage**: SQLite for metadata and recording information
+
+## Configuration
+
+- **Recording Settings**: Configure in [src-tauri/config.example.toml](mdc:src-tauri/config.example.toml)
+- **FFmpeg Path**: Set FFmpeg binary location for video processing
+- **Storage Paths**: Configure cache and output directories
+- **Quality Settings**: Adjust recording bitrate and format options
+
+## Development Workflow
+
+- Use [src-tauri/src/recorder/](mdc:src-tauri/src/recorder/) for core recording logic
+- Test with [src-tauri/tests/](mdc:src-tauri/tests/) directory
+- Monitor recording progress via progress manager
+- Handle errors gracefully with custom error types
+  description:
+  globs:
+  alwaysApply: true
+
+---

.devcontainer/Dockerfile

@@ -0,0 +1,36 @@
+ARG VARIANT=bookworm-slim
+FROM debian:${VARIANT}
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Arguments
+ARG CONTAINER_USER=vscode
+ARG CONTAINER_GROUP=vscode
+
+# Install dependencies
+RUN apt-get update \
+    && apt-get install -y \
+        build-essential \
+        clang \
+        cmake \
+        curl \
+        file \
+        git \
+        libayatana-appindicator3-dev \
+        librsvg2-dev \
+        libssl-dev \
+        libwebkit2gtk-4.1-dev \
+        libxdo-dev \
+        pkg-config \
+        wget \
+    && apt-get clean -y && rm -rf /var/lib/apt/lists/* /tmp/library-scripts
+
+# Set users
+RUN adduser --disabled-password --gecos "" ${CONTAINER_USER}
+USER ${CONTAINER_USER}
+WORKDIR /home/${CONTAINER_USER}
+
+# Install rustup
+RUN curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal
+ENV PATH=${PATH}:/home/${CONTAINER_USER}/.cargo/bin
+
+CMD [ "/bin/bash" ]

.devcontainer/devcontainer.json

@@ -0,0 +1,31 @@
+{
+    "name": "vscode",
+    "build": {
+        "dockerfile": "Dockerfile",
+        "args": {
+            "CONTAINER_USER": "vscode",
+            "CONTAINER_GROUP": "vscode"
+        }
+    },
+    "features": {
+        "ghcr.io/devcontainers/features/node:1": {
+            "version": "latest"
+        }
+    },
+    "customizations": {
+        "vscode": {
+            "settings": {
+                "lldb.executable": "/usr/bin/lldb",
+                "files.watcherExclude": {
+                    "**/target/**": true
+                }
+            },
+            "extensions": [
+                "vadimcn.vscode-lldb",
+                "rust-lang.rust-analyzer",
+                "tamasfe.even-better-toml"
+            ]
+        }
+    },
+    "remoteUser": "vscode"
+}

.github/CONTRIBUTING.md

@@ -12,7 +12,8 @@
 
 ### Windows
 
-Windows 下分为两个版本，分别是 `cpu` 和 `cuda` 版本。区别在于 Whisper 是否使用 GPU 加速。`cpu` 版本使用 CPU 进行推理，`cuda` 版本使用 GPU 进行推理。
+Windows 下分为两个版本，分别是 `cpu` 和 `cuda` 版本。区别在于 Whisper 是否使用 GPU 加速。
+`cpu` 版本使用 CPU 进行推理，`cuda` 版本使用 GPU 进行推理。
 
 默认运行为 `cpu` 版本，使用 `yarn tauri dev --features cuda` 命令运行 `cuda` 版本。
 
@@ -20,7 +21,9 @@ Windows 下分为两个版本，分别是 `cpu` 和 `cuda` 版本。区别在于
 
 1. 安装 LLVM 且配置相关环境变量，详情见 [LLVM Windows Setup](https://llvm.org/docs/GettingStarted.html#building-llvm-on-windows)；
 
-2. 安装 CUDA Toolkit，详情见 [CUDA Windows Setup](https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html)；要注意，安装时请勾选 **VisualStudio integration**。
+2. 安装 CUDA Toolkit，详情见
+   [CUDA Windows Setup](https://docs.nvidia.com/cuda/cuda-installation-guide-microsoft-windows/index.html)；
+   要注意，安装时请勾选 **VisualStudio integration**。
 
 ### 常见问题
 

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,21 +0,0 @@
----
-name: Bug report
-about: 提交一个 BUG
-title: "[BUG]"
-labels: bug
-assignees: Xinrea
----
-
-**描述：**
-简要描述一下这个 BUG 的现象
-
-**日志和截图：**
-如果可以的话，请尽量附上相关截图和日志文件（日志是位于安装目录下，名为 bsr.log 的文件）。
-
-**相关信息：**
-
-- 程序版本：
-- 系统类型：
-
-**其他**
-任何其他想说的

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,47 @@
+name: Bug Report
+description: 提交 BUG 报告.
+title: "[bug] "
+labels: ["bug"]
+assignees:
+  - Xinrea
+body:
+  - type: checkboxes
+    attributes:
+      label: 提交须知
+      description: 请确认以下内容
+      options:
+        - label: 我是在最新版本上发现的此问题
+          required: true
+        - label: 我已阅读 [常见问题](https://bsr.xinrea.cn/usage/faq.html) 的说明
+          required: true
+  - type: dropdown
+    id: app_type
+    attributes:
+      label: 以哪种方式使用的该软件？
+      multiple: false
+      options:
+        - Docker 镜像
+        - 桌面应用
+  - type: dropdown
+    id: os
+    attributes:
+      label: 运行环境
+      multiple: false
+      options:
+        - Linux
+        - Windows
+        - MacOS
+        - Docker
+  - type: textarea
+    attributes:
+      label: BUG 描述
+      description: 请尽可能详细描述 BUG 的现象以及复现的方法
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: 日志
+      description: 请粘贴日志内容或是上传日志文件（在主窗口的设置页面，提供了一键打开日志目录所在位置的按钮；当你打开日志目录所在位置后，进入 logs 目录，找到后缀名为 log 的文件）
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: 提交一个新功能的建议
-title: "[feature]"
-labels: enhancement
-assignees: Xinrea
-
----
-
-**遇到的问题：**
-在使用过程中遇到了什么问题让你想要提出建议
-
-**想要的功能：**
-想要怎样的新功能来解决这个问题
-
-**通过什么方式实现（有思路的话）：**
-如果有相关的实现思路或者是参考，可以在此提供
-
-**其他：**
-其他任何想说的话

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,13 @@
+name: Feature Request
+description: 提交新功能的需求
+title: "[feature] "
+labels: ["feature"]
+assignees:
+  - Xinrea
+body:
+  - type: textarea
+    attributes:
+      label: 需求描述
+      description: 请尽可能详细描述你想要的新功能
+    validations:
+      required: true

.github/workflows/check.yml

@@ -0,0 +1,46 @@
+name: Rust Check
+
+on:
+  push:
+    paths:
+      - "**/*.rs"
+      - "src-tauri/Cargo.toml"
+      - "src-tauri/Cargo.lock"
+
+jobs:
+  check:
+    runs-on: self-linux
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt clippy
+
+      - name: Install dependencies (ubuntu only)
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf ffmpeg
+
+      - name: Check formatting
+        run: cargo fmt --check
+        working-directory: src-tauri
+
+      - name: Check clippy
+        run: cargo clippy
+        working-directory: src-tauri
+
+      - name: Check clippy (headless)
+        run: cargo clippy --no-default-features --features headless
+        working-directory: src-tauri
+
+      - name: Check tests
+        run: cargo test -v
+        working-directory: src-tauri
+
+      - name: Check tests (headless)
+        run: cargo test --no-default-features --features headless -v
+        working-directory: src-tauri

.github/workflows/main.yml

@@ -59,11 +59,6 @@ jobs:
         if: matrix.platform == 'windows-latest' && matrix.features == 'cuda'
         uses: Jimver/cuda-toolkit@v0.2.24
 
-      - name: Rust cache
-        uses: swatinem/rust-cache@v2
-        with:
-          workspaces: "./src-tauri -> target"
-
       - name: Setup ffmpeg
         if: matrix.platform == 'windows-latest'
         working-directory: ./
@@ -87,6 +82,19 @@ jobs:
           Copy-Item "$cudaPath\cublas64*.dll" -Destination $targetPath
           Copy-Item "$cudaPath\cublasLt64*.dll" -Destination $targetPath
 
+      - name: Get previous tag
+        id: get_previous_tag
+        run: |
+          # Get the previous tag (excluding the current one being pushed)
+          PREVIOUS_TAG=$(git describe --tags --abbrev=0 HEAD~1 2>/dev/null || echo "")
+          if [ -z "$PREVIOUS_TAG" ]; then
+            # If no previous tag found, use the first commit
+            PREVIOUS_TAG=$(git rev-list --max-parents=0 HEAD | head -1)
+          fi
+          echo "previous_tag=$PREVIOUS_TAG" >> $GITHUB_OUTPUT
+          echo "current_tag=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
+        shell: bash
+
       - uses: tauri-apps/tauri-action@v0
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -96,8 +104,7 @@ jobs:
         with:
           tagName: v__VERSION__
           releaseName: "BiliBili ShadowReplay v__VERSION__"
-          releaseBody: "See the assets to download this version and install."
+          releaseBody: "> [!NOTE]\n> 如果你是第一次下载安装，请参考 [安装准备](https://bsr.xinrea.cn/getting-started/installation/desktop.html) 选择合适的版本。\n> Changelog: https://github.com/Xinrea/bili-shadowreplay/compare/${{ steps.get_previous_tag.outputs.previous_tag }}...${{ steps.get_previous_tag.outputs.current_tag }}"
           releaseDraft: true
           prerelease: false
           args: ${{ matrix.args }} ${{ matrix.platform == 'windows-latest' && matrix.features == 'cuda' && '--config src-tauri/tauri.windows.cuda.conf.json' || '' }}
-          includeDebug: true

.gitignore

@@ -11,6 +11,7 @@ node_modules
 dist
 dist-ssr
 *.local
+/target/
 
 # Editor directories and files
 .vscode/*

.markdownlint.json

@@ -0,0 +1,5 @@
+{
+  "MD033": {
+    "allowed_elements": ["nobr", "sup"]
+  }
+}

.pre-commit-config.yaml

@@ -0,0 +1,50 @@
+fail_fast: true
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+
+  - repo: https://github.com/crate-ci/typos
+    rev: v1.36.2
+    hooks:
+      - id: typos
+
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt
+        entry: cargo fmt --manifest-path src-tauri/Cargo.toml --
+        language: system
+        types: [rust]
+        pass_filenames: false # This makes it a lot faster
+
+      - id: cargo-clippy
+        name: cargo clippy
+        language: system
+        types: [rust]
+        pass_filenames: false
+        entry: cargo clippy --manifest-path src-tauri/Cargo.toml
+
+      - id: cargo-clippy-headless
+        name: cargo clippy headless
+        language: system
+        types: [rust]
+        pass_filenames: false
+        entry: cargo clippy --manifest-path src-tauri/Cargo.toml --no-default-features --features headless
+
+      - id: cargo-test
+        name: cargo test
+        language: system
+        types: [rust]
+        pass_filenames: false
+        entry: cargo test --manifest-path src-tauri/Cargo.toml
+
+      - id: cargo-test-headless
+        name: cargo test headless
+        language: system
+        types: [rust]
+        pass_filenames: false
+        entry: cargo test --manifest-path src-tauri/Cargo.toml --no-default-features --features headless

Dockerfile

@@ -23,7 +23,7 @@ COPY . .
 RUN yarn build
 
 # Build Rust backend
-FROM rust:1.86-slim AS rust-builder
+FROM rust:1.90-slim AS rust-builder
 
 WORKDIR /app
 
@@ -65,9 +65,16 @@ RUN apt-get update && apt-get install -y \
     libssl3 \
     ca-certificates \
     fonts-wqy-microhei \
+    netbase \
+    nscd \
     && update-ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
+
+RUN touch /etc/netgroup
+RUN mkdir -p /var/run/nscd && chmod 755 /var/run/nscd
+RUN nscd
+
 # Add /app to PATH
 ENV PATH="/app:${PATH}"
 
@@ -83,4 +90,4 @@ COPY --from=rust-builder /app/src-tauri/ffprobe ./ffprobe
 EXPOSE 3000
 
 # Run the application
-CMD ["./bili-shadowreplay"]
+CMD ["sh", "-c", "nscd && ./bili-shadowreplay"]

README.md

@@ -4,23 +4,27 @@
 
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/xinrea/bili-shadowreplay/main.yml?label=Application%20Build)
 ![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Xinrea/bili-shadowreplay/package.yml?label=Docker%20Build)
-
 ![GitHub Release](https://img.shields.io/github/v/release/xinrea/bili-shadowreplay)
 ![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/xinrea/bili-shadowreplay/total)
+[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/Xinrea/bili-shadowreplay)
 
 BiliBili ShadowReplay 是一个缓存直播并进行实时编辑投稿的工具。通过划定时间区间，并编辑简单的必需信息，即可完成直播切片以及投稿，将整个流程压缩到分钟级。同时，也支持对缓存的历史直播进行回放，以及相同的切片编辑投稿处理流程。
 
 目前仅支持 B 站和抖音平台的直播。
 
-![rooms](docs/public/images/summary.png)
+[![Star History Chart](https://api.star-history.com/svg?repos=Xinrea/bili-shadowreplay&type=Date)](https://www.star-history.com/#Xinrea/bili-shadowreplay&Date)
 
 ## 安装和使用
 
+![rooms](docs/public/images/summary.png)
+
 前往网站查看说明：[BiliBili ShadowReplay](https://bsr.xinrea.cn/)
 
 ## 参与开发
 
-[Contributing](.github/CONTRIBUTING.md)
+可以通过 [DeepWiki](https://deepwiki.com/Xinrea/bili-shadowreplay) 了解本项目。
+
+贡献指南：[Contributing](.github/CONTRIBUTING.md)
 
 ## 赞助
 

_typos.toml

@@ -0,0 +1,2 @@
+[default.extend-identifiers]
+pull_datas = "pull_datas"

docs/.vitepress/config.ts

@@ -1,7 +1,8 @@
 import { defineConfig } from "vitepress";
+import { withMermaid } from "vitepress-plugin-mermaid";
 
 // https://vitepress.dev/reference/site-config
-export default defineConfig({
+export default withMermaid({
   title: "BiliBili ShadowReplay",
   description: "直播录制/实时回放/剪辑/投稿工具",
   themeConfig: {
@@ -18,21 +19,55 @@ export default defineConfig({
       {
         text: "开始使用",
         items: [
-          { text: "安装准备", link: "/getting-started/installation" },
-          { text: "配置使用", link: "/getting-started/configuration" },
-          { text: "FFmpeg 配置", link: "/getting-started/ffmpeg" },
+          {
+            text: "安装准备",
+            items: [
+              {
+                text: "桌面端安装",
+                link: "/getting-started/installation/desktop",
+              },
+              {
+                text: "Docker 安装",
+                link: "/getting-started/installation/docker",
+              },
+            ],
+          },
+          {
+            text: "配置使用",
+            items: [
+              { text: "账号配置", link: "/getting-started/config/account" },
+              { text: "FFmpeg 配置", link: "/getting-started/config/ffmpeg" },
+              { text: "Whisper 配置", link: "/getting-started/config/whisper" },
+              { text: "LLM 配置", link: "/getting-started/config/llm" },
+            ],
+          },
         ],
       },
       {
         text: "说明文档",
         items: [
-          { text: "功能说明", link: "/usage/features" },
+          {
+            text: "功能说明",
+            items: [
+              { text: "工作流程", link: "/usage/features/workflow" },
+              { text: "直播间管理", link: "/usage/features/room" },
+              { text: "切片功能", link: "/usage/features/clip" },
+              { text: "字幕功能", link: "/usage/features/subtitle" },
+              { text: "弹幕功能", link: "/usage/features/danmaku" },
+              { text: "Webhook", link: "/usage/features/webhook" },
+            ],
+          },
           { text: "常见问题", link: "/usage/faq" },
         ],
       },
       {
         text: "开发文档",
-        items: [{ text: "架构设计", link: "/develop/architecture" }],
+        items: [
+          {
+            text: "DeepWiki",
+            link: "https://deepwiki.com/Xinrea/bili-shadowreplay",
+          },
+        ],
       },
     ],
 

docs/develop/architecture.md

@@ -1 +0,0 @@
-# 架构设计

docs/getting-started/config/account.md

@@ -0,0 +1,12 @@
+# 账号配置
+
+要添加直播间，至少需要配置一个同平台的账号。在账号页面，你可以通过添加账号按钮添加一个账号。
+
+- B 站账号：目前支持扫码登录和 Cookie 手动配置两种方式，推荐使用扫码登录
+- 抖音账号：目前仅支持 Cookie 手动配置登陆
+
+## 抖音账号配置
+
+首先确保已经登录抖音，然后打开[个人主页](https://www.douyin.com/user/self)，右键单击网页，在菜单中选择 `检查（Inspect）`，打开开发者工具，切换到 `网络（Network）` 选项卡，然后刷新网页，此时能在列表中找到 `self` 请求（一般是列表中第一个），单击该请求，查看`请求标头`，在 `请求标头` 中找到 `Cookie`，复制该字段的值，粘贴到配置页面的 `Cookie` 输入框中，要注意复制完全。
+
+![DouyinCookie](/images/douyin_cookie.png)

docs/getting-started/config/llm.md

@@ -0,0 +1,9 @@
+# LLM 配置
+
+![LLM](/images/model_config.png)
+
+助手页面的 AI Agent 助手功能需要配置大模型，目前仅支持配置 OpenAI 协议兼容的大模型服务。
+
+本软件并不提供大模型服务，请自行选择服务提供商。要注意，使用 AI Agent 助手需要消耗比普通对话更多的 Token，请确保有足够的 Token 余额。
+
+此外，AI Agent 的功能需要大模型支持 Function Calling 功能，否则无法正常调用工具。

docs/getting-started/config/whisper.md

@@ -0,0 +1,46 @@
+# Whisper 配置
+
+要使用 AI 字幕识别功能，需要在设置页面配置 Whisper。目前可以选择使用本地运行 Whisper 模型，或是使用在线的 Whisper 服务（通常需要付
+费获取 API Key）。
+
+> [!NOTE]
+> 其实有许多更好的中文字幕识别解决方案，但是这类服务通常需要将文件上传到对象存储后异步处理，考虑到实现的复杂度，选择了使用本地运行 Whisper 模型或是使
+> 用在线的 Whisper 服务，在请求返回时能够直接获取字幕生成结果。
+
+## 本地运行 Whisper 模型
+
+![WhisperLocal](/images/whisper_local.png)
+
+如果需要使用本地运行 Whisper 模型进行字幕生成，需要下载 Whisper.cpp 模型，并在设置中指定模型路径。模型文件可以从网络上下载，例如：
+
+- [Whisper.cpp（国内镜像，内容较旧）](https://www.modelscope.cn/models/cjc1887415157/whisper.cpp/files)
+- [Whisper.cpp](https://huggingface.co/ggerganov/whisper.cpp/tree/main)
+
+可以跟据自己的需求选择不同的模型，要注意带有 `en` 的模型是英文模型，其他模型为多语言模型。
+
+模型文件的大小通常意味着其在运行时资源占用的大小，因此请根据电脑配置选择合适的模型。此外，GPU 版本与 CPU 版本在字幕生成速度上存在**巨大差异**，因此
+推荐使用 GPU 版本进行本地处理（目前仅支持 Nvidia GPU）。
+
+## 使用在线 Whisper 服务
+
+![WhisperOnline](/images/whisper_online.png)
+
+如果需要使用在线的 Whisper 服务进行字幕生成，可以在设置中切换为在线 Whisper，并配置好 API Key。提供 Whisper 服务的平台并非只有
+OpenAI 一家，许多云服务平台也提供 Whisper 服务。
+
+## 字幕识别质量的调优
+
+目前在设置中支持设置 Whisper 语言和 Whisper 提示词，这些设置对于本地和在线的 Whisper 服务都有效。
+
+通常情况下，`auto` 语言选项能够自动识别语音语言，并生成相应语言的字幕。如果需要生成其他语言的字幕，或是生成的字幕语言不匹配，可以手动配置指定的语言。
+根据 OpenAI 官方文档中对于 `language` 参数的描述，目前支持的语言包括
+
+Afrikaans, Arabic, Armenian, Azerbaijani, Belarusian, Bosnian, Bulgarian,
+Catalan, Chinese, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish,
+French, Galician, German, Greek, Hebrew, Hindi, Hungarian, Icelandic,
+Indonesian, Italian, Japanese, Kannada, Kazakh, Korean, Latvian, Lithuanian,
+Macedonian, Malay, Marathi, Maori, Nepali, Norwegian, Persian, Polish,
+Portuguese, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili,
+Swedish, Tagalog, Tamil, Thai, Turkish, Ukrainian, Urdu, Vietnamese, and Welsh.
+
+提示词可以优化生成的字幕的风格（也会一定程度上影响质量），要注意，Whisper 无法理解复杂的提示词，你可以在提示词中使用一些简单的描述，让其在选择词汇时使用偏向于提示词所描述的领域相关的词汇，以避免出现毫不相干领域的词汇；或是让它在标点符号的使用上参照提示词的风格。

docs/getting-started/configuration.md

@@ -1,57 +0,0 @@
-# 配置使用
-
-## 账号配置
-
-要添加直播间，至少需要配置一个同平台的账号。在账号页面，你可以通过添加账号按钮添加一个账号。
-
-- B 站账号：目前支持扫码登录和 Cookie 手动配置两种方式，推荐使用扫码登录
-- 抖音账号：目前仅支持 Cookie 手动配置登陆
-
-### 抖音账号配置
-
-首先确保已经登录抖音，然后打开[个人主页](https://www.douyin.com/user/self)，右键单击网页，在菜单中选择 `检查（Inspect）`，打开开发者工具，切换到 `网络（Network）` 选项卡，然后刷新网页，此时能在列表中找到 `self` 请求（一般是列表中第一个），单击该请求，查看`请求标头`，在 `请求标头` 中找到 `Cookie`，复制该字段的值，粘贴到配置页面的 `Cookie` 输入框中，要注意复制完全。
-
-![DouyinCookie](/images/douyin_cookie.png)
-
-## FFmpeg 配置
-
-如果想要使用切片生成和压制功能，请确保 FFmpeg 已正确配置；除了 Windows 平台打包自带 FFmpeg 以外，其他平台需要手动安装 FFmpeg，请参考 [FFmpeg 配置](/getting-started/ffmpeg)。
-
-## Whisper 配置
-
-要使用 AI 字幕识别功能，需要在设置页面配置 Whisper。目前可以选择使用本地运行 Whisper 模型，或是使用在线的 Whisper 服务（通常需要付费获取 API Key）。
-
-> [!NOTE]
-> 其实有许多更好的中文字幕识别解决方案，但是这类服务通常需要将文件上传到对象存储后异步处理，考虑到实现的复杂度，选择了使用本地运行 Whisper 模型或是使用在线的 Whisper 服务，在请求返回时能够直接获取字幕生成结果。
-
-### 本地运行 Whisper 模型
-
-![WhisperLocal](/images/whisper_local.png)
-
-如果需要使用本地运行 Whisper 模型进行字幕生成，需要下载 Whisper.cpp 模型，并在设置中指定模型路径。模型文件可以从网络上下载，例如：
-
-- [Whisper.cpp（国内镜像，内容较旧）](https://www.modelscope.cn/models/cjc1887415157/whisper.cpp/files)
-- [Whisper.cpp](https://huggingface.co/ggerganov/whisper.cpp/tree/main)
-
-可以跟据自己的需求选择不同的模型，要注意带有 `en` 的模型是英文模型，其他模型为多语言模型。
-
-模型文件的大小通常意味着其在运行时资源占用的大小，因此请根据电脑配置选择合适的模型。此外，GPU 版本与 CPU 版本在字幕生成速度上存在**巨大差异**，因此推荐使用 GPU 版本进行本地处理（目前仅支持 Nvidia GPU）。
-
-### 使用在线 Whisper 服务
-
-![WhisperOnline](/images/whisper_online.png)
-
-如果需要使用在线的 Whisper 服务进行字幕生成，可以在设置中切换为在线 Whisper，并配置好 API Key。提供 Whisper 服务的平台并非只有 OpenAI 一家，许多云服务平台也提供 Whisper 服务。
-
-### 字幕识别质量的调优
-
-目前在设置中支持设置 Whisper 语言和 Whisper 提示词，这些设置对于本地和在线的 Whisper 服务都有效。
-
-通常情况下，`auto` 语言选项能够自动识别语音语言，并生成相应语言的字幕。如果需要生成其他语言的字幕，或是生成的字幕语言不匹配，可以手动配置指定的语言。根据 OpenAI 官方文档中对于 `language` 参数的描述，目前支持的语言包括
-
-Afrikaans, Arabic, Armenian, Azerbaijani, Belarusian, Bosnian, Bulgarian, Catalan, Chinese, Croatian, Czech, Danish, Dutch, English, Estonian, Finnish, French, Galician, German, Greek, Hebrew, Hindi, Hungarian, Icelandic, Indonesian, Italian, Japanese, Kannada, Kazakh, Korean, Latvian, Lithuanian, Macedonian, Malay, Marathi, Maori, Nepali, Norwegian, Persian, Polish, Portuguese, Romanian, Russian, Serbian, Slovak, Slovenian, Spanish, Swahili, Swedish, Tagalog, Tamil, Thai, Turkish, Ukrainian, Urdu, Vietnamese, and Welsh.
-
-提示词可以优化生成的字幕的风格（也会一定程度上影响质量），要注意，Whisper 无法理解复杂的提示词，你可以在提示词中使用一些简单的描述，让其在选择词汇时使用偏向于提示词所描述的领域相关的词汇，以避免出现毫不相干领域的词汇；或是让它在标点符号的使用上参照提示词的风格。
-
-
-

docs/getting-started/installation.md

@@ -1,66 +0,0 @@
-# 安装准备
-
-## 桌面端安装
-
-桌面端目前提供了 Windows、Linux 和 MacOS 三个平台的安装包。
-
-安装包分为两个版本，普通版和 debug 版，普通版适合大部分用户使用，debug 版包含了更多的调试信息，适合开发者使用；由于程序会对账号等敏感信息进行管理，请从信任的来源进行下载；所有版本均可在 [GitHub Releases](https://github.com/Xinrea/bili-shadowreplay/releases) 页面下载安装。
-
-### Windows
-
-由于程序内置 Whisper 字幕识别模型支持，Windows 版本分为两种：
-
-- **普通版本**：内置了 Whisper GPU 加速，字幕识别较快，体积较大，只支持 Nvidia 显卡
-- **CPU 版本**： 使用 CPU 进行字幕识别推理，速度较慢
-
-请根据自己的显卡情况选择合适的版本进行下载。
-
-### Linux
-
-Linux 版本目前仅支持使用 CPU 推理，且测试较少，可能存在一些问题，遇到问题请及时反馈。
-
-### MacOS
-
-MacOS 版本内置 Metal GPU 加速；安装后首次运行，会提示无法打开从网络下载的软件，请在设置-隐私与安全性下，选择仍然打开以允许程序运行。
-
-## Docker 部署
-
-BiliBili ShadowReplay 提供了服务端部署的能力，提供 Web 控制界面，可以用于在服务器等无图形界面环境下部署使用。
-
-### 镜像获取
-
-```bash
-# 拉取最新版本
-docker pull ghcr.io/xinrea/bili-shadowreplay:latest
-# 拉取指定版本
-docker pull ghcr.io/xinrea/bili-shadowreplay:2.5.0
-# 速度太慢？从镜像源拉取
-docker pull ghcr.nju.edu.cn/xinrea/bili-shadowreplay:latest
-```
-
-### 镜像使用
-
-使用方法：
-
-```bash
-sudo docker run -it -d\
-    -p 3000:3000 \
-    -v $DATA_DIR:/app/data \
-    -v $CACHE_DIR:/app/cache \
-    -v $OUTPUT_DIR:/app/output \
-    -v $WHISPER_MODEL:/app/whisper_model.bin \
-    --name bili-shadowreplay \
-    ghcr.io/xinrea/bili-shadowreplay:latest
-```
-
-其中：
-
-- `$DATA_DIR`：为数据目录，对应于桌面版的数据目录，
-
-  Windows 下位于 `C:\Users\{用户名}\AppData\Roaming\cn.vjoi.bilishadowreplay`;
-
-  MacOS 下位于 `/Users/{user}/Library/Application Support/cn.vjoi.bilishadowreplay`
-
-- `$CACHE_DIR`：为缓存目录，对应于桌面版的缓存目录；
-- `$OUTPUT_DIR`：为输出目录，对应于桌面版的输出目录；
-- `$WHISPER_MODEL`：为 Whisper 模型文件路径，对应于桌面版的 Whisper 模型文件路径。

docs/getting-started/installation/desktop.md

@@ -0,0 +1,22 @@
+# 桌面端安装
+
+桌面端目前提供了 Windows、Linux 和 MacOS 三个平台的安装包。
+
+由于程序会对账号等敏感信息进行管理，请从信任的来源进行下载；所有版本均可在 [GitHub Releases](https://github.com/Xinrea/bili-shadowreplay/releases) 页面下载安装。
+
+## Windows
+
+由于程序内置 Whisper 字幕识别模型支持，Windows 版本分为两种：
+
+- **普通版本**：内置了 Whisper GPU 加速，字幕识别较快，体积较大，只支持 Nvidia 显卡
+- **CPU 版本**： 使用 CPU 进行字幕识别推理，速度较慢
+
+请根据自己的显卡情况选择合适的版本进行下载。
+
+## Linux
+
+Linux 版本目前仅支持使用 CPU 推理，且测试较少，可能存在一些问题，遇到问题请及时反馈。
+
+## MacOS
+
+MacOS 版本内置 Metal GPU 加速；安装后首次运行，会提示无法打开从网络下载的软件，请在设置-隐私与安全性下，选择仍然打开以允许程序运行。

docs/getting-started/installation/docker.md

@@ -0,0 +1,41 @@
+# Docker 部署
+
+BiliBili ShadowReplay 提供了服务端部署的能力，提供 Web 控制界面，可以用于在服务器等无图形界面环境下部署使用。
+
+## 镜像获取
+
+```bash
+# 拉取最新版本
+docker pull ghcr.io/xinrea/bili-shadowreplay:latest
+# 拉取指定版本
+docker pull ghcr.io/xinrea/bili-shadowreplay:2.5.0
+# 速度太慢？从镜像源拉取
+docker pull ghcr.nju.edu.cn/xinrea/bili-shadowreplay:latest
+```
+
+## 镜像使用
+
+使用方法：
+
+```bash
+sudo docker run -it -d\
+    -p 3000:3000 \
+    -v $DATA_DIR:/app/data \
+    -v $CACHE_DIR:/app/cache \
+    -v $OUTPUT_DIR:/app/output \
+    -v $WHISPER_MODEL:/app/whisper_model.bin \
+    --name bili-shadowreplay \
+    ghcr.io/xinrea/bili-shadowreplay:latest
+```
+
+其中：
+
+- `$DATA_DIR`：为数据目录，对应于桌面版的数据目录，
+
+  Windows 下位于 `C:\Users\{用户名}\AppData\Roaming\cn.vjoi.bilishadowreplay`;
+
+  MacOS 下位于 `/Users/{user}/Library/Application Support/cn.vjoi.bilishadowreplay`
+
+- `$CACHE_DIR`：为缓存目录，对应于桌面版的缓存目录；
+- `$OUTPUT_DIR`：为输出目录，对应于桌面版的输出目录；
+- `$WHISPER_MODEL`：为 Whisper 模型文件路径，对应于桌面版的 Whisper 模型文件路径。

docs/index.md

@@ -11,10 +11,10 @@ hero:
   actions:
     - theme: brand
       text: 开始使用
-      link: /getting-started/installation
+      link: /getting-started/installation/desktop
     - theme: alt
       text: 说明文档
-      link: /usage/features
+      link: /usage/features/workflow
 
 features:
   - icon: 📹

docs/usage/faq.md

@@ -0,0 +1,31 @@
+# 常见问题
+
+## 一、在哪里反馈问题？
+
+你可以前往 [Github Issues](https://github.com/Xinrea/bili-shadowreplay/issues/new?template=bug_report.md) 提交问题，或是加入[反馈交流群](https://qm.qq.com/q/v4lrE6gyum)。
+
+1. 在提交问题前，请先阅读其它常见问题，确保你的问题已有解答；
+2. 其次，请确保你的程序已更新到最新版本；
+3. 最后，你应准备好提供你的程序日志文件，以便更好地定位问题。
+
+## 二、在哪里查看日志？
+
+在主窗口的设置页面，提供了一键打开日志目录所在位置的按钮。当你打开日志目录所在位置后，进入 `logs` 目录，找到后缀名为 `log` 的文件，这便是你需要提供给开发者的日志文件。
+
+## 三、无法预览直播或是生成切片
+
+如果你是 macOS 或 Linux 用户，请确保你已安装了 `ffmpeg` 和 `ffprobe` 工具；如果不知道如何安装，请参考 [FFmpeg 配置](/getting-started/config/ffmpeg)。
+
+如果你是 Windows 用户，程序目录下应当自带了 `ffmpeg` 和 `ffprobe` 工具，如果无法预览直播或是生成切片，请向开发者反馈。
+
+## 四、添加 B 站直播间出现 -352 错误
+
+`-352` 错误是由 B 站风控机制导致的，如果你添加了大量的 B 站直播间进行录制，可以在设置页面调整直播间状态的检查间隔，尽量避免风控；如果你在直播间数量较少的情况下出现该错误，请向开发者反馈。
+
+## 五、录播为什么都是碎片文件？
+
+缓存目录下的录播文件并非用于直接播放或是投稿，而是用于直播流的预览与实时回放。如果你需要录播文件用于投稿，请打开对应录播的预览界面，使用快捷键创建选区，生成所需范围的切片，切片文件为常规的 mp4 文件，位于你所设置的切片目录下。
+
+如果你将 BSR 作为单纯的录播软件使用，在设置中可以开启`整场录播生成`，这样在直播结束后，BSR 会自动生成整场录播的切片。
+
+![整场录播](/images/whole_clip.png)

docs/usage/features/clip.md

@@ -0,0 +1 @@
+# 切片

docs/usage/features/danmaku.md

@@ -0,0 +1 @@
+# 弹幕

docs/usage/features/room.md

@@ -0,0 +1,40 @@
+# 直播间
+
+> [!WARNING]
+> 在添加管理直播间前，请确保账号列表中有对应平台的可用账号。
+
+## 添加直播间
+
+### 手动添加直播间
+
+你可以在 BSR 直播间页面，点击按钮手动添加直播间。你需要选择平台，并输入直播间号。
+
+直播间号通常是直播间网页地址尾部的遗传数字，例如 `https://live.bilibili.com/123456` 中的 `123456`，或是 `https://live.douyin.com/123456` 中的 `123456`。
+
+抖音直播间比较特殊，当未开播时，你无法找到直播间的入口，因此你需要当直播间开播时找到直播间网页地址，并记录其直播间号。
+
+抖音直播间需要输入主播的 sec_uid，你可以在主播主页的 URL 中找到，例如 `https://www.douyin.com/user/MS4wLjABAAAA` 中的 `MS4wLjABAAAA`。
+
+### 使用 DeepLinking 快速添加直播间
+
+<!-- MD033 -->
+
+<video src="/videos/deeplinking.mp4" loop autoplay muted style="border-radius: 10px;"></video>
+
+在浏览器中观看直播时，替换地址栏中直播间地址中的 `https://` 为 `bsr://` 即可快速唤起 BSR 添加直播间。
+
+## 启用/禁用直播间
+
+你可以点击直播间卡片右上角的菜单按钮，选择启用/禁用直播间。
+
+- 启用后，当直播间开播时，会自动开始录制
+- 禁用后，当直播间开播时，不会自动开始录制
+
+## 移除直播间
+
+> [!CAUTION]
+> 移除直播间后，该直播间相关的所有录播都会被删除，请谨慎操作。
+
+你可以点击直播间卡片右上角的菜单按钮，选择移除直播间。
+
+<video src="/videos/room_remove.mp4" loop autoplay muted style="border-radius: 10px;"></video>

docs/usage/features/subtitle.md

@@ -0,0 +1 @@
+# 字幕

docs/usage/features/webhook.md

@@ -0,0 +1,245 @@
+# Webhook
+
+> [!NOTE]
+> 你可以使用 <https://webhook.site> 来测试 Webhook 功能。
+
+## 设置 Webhook
+
+打开 BSR 设置页面，在基础设置中设置 Webhook 地址。
+
+## Webhook Events
+
+### 直播间相关
+
+#### 添加直播间
+
+```json
+{
+  "id": "a96a5e9f-9857-4c13-b889-91da2ace208a",
+  "event": "recorder.added",
+  "payload": {
+    "room_id": 26966466,
+    "created_at": "2025-09-07T03:33:14.258796+00:00",
+    "platform": "bilibili",
+    "auto_start": true,
+    "extra": ""
+  },
+  "timestamp": 1757215994
+}
+```
+
+#### 移除直播间
+
+```json
+{
+  "id": "e33623d4-e040-4390-88f5-d351ceeeace7",
+  "event": "recorder.removed",
+  "payload": {
+    "room_id": 27183290,
+    "created_at": "2025-08-30T10:54:18.569198+00:00",
+    "platform": "bilibili",
+    "auto_start": true,
+    "extra": ""
+  },
+  "timestamp": 1757217015
+}
+```
+
+### 直播相关
+
+> [!NOTE]
+> 直播开始和结束，不意味着录制的开始和结束。
+
+#### 直播开始
+
+```json
+{
+  "id": "f12f3424-f7d8-4b2f-a8b7-55477411482e",
+  "event": "live.started",
+  "payload": {
+    "room_id": 843610,
+    "room_info": {
+      "room_id": 843610,
+      "room_title": "登顶！",
+      "room_cover": "https://i0.hdslb.com/bfs/live/new_room_cover/73aea43f4b4624c314d62fea4b424822fb506dfb.jpg"
+    },
+    "user_info": {
+      "user_id": "475210",
+      "user_name": "Xinrea",
+      "user_avatar": "https://i1.hdslb.com/bfs/face/91beb3bf444b295fe12bae1f3dc6d9fc4fe4c224.jpg"
+    },
+    "total_length": 0,
+    "current_live_id": "",
+    "live_status": false,
+    "is_recording": false,
+    "auto_start": true,
+    "platform": "bilibili"
+  },
+  "timestamp": 1757217190
+}
+```
+
+#### 直播结束
+
+```json
+{
+  "id": "e8b0756a-02f9-4655-b5ae-a170bf9547bd",
+  "event": "live.ended",
+  "payload": {
+    "room_id": 843610,
+    "room_info": {
+      "room_id": 843610,
+      "room_title": "登顶！",
+      "room_cover": "https://i0.hdslb.com/bfs/live/new_room_cover/73aea43f4b4624c314d62fea4b424822fb506dfb.jpg"
+    },
+    "user_info": {
+      "user_id": "475210",
+      "user_name": "Xinrea",
+      "user_avatar": "https://i1.hdslb.com/bfs/face/91beb3bf444b295fe12bae1f3dc6d9fc4fe4c224.jpg"
+    },
+    "total_length": 0,
+    "current_live_id": "",
+    "live_status": true,
+    "is_recording": false,
+    "auto_start": true,
+    "platform": "bilibili"
+  },
+  "timestamp": 1757217365
+}
+```
+
+### 录播相关
+
+#### 开始录制
+
+```json
+{
+  "id": "5ec1ea10-2b31-48fd-8deb-f2d7d2ea5985",
+  "event": "record.started",
+  "payload": {
+    "room_id": 26966466,
+    "room_info": {
+      "room_id": 26966466,
+      "room_title": "早安獭獭栞！下播前抽fufu",
+      "room_cover": "https://i0.hdslb.com/bfs/live/user_cover/b810c36855168034557e905e5916b1dba1761fa4.jpg"
+    },
+    "user_info": {
+      "user_id": "1609526545",
+      "user_name": "栞栞Shiori",
+      "user_avatar": "https://i1.hdslb.com/bfs/face/47e8dbabb895de44ec6cace085d4dc1d40307277.jpg"
+    },
+    "total_length": 0,
+    "current_live_id": "1757216045412",
+    "live_status": true,
+    "is_recording": false,
+    "auto_start": true,
+    "platform": "bilibili"
+  },
+  "timestamp": 1757216045
+}
+```
+
+#### 结束录制
+
+```json
+{
+  "id": "56fd03e5-3965-4c2e-a6a9-bb6932347eb3",
+  "event": "record.ended",
+  "payload": {
+    "room_id": 26966466,
+    "room_info": {
+      "room_id": 26966466,
+      "room_title": "早安獭獭栞！下播前抽fufu",
+      "room_cover": "https://i0.hdslb.com/bfs/live/user_cover/b810c36855168034557e905e5916b1dba1761fa4.jpg"
+    },
+    "user_info": {
+      "user_id": "1609526545",
+      "user_name": "栞栞Shiori",
+      "user_avatar": "https://i1.hdslb.com/bfs/face/47e8dbabb895de44ec6cace085d4dc1d40307277.jpg"
+    },
+    "total_length": 52.96700000000001,
+    "current_live_id": "1757215994597",
+    "live_status": true,
+    "is_recording": true,
+    "auto_start": true,
+    "platform": "bilibili"
+  },
+  "timestamp": 1757216040
+}
+```
+
+#### 删除录播
+
+```json
+{
+  "id": "c32bc811-ab4b-49fd-84c7-897727905d16",
+  "event": "archive.deleted",
+  "payload": {
+    "platform": "bilibili",
+    "live_id": "1756607084705",
+    "room_id": 1967212929,
+    "title": "灶台O.o",
+    "length": 9,
+    "size": 1927112,
+    "created_at": "2025-08-31T02:24:44.728616+00:00",
+    "cover": "bilibili/1967212929/1756607084705/cover.jpg"
+  },
+  "timestamp": 1757176219
+}
+```
+
+### 切片相关
+
+#### 切片生成
+
+```json
+{
+  "id": "f542e0e1-688b-4f1a-8ce1-e5e51530cf5d",
+  "event": "clip.generated",
+  "payload": {
+    "id": 316,
+    "room_id": 27183290,
+    "cover": "[27183290][1757172501727][一起看凡人修仙传][2025-09-07_00-16-11].jpg",
+    "file": "[27183290][1757172501727][一起看凡人修仙传][2025-09-07_00-16-11].mp4",
+    "note": "",
+    "length": 121,
+    "size": 53049119,
+    "status": 0,
+    "bvid": "",
+    "title": "",
+    "desc": "",
+    "tags": "",
+    "area": 0,
+    "created_at": "2025-09-07T00:16:11.747461+08:00",
+    "platform": "bilibili"
+  },
+  "timestamp": 1757175371
+}
+```
+
+#### 切片删除
+
+```json
+{
+  "id": "5c7ca728-753d-4a7d-a0b4-02c997ad2f92",
+  "event": "clip.deleted",
+  "payload": {
+    "id": 313,
+    "room_id": 27183290,
+    "cover": "[27183290][1756903953470][不出非洲之心不下播][2025-09-03_21-10-54].jpg",
+    "file": "[27183290][1756903953470][不出非洲之心不下播][2025-09-03_21-10-54].mp4",
+    "note": "",
+    "length": 32,
+    "size": 18530098,
+    "status": 0,
+    "bvid": "",
+    "title": "",
+    "desc": "",
+    "tags": "",
+    "area": 0,
+    "created_at": "2025-09-03T21:10:54.943682+08:00",
+    "platform": "bilibili"
+  },
+  "timestamp": 1757147617
+}
+```

docs/usage/features/workflow.md

@@ -0,0 +1,30 @@
+# 工作流程
+
+- 直播间：各个平台的直播间
+- 录播：直播流的存档，每次录制会自动生成一场录播记录
+- 切片：从直播流中剪切生成的视频片段
+- 投稿：将切片上传到各个平台（目前仅支持 Bilibili）
+
+下图展示了它们之间的关系：
+
+```mermaid
+flowchart TD
+    A[直播间] -->|录制| B[录播 01]
+    A -->|录制| C[录播 02]
+    A -->|录制| E[录播 N]
+
+    B --> F[直播流预览窗口]
+
+    F -->|区间生成| G[切片 01]
+    F -->|区间生成| H[切片 02]
+    F -->|区间生成| I[切片 N]
+
+    G --> J[切片预览窗口]
+
+    J -->|字幕压制| K[新切片]
+
+    K --> J
+
+    J -->|投稿| L[Bilibili]
+
+```

package.json

@@ -1,7 +1,7 @@
 {
   "name": "bili-shadowreplay",
   "private": true,
-  "version": "2.9.1",
+  "version": "2.13.3",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -11,14 +11,16 @@
     "tauri": "tauri",
     "docs:dev": "vitepress dev docs",
     "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "docs:preview": "vitepress preview docs",
+    "bump": "node scripts/bump.cjs"
   },
   "dependencies": {
     "@langchain/core": "^0.3.64",
     "@langchain/deepseek": "^0.1.0",
     "@langchain/langgraph": "^0.3.10",
     "@langchain/ollama": "^0.2.3",
-    "@tauri-apps/api": "^2.4.1",
+    "@tauri-apps/api": "^2.6.2",
+    "@tauri-apps/plugin-deep-link": "~2",
     "@tauri-apps/plugin-dialog": "~2",
     "@tauri-apps/plugin-fs": "~2",
     "@tauri-apps/plugin-http": "~2",
@@ -40,6 +42,7 @@
     "flowbite": "^2.5.1",
     "flowbite-svelte": "^0.46.16",
     "flowbite-svelte-icons": "^1.6.1",
+    "mermaid": "^11.9.0",
     "postcss": "^8.4.21",
     "svelte": "^3.54.0",
     "svelte-check": "^3.0.0",
@@ -47,8 +50,9 @@
     "tailwindcss": "^3.3.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.4.1",
-    "typescript": "^4.6.4",
+    "typescript": "^5.0.0",
     "vite": "^4.0.0",
-    "vitepress": "^1.6.3"
+    "vitepress": "^1.6.3",
+    "vitepress-plugin-mermaid": "^2.0.17"
   }
 }

scripts/bump.cjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+function updatePackageJson(version) {
+  const packageJsonPath = path.join(process.cwd(), "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+  packageJson.version = version;
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2) + "\n"
+  );
+  console.log(`✅ Updated package.json version to ${version}`);
+}
+
+function updateCargoToml(version) {
+  const cargoTomlPath = path.join(process.cwd(), "src-tauri", "Cargo.toml");
+  let cargoToml = fs.readFileSync(cargoTomlPath, "utf8");
+
+  // Update the version in the [package] section
+  cargoToml = cargoToml.replace(/^version = ".*"$/m, `version = "${version}"`);
+
+  fs.writeFileSync(cargoTomlPath, cargoToml);
+  console.log(`✅ Updated Cargo.toml version to ${version}`);
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error("❌ Please provide a version number");
+    console.error("Usage: yarn bump <version>");
+    console.error("Example: yarn bump 3.1.0");
+    process.exit(1);
+  }
+
+  const version = args[0];
+
+  // Validate version format (simple check)
+  if (!/^\d+\.\d+\.\d+/.test(version)) {
+    console.error(
+      "❌ Invalid version format. Please use semantic versioning (e.g., 3.1.0)"
+    );
+    process.exit(1);
+  }
+
+  try {
+    updatePackageJson(version);
+    updateCargoToml(version);
+    console.log(`🎉 Successfully bumped version to ${version}`);
+  } catch (error) {
+    console.error("❌ Error updating version:", error.message);
+    process.exit(1);
+  }
+}
+
+main();

src-tauri/Cargo.toml

@@ -4,13 +4,20 @@ resolver = "2"
 
 [package]
 name = "bili-shadowreplay"
-version = "1.0.0"
+version = "2.13.3"
 description = "BiliBili ShadowReplay"
 authors = ["Xinrea"]
 license = ""
 repository = ""
 edition = "2021"
 
+[lints.clippy]
+correctness="deny"
+suspicious="deny"
+complexity="deny"
+style="deny"
+perf="deny"
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
@@ -25,7 +32,6 @@ async-std = "1.12.0"
 async-ffmpeg-sidecar = "0.0.1"
 chrono = { version = "0.4.24", features = ["serde"] }
 toml = "0.7.3"
-custom_error = "1.9.2"
 regex = "1.7.3"
 tokio = { version = "1.27.0", features = ["process"] }
 platform-dirs = "0.3.0"
@@ -44,7 +50,7 @@ async-trait = "0.1.87"
 whisper-rs = "0.14.2"
 hound = "3.5.1"
 uuid = { version = "1.4", features = ["v4"] }
-axum = { version = "0.7", features = ["macros"] }
+axum = { version = "0.7", features = ["macros", "multipart"] }
 tower-http = { version = "0.5", features = ["cors", "fs"] }
 futures-core = "0.3"
 futures = "0.3"
@@ -52,6 +58,8 @@ tokio-util = { version = "0.7", features = ["io"] }
 clap = { version = "4.5.37", features = ["derive"] }
 url = "2.5.4"
 srtparse = "0.2.0"
+thiserror = "2"
+deno_core = "0.355"
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem
@@ -71,6 +79,7 @@ gui = [
     "tauri-utils",
     "tauri-plugin-os",
     "tauri-plugin-notification",
+    "tauri-plugin-deep-link",
     "fix-path-env",
     "tauri-build",
 ]
@@ -83,6 +92,7 @@ optional = true
 [dependencies.tauri-plugin-single-instance]
 version = "2"
 optional = true
+features = ["deep-link"]
 
 [dependencies.tauri-plugin-dialog]
 version = "2"
@@ -117,6 +127,10 @@ optional = true
 version = "2"
 optional = true
 
+[dependencies.tauri-plugin-deep-link]
+version = "2"
+optional = true
+
 [dependencies.fix-path-env]
 git = "https://github.com/tauri-apps/fix-path-env-rs"
 optional = true

src-tauri/build.rs

@@ -1,4 +1,4 @@
 fn main() {
     #[cfg(feature = "gui")]
-    tauri_build::build()
+    tauri_build::build();
 }

src-tauri/capabilities/migrated.json

@@ -49,6 +49,9 @@
         },
         {
           "url": "https://*.douyinpic.com/"
+        },
+        {
+          "url": "http://tauri.localhost/*"
         }
       ]
     },
@@ -65,6 +68,7 @@
     "shell:default",
     "sql:default",
     "os:default",
-    "dialog:default"
+    "dialog:default",
+    "deep-link:default"
   ]
 }

src-tauri/crates/danmu_stream/Cargo.toml

@@ -7,38 +7,42 @@ edition = "2021"
 name = "danmu_stream"
 path = "src/lib.rs"
 
+[[example]]
+name = "bilibili"
+path = "examples/bilibili.rs"
+
 [[example]]
 name = "douyin"
 path = "examples/douyin.rs"
 
 [dependencies]
-tokio = { version = "1.0", features = ["full"] }
-tokio-tungstenite = { version = "0.20", features = ["native-tls"] }
+tokio = { version = "1", features = ["full"] }
+tokio-tungstenite = { version = "0.27", features = ["native-tls"] }
 futures-util = "0.3"
-prost = "0.12"
+prost = "0.14"
 chrono = "0.4"
 log = "0.4"
-env_logger = "0.10"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-reqwest = { version = "0.11", features = ["json"] }
+env_logger = "0.11"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+reqwest = { version = "0.12", features = ["json"] }
 url = "2.4"
-md5 = "0.7"
+md5 = "0.8"
 regex = "1.9"
-deno_core = "0.242.0"
-pct-str = "2.0.0"
-custom_error = "1.9.2"
+deno_core = "0.355"
+pct-str = "2.0"
+thiserror = "2.0"
 flate2 = "1.0"
-scroll = "0.13.0"
-scroll_derive = "0.13.0"
-brotli = "8.0.1"
+scroll = "0.13"
+scroll_derive = "0.13"
+brotli = "8.0"
 http = "1.0"
-rand = "0.9.1"
-urlencoding = "2.1.3"
+rand = "0.9"
+urlencoding = "2.1"
 gzip = "0.1.2"
 hex = "0.4.3"
-async-trait = "0.1.88"
-uuid = "1.17.0"
+async-trait = "0.1"
+uuid = "1"
 
 [build-dependencies]
-tonic-build = "0.10"
+tonic-build = "0.14"

src-tauri/crates/danmu_stream/src/danmu_stream.rs

@@ -1,16 +1,17 @@
 use std::sync::Arc;
 
+use tokio::sync::{mpsc, RwLock};
+
 use crate::{
     provider::{new, DanmuProvider, ProviderType},
     DanmuMessageType, DanmuStreamError,
 };
-use tokio::sync::{mpsc, RwLock};
 
 #[derive(Clone)]
 pub struct DanmuStream {
     pub provider_type: ProviderType,
     pub identifier: String,
-    pub room_id: u64,
+    pub room_id: i64,
     pub provider: Arc<RwLock<Box<dyn DanmuProvider>>>,
     tx: mpsc::UnboundedSender<DanmuMessageType>,
     rx: Arc<RwLock<mpsc::UnboundedReceiver<DanmuMessageType>>>,
@@ -20,7 +21,7 @@ impl DanmuStream {
     pub async fn new(
         provider_type: ProviderType,
         identifier: &str,
-        room_id: u64,
+        room_id: i64,
     ) -> Result<Self, DanmuStreamError> {
         let (tx, rx) = mpsc::unbounded_channel();
         let provider = new(provider_type, identifier, room_id).await?;

src-tauri/crates/danmu_stream/src/http_client.rs

@@ -1,19 +1,8 @@
 use std::time::Duration;
 
-use crate::DanmuStreamError;
 use reqwest::header::HeaderMap;
 
-impl From<reqwest::Error> for DanmuStreamError {
-    fn from(value: reqwest::Error) -> Self {
-        Self::HttpError { err: value }
-    }
-}
-
-impl From<url::ParseError> for DanmuStreamError {
-    fn from(value: url::ParseError) -> Self {
-        Self::ParseError { err: value }
-    }
-}
+use crate::DanmuStreamError;
 
 pub struct ApiClient {
     client: reqwest::Client,

src-tauri/crates/danmu_stream/src/lib.rs

@@ -2,16 +2,24 @@ pub mod danmu_stream;
 mod http_client;
 pub mod provider;
 
-use custom_error::custom_error;
+use thiserror::Error;
 
-custom_error! {pub DanmuStreamError
-    HttpError {err: reqwest::Error} = "HttpError {err}",
-    ParseError {err: url::ParseError} = "ParseError {err}",
-    WebsocketError {err: String } = "WebsocketError {err}",
-    PackError {err: String} = "PackError {err}",
-    UnsupportProto {proto: u16} = "UnsupportProto {proto}",
-    MessageParseError {err: String} = "MessageParseError {err}",
-    InvalidIdentifier {err: String} = "InvalidIdentifier {err}"
+#[derive(Error, Debug)]
+pub enum DanmuStreamError {
+    #[error("HttpError {0:?}")]
+    HttpError(#[from] reqwest::Error),
+    #[error("ParseError {0:?}")]
+    ParseError(#[from] url::ParseError),
+    #[error("WebsocketError {err}")]
+    WebsocketError { err: String },
+    #[error("PackError {err}")]
+    PackError { err: String },
+    #[error("UnsupportProto {proto}")]
+    UnsupportProto { proto: u16 },
+    #[error("MessageParseError {err}")]
+    MessageParseError { err: String },
+    #[error("InvalidIdentifier {err}")]
+    InvalidIdentifier { err: String },
 }
 
 #[derive(Debug)]
@@ -21,7 +29,7 @@ pub enum DanmuMessageType {
 
 #[derive(Debug, Clone)]
 pub struct DanmuMessage {
-    pub room_id: u64,
+    pub room_id: i64,
     pub user_id: u64,
     pub user_name: String,
     pub message: String,

src-tauri/crates/danmu_stream/src/provider/bilibili.rs

@@ -36,15 +36,15 @@ type WsWriteType = futures_util::stream::SplitSink<
 
 pub struct BiliDanmu {
     client: ApiClient,
-    room_id: u64,
-    user_id: u64,
+    room_id: i64,
+    user_id: i64,
     stop: Arc<RwLock<bool>>,
     write: Arc<RwLock<Option<WsWriteType>>>,
 }
 
 #[async_trait]
 impl DanmuProvider for BiliDanmu {
-    async fn new(cookie: &str, room_id: u64) -> Result<Self, DanmuStreamError> {
+    async fn new(cookie: &str, room_id: i64) -> Result<Self, DanmuStreamError> {
         // find DedeUserID=<user_id> in cookie str
         let user_id = BiliDanmu::parse_user_id(cookie)?;
         // add buvid3 to cookie
@@ -65,7 +65,6 @@ impl DanmuProvider for BiliDanmu {
         tx: mpsc::UnboundedSender<DanmuMessageType>,
     ) -> Result<(), DanmuStreamError> {
         let mut retry_count = 0;
-        const MAX_RETRIES: u32 = 5;
         const RETRY_DELAY: Duration = Duration::from_secs(5);
         info!(
             "Bilibili WebSocket connection started, room_id: {}",
@@ -74,33 +73,37 @@ impl DanmuProvider for BiliDanmu {
 
         loop {
             if *self.stop.read().await {
+                info!(
+                    "Bilibili WebSocket connection stopped, room_id: {}",
+                    self.room_id
+                );
                 break;
             }
 
             match self.connect_and_handle(tx.clone()).await {
                 Ok(_) => {
-                    info!("Bilibili WebSocket connection closed normally");
-                    break;
+                    info!(
+                        "Bilibili WebSocket connection closed normally, room_id: {}",
+                        self.room_id
+                    );
+                    retry_count = 0;
                 }
                 Err(e) => {
-                    error!("Bilibili WebSocket connection error: {}", e);
-                    retry_count += 1;
-
-                    if retry_count >= MAX_RETRIES {
-                        return Err(DanmuStreamError::WebsocketError {
-                            err: format!("Failed to connect after {} retries", MAX_RETRIES),
-                        });
-                    }
-
-                    info!(
-                        "Retrying connection in {} seconds... (Attempt {}/{})",
-                        RETRY_DELAY.as_secs(),
-                        retry_count,
-                        MAX_RETRIES
+                    error!(
+                        "Bilibili WebSocket connection error, room_id: {}, error: {}",
+                        self.room_id, e
                     );
-                    tokio::time::sleep(RETRY_DELAY).await;
+                    retry_count += 1;
                 }
             }
+
+            info!(
+                "Retrying connection in {} seconds... (Attempt {}), room_id: {}",
+                RETRY_DELAY.as_secs(),
+                retry_count,
+                self.room_id
+            );
+            tokio::time::sleep(RETRY_DELAY).await;
         }
 
         Ok(())
@@ -123,7 +126,8 @@ impl BiliDanmu {
         tx: mpsc::UnboundedSender<DanmuMessageType>,
     ) -> Result<(), DanmuStreamError> {
         let wbi_key = self.get_wbi_key().await?;
-        let danmu_info = self.get_danmu_info(&wbi_key, self.room_id).await?;
+        let real_room = self.get_real_room(&wbi_key, self.room_id).await?;
+        let danmu_info = self.get_danmu_info(&wbi_key, real_room).await?;
         let ws_hosts = danmu_info.data.host_list.clone();
         let mut conn = None;
         log::debug!("ws_hosts: {:?}", ws_hosts);
@@ -152,7 +156,7 @@ impl BiliDanmu {
         *self.write.write().await = Some(write);
 
         let json = serde_json::to_string(&WsSend {
-            roomid: self.room_id,
+            roomid: real_room,
             key: danmu_info.data.token,
             uid: self.user_id,
             protover: 3,
@@ -237,9 +241,8 @@ impl BiliDanmu {
     async fn get_danmu_info(
         &self,
         wbi_key: &str,
-        room_id: u64,
+        room_id: i64,
     ) -> Result<DanmuInfo, DanmuStreamError> {
-        let room_id = self.get_real_room(wbi_key, room_id).await?;
         let params = self
             .get_sign(
                 wbi_key,
@@ -265,7 +268,7 @@ impl BiliDanmu {
         Ok(resp)
     }
 
-    async fn get_real_room(&self, wbi_key: &str, room_id: u64) -> Result<u64, DanmuStreamError> {
+    async fn get_real_room(&self, wbi_key: &str, room_id: i64) -> Result<i64, DanmuStreamError> {
         let params = self
             .get_sign(
                 wbi_key,
@@ -293,14 +296,14 @@ impl BiliDanmu {
         Ok(resp)
     }
 
-    fn parse_user_id(cookie: &str) -> Result<u64, DanmuStreamError> {
+    fn parse_user_id(cookie: &str) -> Result<i64, DanmuStreamError> {
         let mut user_id = None;
 
         // find DedeUserID=<user_id> in cookie str
         let re = Regex::new(r"DedeUserID=(\d+)").unwrap();
         if let Some(captures) = re.captures(cookie) {
             if let Some(user) = captures.get(1) {
-                user_id = Some(user.as_str().parse::<u64>().unwrap());
+                user_id = Some(user.as_str().parse::<i64>().unwrap());
             }
         }
 
@@ -404,8 +407,8 @@ impl BiliDanmu {
 
 #[derive(Serialize)]
 struct WsSend {
-    uid: u64,
-    roomid: u64,
+    uid: i64,
+    roomid: i64,
     key: String,
     protover: u32,
     platform: String,
@@ -436,5 +439,5 @@ pub struct RoomInit {
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct RoomInitData {
-    room_id: u64,
+    room_id: i64,
 }

src-tauri/crates/danmu_stream/src/provider/bilibili/dannmu_msg.rs

@@ -1,6 +1,8 @@
 use serde::Deserialize;
 
-use crate::{provider::bilibili::stream::WsStreamCtx, DanmuStreamError};
+use super::stream::WsStreamCtx;
+
+use crate::DanmuStreamError;
 
 #[derive(Debug, Deserialize)]
 #[allow(dead_code)]

src-tauri/crates/danmu_stream/src/provider/bilibili/interact_word.rs

@@ -1,4 +1,6 @@
-use crate::{provider::bilibili::stream::WsStreamCtx, DanmuStreamError};
+use super::stream::WsStreamCtx;
+
+use crate::DanmuStreamError;
 
 #[derive(Debug)]
 #[allow(dead_code)]

src-tauri/crates/danmu_stream/src/provider/bilibili/pack.rs

@@ -24,7 +24,7 @@ struct PackHotCount {
 
 type BilibiliPackCtx<'a> = (BilibiliPackHeader, &'a [u8]);
 
-fn pack(buffer: &[u8]) -> Result<BilibiliPackCtx, DanmuStreamError> {
+fn pack(buffer: &[u8]) -> Result<BilibiliPackCtx<'_>, DanmuStreamError> {
     let data = buffer
         .pread_with(0, scroll::BE)
         .map_err(|e: scroll::Error| DanmuStreamError::PackError { err: e.to_string() })?;

src-tauri/crates/danmu_stream/src/provider/bilibili/send_gift.rs

@@ -1,6 +1,8 @@
 use serde::Deserialize;
 
-use crate::{provider::bilibili::stream::WsStreamCtx, DanmuStreamError};
+use super::stream::WsStreamCtx;
+
+use crate::DanmuStreamError;
 
 #[derive(Debug, Deserialize)]
 #[allow(dead_code)]

src-tauri/crates/danmu_stream/src/provider/bilibili/stream.rs

@@ -1,10 +1,9 @@
 use serde::Deserialize;
 use serde_json::Value;
 
-use crate::{
-    provider::{bilibili::dannmu_msg::BiliDanmuMessage, DanmuMessageType},
-    DanmuMessage, DanmuStreamError,
-};
+use super::dannmu_msg::BiliDanmuMessage;
+
+use crate::{provider::DanmuMessageType, DanmuMessage, DanmuStreamError};
 
 #[derive(Debug, Deserialize, Clone)]
 pub struct WsStreamCtx {

src-tauri/crates/danmu_stream/src/provider/bilibili/super_chat.rs

@@ -1,6 +1,8 @@
 use serde::Deserialize;
 
-use crate::{provider::bilibili::stream::WsStreamCtx, DanmuStreamError};
+use super::stream::WsStreamCtx;
+
+use crate::DanmuStreamError;
 
 #[derive(Debug, Deserialize)]
 #[allow(dead_code)]

src-tauri/crates/danmu_stream/src/provider/douyin.rs

@@ -1,4 +1,9 @@
-use crate::{provider::DanmuProvider, DanmuMessage, DanmuMessageType, DanmuStreamError};
+mod messages;
+
+use std::io::Read;
+use std::sync::Arc;
+use std::time::{Duration, SystemTime};
+
 use async_trait::async_trait;
 use deno_core::v8;
 use deno_core::JsRuntime;
@@ -7,11 +12,9 @@ use flate2::read::GzDecoder;
 use futures_util::{SinkExt, StreamExt, TryStreamExt};
 use log::debug;
 use log::{error, info};
+use messages::*;
 use prost::bytes::Bytes;
 use prost::Message;
-use std::io::Read;
-use std::sync::Arc;
-use std::time::{Duration, SystemTime};
 use tokio::net::TcpStream;
 use tokio::sync::mpsc;
 use tokio::sync::RwLock;
@@ -19,8 +22,7 @@ use tokio_tungstenite::{
     connect_async, tungstenite::Message as WsMessage, MaybeTlsStream, WebSocketStream,
 };
 
-mod messages;
-use messages::*;
+use crate::{provider::DanmuProvider, DanmuMessage, DanmuMessageType, DanmuStreamError};
 
 const USER_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
 
@@ -31,7 +33,7 @@ type WsWriteType =
     futures_util::stream::SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, WsMessage>;
 
 pub struct DouyinDanmu {
-    room_id: u64,
+    room_id: i64,
     cookie: String,
     stop: Arc<RwLock<bool>>,
     write: Arc<RwLock<Option<WsWriteType>>>,
@@ -109,7 +111,7 @@ impl DouyinDanmu {
         runtime
             .execute_script(
                 "<crypto-js.min.js>",
-                deno_core::FastString::Static(crypto_js),
+                deno_core::FastString::from_static(crypto_js),
             )
             .map_err(|e| DanmuStreamError::WebsocketError {
                 err: format!("Failed to execute crypto-js: {}", e),
@@ -118,7 +120,7 @@ impl DouyinDanmu {
         // Load and execute the sign.js file
         let js_code = include_str!("douyin/webmssdk.js");
         runtime
-            .execute_script("<sign.js>", deno_core::FastString::Static(js_code))
+            .execute_script("<sign.js>", deno_core::FastString::from_static(js_code))
             .map_err(|e| DanmuStreamError::WebsocketError {
                 err: format!("Failed to execute JavaScript: {}", e),
             })?;
@@ -126,10 +128,7 @@ impl DouyinDanmu {
         // Call the get_wss_url function
         let sign_call = format!("get_wss_url(\"{}\")", self.room_id);
         let result = runtime
-            .execute_script(
-                "<sign_call>",
-                deno_core::FastString::Owned(sign_call.into_boxed_str()),
-            )
+            .execute_script("<sign_call>", deno_core::FastString::from(sign_call))
             .map_err(|e| DanmuStreamError::WebsocketError {
                 err: format!("Failed to execute JavaScript: {}", e),
             })?;
@@ -214,7 +213,7 @@ impl DouyinDanmu {
                         if let Ok(Some(ack)) = handle_binary_message(&data, &tx, room_id).await {
                             if let Some(write) = write.write().await.as_mut() {
                                 if let Err(e) =
-                                    write.send(WsMessage::Binary(ack.encode_to_vec())).await
+                                    write.send(WsMessage::binary(ack.encode_to_vec())).await
                                 {
                                     error!("Failed to send ack: {}", e);
                                 }
@@ -257,7 +256,7 @@ impl DouyinDanmu {
 
     async fn send_heartbeat(tx: &mpsc::Sender<WsMessage>) -> Result<(), DanmuStreamError> {
         // heartbeat message: 3A 02 68 62
-        tx.send(WsMessage::Binary(vec![0x3A, 0x02, 0x68, 0x62]))
+        tx.send(WsMessage::binary(vec![0x3A, 0x02, 0x68, 0x62]))
             .await
             .map_err(|e| DanmuStreamError::WebsocketError {
                 err: format!("Failed to send heartbeat message: {}", e),
@@ -269,7 +268,7 @@ impl DouyinDanmu {
 async fn handle_binary_message(
     data: &[u8],
     tx: &mpsc::UnboundedSender<DanmuMessageType>,
-    room_id: u64,
+    room_id: i64,
 ) -> Result<Option<PushFrame>, DanmuStreamError> {
     // First decode the PushFrame
     let push_frame = PushFrame::decode(Bytes::from(data.to_vec())).map_err(|e| {
@@ -395,7 +394,7 @@ async fn handle_binary_message(
 
 #[async_trait]
 impl DanmuProvider for DouyinDanmu {
-    async fn new(identifier: &str, room_id: u64) -> Result<Self, DanmuStreamError> {
+    async fn new(identifier: &str, room_id: i64) -> Result<Self, DanmuStreamError> {
         Ok(Self {
             room_id,
             cookie: identifier.to_string(),
@@ -409,7 +408,6 @@ impl DanmuProvider for DouyinDanmu {
         tx: mpsc::UnboundedSender<DanmuMessageType>,
     ) -> Result<(), DanmuStreamError> {
         let mut retry_count = 0;
-        const MAX_RETRIES: u32 = 5;
         const RETRY_DELAY: Duration = Duration::from_secs(5);
         info!(
             "Douyin WebSocket connection started, room_id: {}",
@@ -423,28 +421,25 @@ impl DanmuProvider for DouyinDanmu {
 
             match self.connect_and_handle(tx.clone()).await {
                 Ok(_) => {
-                    info!("Douyin WebSocket connection closed normally");
-                    break;
+                    info!(
+                        "Douyin WebSocket connection closed normally, room_id: {}",
+                        self.room_id
+                    );
+                    retry_count = 0;
                 }
                 Err(e) => {
                     error!("Douyin WebSocket connection error: {}", e);
                     retry_count += 1;
-
-                    if retry_count >= MAX_RETRIES {
-                        return Err(DanmuStreamError::WebsocketError {
-                            err: format!("Failed to connect after {} retries", MAX_RETRIES),
-                        });
-                    }
-
-                    info!(
-                        "Retrying connection in {} seconds... (Attempt {}/{})",
-                        RETRY_DELAY.as_secs(),
-                        retry_count,
-                        MAX_RETRIES
-                    );
-                    tokio::time::sleep(RETRY_DELAY).await;
                 }
             }
+
+            info!(
+                "Retrying connection in {} seconds... (Attempt {}), room_id: {}",
+                RETRY_DELAY.as_secs(),
+                retry_count,
+                self.room_id
+            );
+            tokio::time::sleep(RETRY_DELAY).await;
         }
 
         Ok(())

src-tauri/crates/danmu_stream/src/provider/douyin/messages.rs

@@ -1,6 +1,7 @@
-use prost::Message;
 use std::collections::HashMap;
 
+use prost::Message;
+
 // message Response {
 //   repeated Message messagesList = 1;
 //   string cursor = 2;

src-tauri/crates/danmu_stream/src/provider/mod.rs

@@ -4,10 +4,10 @@ mod douyin;
 use async_trait::async_trait;
 use tokio::sync::mpsc;
 
-use crate::{
-    provider::bilibili::BiliDanmu, provider::douyin::DouyinDanmu, DanmuMessageType,
-    DanmuStreamError,
-};
+use self::bilibili::BiliDanmu;
+use self::douyin::DouyinDanmu;
+
+use crate::{DanmuMessageType, DanmuStreamError};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ProviderType {
@@ -17,7 +17,7 @@ pub enum ProviderType {
 
 #[async_trait]
 pub trait DanmuProvider: Send + Sync {
-    async fn new(identifier: &str, room_id: u64) -> Result<Self, DanmuStreamError>
+    async fn new(identifier: &str, room_id: i64) -> Result<Self, DanmuStreamError>
     where
         Self: Sized;
 
@@ -57,7 +57,7 @@ pub trait DanmuProvider: Send + Sync {
 pub async fn new(
     provider_type: ProviderType,
     identifier: &str,
-    room_id: u64,
+    room_id: i64,
 ) -> Result<Box<dyn DanmuProvider>, DanmuStreamError> {
     match provider_type {
         ProviderType::BiliBili => {

src-tauri/gen/schemas/capabilities.json

@@ -1 +1 @@
-{"migrated":{"identifier":"migrated","description":"permissions that were migrated from v1","local":true,"windows":["main","Live*","Clip*"],"permissions":["core:default","fs:allow-read-file","fs:allow-write-file","fs:allow-read-dir","fs:allow-copy-file","fs:allow-mkdir","fs:allow-remove","fs:allow-remove","fs:allow-rename","fs:allow-exists",{"identifier":"fs:scope","allow":["**"]},"core:window:default","core:window:allow-start-dragging","core:window:allow-close","core:window:allow-minimize","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-set-title","sql:allow-execute","shell:allow-open","dialog:allow-open","dialog:allow-save","dialog:allow-message","dialog:allow-ask","dialog:allow-confirm",{"identifier":"http:default","allow":[{"url":"https://*.hdslb.com/"},{"url":"https://afdian.com/"},{"url":"https://*.afdiancdn.com/"},{"url":"https://*.douyin.com/"},{"url":"https://*.douyinpic.com/"}]},"dialog:default","shell:default","fs:default","http:default","sql:default","os:default","notification:default","dialog:default","fs:default","http:default","shell:default","sql:default","os:default","dialog:default"]}}
+{"migrated":{"identifier":"migrated","description":"permissions that were migrated from v1","local":true,"windows":["main","Live*","Clip*"],"permissions":["core:default","fs:allow-read-file","fs:allow-write-file","fs:allow-read-dir","fs:allow-copy-file","fs:allow-mkdir","fs:allow-remove","fs:allow-remove","fs:allow-rename","fs:allow-exists",{"identifier":"fs:scope","allow":["**"]},"core:window:default","core:window:allow-start-dragging","core:window:allow-close","core:window:allow-minimize","core:window:allow-maximize","core:window:allow-unmaximize","core:window:allow-set-title","sql:allow-execute","shell:allow-open","dialog:allow-open","dialog:allow-save","dialog:allow-message","dialog:allow-ask","dialog:allow-confirm",{"identifier":"http:default","allow":[{"url":"https://*.hdslb.com/"},{"url":"https://afdian.com/"},{"url":"https://*.afdiancdn.com/"},{"url":"https://*.douyin.com/"},{"url":"https://*.douyinpic.com/"},{"url":"http://tauri.localhost/*"}]},"dialog:default","shell:default","fs:default","http:default","sql:default","os:default","notification:default","dialog:default","fs:default","http:default","shell:default","sql:default","os:default","dialog:default","deep-link:default"]}}

src-tauri/gen/schemas/desktop-schema.json

@@ -4220,6 +4220,60 @@
           "const": "core:window:deny-unminimize",
           "markdownDescription": "Denies the unminimize command without any pre-configured scope."
         },
+        {
+          "description": "Allows reading the opened deep link via the get_current command\n#### This default permission set includes:\n\n- `allow-get-current`",
+          "type": "string",
+          "const": "deep-link:default",
+          "markdownDescription": "Allows reading the opened deep link via the get_current command\n#### This default permission set includes:\n\n- `allow-get-current`"
+        },
+        {
+          "description": "Enables the get_current command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-get-current",
+          "markdownDescription": "Enables the get_current command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_registered command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-is-registered",
+          "markdownDescription": "Enables the is_registered command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-register",
+          "markdownDescription": "Enables the register command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the unregister command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-unregister",
+          "markdownDescription": "Enables the unregister command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_current command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-get-current",
+          "markdownDescription": "Denies the get_current command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_registered command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-is-registered",
+          "markdownDescription": "Denies the is_registered command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-register",
+          "markdownDescription": "Denies the register command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the unregister command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-unregister",
+          "markdownDescription": "Denies the unregister command without any pre-configured scope."
+        },
         {
           "description": "This permission set configures the types of dialogs\navailable from the dialog plugin.\n\n#### Granted Permissions\n\nAll dialog types are enabled.\n\n\n\n#### This default permission set includes:\n\n- `allow-ask`\n- `allow-confirm`\n- `allow-message`\n- `allow-save`\n- `allow-open`",
           "type": "string",

src-tauri/gen/schemas/macOS-schema.json

@@ -4220,6 +4220,60 @@
           "const": "core:window:deny-unminimize",
           "markdownDescription": "Denies the unminimize command without any pre-configured scope."
         },
+        {
+          "description": "Allows reading the opened deep link via the get_current command\n#### This default permission set includes:\n\n- `allow-get-current`",
+          "type": "string",
+          "const": "deep-link:default",
+          "markdownDescription": "Allows reading the opened deep link via the get_current command\n#### This default permission set includes:\n\n- `allow-get-current`"
+        },
+        {
+          "description": "Enables the get_current command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-get-current",
+          "markdownDescription": "Enables the get_current command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the is_registered command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-is-registered",
+          "markdownDescription": "Enables the is_registered command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the register command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-register",
+          "markdownDescription": "Enables the register command without any pre-configured scope."
+        },
+        {
+          "description": "Enables the unregister command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:allow-unregister",
+          "markdownDescription": "Enables the unregister command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the get_current command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-get-current",
+          "markdownDescription": "Denies the get_current command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the is_registered command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-is-registered",
+          "markdownDescription": "Denies the is_registered command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the register command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-register",
+          "markdownDescription": "Denies the register command without any pre-configured scope."
+        },
+        {
+          "description": "Denies the unregister command without any pre-configured scope.",
+          "type": "string",
+          "const": "deep-link:deny-unregister",
+          "markdownDescription": "Denies the unregister command without any pre-configured scope."
+        },
         {
           "description": "This permission set configures the types of dialogs\navailable from the dialog plugin.\n\n#### Granted Permissions\n\nAll dialog types are enabled.\n\n\n\n#### This default permission set includes:\n\n- `allow-ask`\n- `allow-confirm`\n- `allow-message`\n- `allow-save`\n- `allow-open`",
           "type": "string",

src-tauri/src/archive_migration.rs

@@ -1,56 +0,0 @@
-use std::path::PathBuf;
-use std::sync::Arc;
-
-use chrono::Utc;
-
-use crate::database::Database;
-use crate::recorder::PlatformType;
-
-pub async fn try_rebuild_archives(
-    db: &Arc<Database>,
-    cache_path: PathBuf,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let rooms = db.get_recorders().await?;
-    for room in rooms {
-        let room_id = room.room_id;
-        let room_cache_path = cache_path.join(format!("{}/{}", room.platform, room_id));
-        let mut files = tokio::fs::read_dir(room_cache_path).await?;
-        while let Some(file) = files.next_entry().await? {
-            if file.file_type().await?.is_dir() {
-                // use folder name as live_id
-                let live_id = file.file_name();
-                let live_id = live_id.to_str().unwrap();
-                // check if live_id is in db
-                let record = db.get_record(room_id, live_id).await;
-                if record.is_ok() {
-                    continue;
-                }
-
-                // get created_at from folder metadata
-                let metadata = file.metadata().await?;
-                let created_at = metadata.created();
-                if created_at.is_err() {
-                    continue;
-                }
-                let created_at = created_at.unwrap();
-                let created_at = chrono::DateTime::<Utc>::from(created_at)
-                    .format("%Y-%m-%dT%H:%M:%S.%fZ")
-                    .to_string();
-                // create a record for this live_id
-                let record = db
-                    .add_record(
-                        PlatformType::from_str(room.platform.as_str()).unwrap(),
-                        live_id,
-                        room_id,
-                        &format!("UnknownLive {}", live_id),
-                        None,
-                        Some(&created_at),
-                    )
-                    .await?;
-
-                log::info!("rebuild archive {:?}", record);
-            }
-        }
-    }
-    Ok(())
-}

src-tauri/src/config.rs

@@ -1,6 +1,6 @@
 use std::path::{Path, PathBuf};
 
-use chrono::Utc;
+use chrono::Local;
 use serde::{Deserialize, Serialize};
 
 use crate::{recorder::PlatformType, recorder_manager::ClipRangeParams};
@@ -35,6 +35,8 @@ pub struct Config {
     pub config_path: String,
     #[serde(default = "default_whisper_language")]
     pub whisper_language: String,
+    #[serde(default = "default_webhook_url")]
+    pub webhook_url: String,
 }
 
 #[derive(Deserialize, Serialize, Clone)]
@@ -64,7 +66,7 @@ fn default_openai_api_endpoint() -> String {
 }
 
 fn default_openai_api_key() -> String {
-    "".to_string()
+    String::new()
 }
 
 fn default_clip_name_format() -> String {
@@ -86,6 +88,10 @@ fn default_whisper_language() -> String {
     "auto".to_string()
 }
 
+fn default_webhook_url() -> String {
+    String::new()
+}
+
 impl Config {
     pub fn load(
         config_path: &PathBuf,
@@ -123,6 +129,7 @@ impl Config {
             status_check_interval: default_status_check_interval(),
             config_path: config_path.to_str().unwrap().into(),
             whisper_language: default_whisper_language(),
+            webhook_url: default_webhook_url(),
         };
 
         config.save();
@@ -170,13 +177,31 @@ impl Config {
         let format_config = format_config.replace("{platform}", platform.as_str());
         let format_config = format_config.replace("{room_id}", &params.room_id.to_string());
         let format_config = format_config.replace("{live_id}", &params.live_id);
-        let format_config = format_config.replace("{x}", &params.x.to_string());
-        let format_config = format_config.replace("{y}", &params.y.to_string());
+        let format_config = format_config.replace(
+            "{x}",
+            &params
+                .range
+                .as_ref()
+                .map_or("0".to_string(), |r| r.start.to_string()),
+        );
+        let format_config = format_config.replace(
+            "{y}",
+            &params
+                .range
+                .as_ref()
+                .map_or("0".to_string(), |r| r.end.to_string()),
+        );
         let format_config = format_config.replace(
             "{created_at}",
-            &Utc::now().format("%Y-%m-%d_%H-%M-%S").to_string(),
+            &Local::now().format("%Y-%m-%d_%H-%M-%S").to_string(),
+        );
+        let format_config = format_config.replace(
+            "{length}",
+            &params
+                .range
+                .as_ref()
+                .map_or("0".to_string(), |r| r.duration().to_string()),
         );
-        let format_config = format_config.replace("{length}", &(params.y - params.x).to_string());
 
         let output = self.output.clone();
 

src-tauri/src/constants.rs

@@ -0,0 +1,4 @@
+pub const PREFIX_SUBTITLE: &str = "[subtitle]";
+pub const PREFIX_IMPORTED: &str = "[imported]";
+pub const PREFIX_DANMAKU: &str = "[danmaku]";
+pub const PREFIX_CLIP: &str = "[clip]";

src-tauri/src/danmu2ass.rs

@@ -24,32 +24,32 @@ struct DanmakuPosition {
     time: f64,
 }
 
-const PLAY_RES_X: f64 = 1920.0;
-const PLAY_RES_Y: f64 = 1080.0;
+const PLAY_RES_X: f64 = 1280.0;
+const PLAY_RES_Y: f64 = 720.0;
 const BOTTOM_RESERVED: f64 = 50.0;
 const R2L_TIME: f64 = 8.0;
 const MAX_DELAY: f64 = 6.0;
 
 pub fn danmu_to_ass(danmus: Vec<DanmuEntry>) -> String {
     // ASS header
-    let header = r#"[Script Info]
+    let header = r"[Script Info]
 Title: Bilibili Danmaku
 ScriptType: v4.00+
 Collisions: Normal
-PlayResX: 1920
-PlayResY: 1080
+PlayResX: 1280
+PlayResY: 720
 Timer: 10.0000
 
 [V4+ Styles]
 Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
-Style: Default,Microsoft YaHei,48,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,20,20,2,0
+Style: Default,微软雅黑,36,&H7fFFFFFF,&H7fFFFFFF,&H7f000000,&H7f000000,0,0,0,0,100,100,0,0,1,1,0,2,20,20,2,0
 
 [Events]
 Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
-"#;
+";
 
     let mut normal = normal_danmaku();
-    let font_size = 48.0; // Default font size
+    let font_size = 36.0; // Default font size
 
     // Convert danmus to ASS events
     let events = danmus
@@ -76,7 +76,7 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
                 "Dialogue: 0,{},{},Default,,0,0,0,,{{\\move({},{},{},{})}}{}",
                 start_time,
                 end_time,
-                PLAY_RES_X,
+                PLAY_RES_X + text_width / 2.0,
                 pos.top + font_size, // Start position
                 -text_width,
                 pos.top + font_size, // End position
@@ -87,22 +87,22 @@ Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
         .join("\n");
 
     // Combine header and events
-    format!("{}\n{}", header, events)
+    format!("{header}\n{events}")
 }
 
 fn format_time(seconds: f64) -> String {
     let hours = (seconds / 3600.0) as i32;
     let minutes = ((seconds % 3600.0) / 60.0) as i32;
     let seconds = seconds % 60.0;
-    format!("{}:{:02}:{:05.2}", hours, minutes, seconds)
+    format!("{hours}:{minutes:02}:{seconds:05.2}")
 }
 
 fn escape_text(text: &str) -> String {
-    text.replace("\\", "\\\\")
-        .replace("{", "｛")
-        .replace("}", "｝")
-        .replace("\r", "")
-        .replace("\n", "\\N")
+    text.replace('\\', "\\\\")
+        .replace('{', "｛")
+        .replace('}', "｝")
+        .replace('\r', "")
+        .replace('\n', "\\N")
 }
 
 fn normal_danmaku() -> impl FnMut(f64, f64, f64, bool) -> Option<DanmakuPosition> {
@@ -144,8 +144,8 @@ fn normal_danmaku() -> impl FnMut(f64, f64, f64, bool) -> Option<DanmakuPosition
 
             let p = space.m;
             let m = p + hv;
-            let mut tas = t0s;
-            let mut tal = t0l;
+            let mut time_actual_start = t0s;
+            let mut time_actual_leave = t0l;
 
             for other in &used {
                 if other.p >= m || other.m <= p {
@@ -154,13 +154,13 @@ fn normal_danmaku() -> impl FnMut(f64, f64, f64, bool) -> Option<DanmakuPosition
                 if other.b && b {
                     continue;
                 }
-                tas = tas.max(other.tf);
-                tal = tal.max(other.td);
+                time_actual_start = time_actual_start.max(other.tf);
+                time_actual_leave = time_actual_leave.max(other.td);
             }
 
             suggestions.push(PositionSuggestion {
                 p,
-                r: (tas - t0s).max(tal - t0l),
+                r: (time_actual_start - t0s).max(time_actual_leave - t0l),
             });
         }
 

src-tauri/src/database/account.rs

@@ -6,10 +6,10 @@ use chrono::Utc;
 use rand::seq::SliceRandom;
 use rand::Rng;
 
-#[derive(Debug, Clone, serde::Serialize, sqlx::FromRow)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]
 pub struct AccountRow {
     pub platform: String,
-    pub uid: u64, // Keep for Bilibili compatibility
+    pub uid: i64,               // Keep for Bilibili compatibility
     pub id_str: Option<String>, // New field for string IDs like Douyin sec_uid
     pub name: String,
     pub avatar: String,
@@ -30,74 +30,76 @@ impl Database {
         let platform = PlatformType::from_str(platform).unwrap();
 
         let csrf = if platform == PlatformType::Douyin {
-            Some("".to_string())
+            Some(String::new())
         } else {
             // parse cookies
             cookies
                 .split(';')
-                .map(|cookie| cookie.trim())
+                .map(str::trim)
                 .find_map(|cookie| -> Option<String> {
-                    match cookie.starts_with("bili_jct=") {
-                        true => {
-                            let var_name = &"bili_jct=";
-                            Some(cookie[var_name.len()..].to_string())
-                        }
-                        false => None,
+                    if cookie.starts_with("bili_jct=") {
+                        let var_name = &"bili_jct=";
+                        Some(cookie[var_name.len()..].to_string())
+                    } else {
+                        None
                     }
                 })
         };
 
         if csrf.is_none() {
-            return Err(DatabaseError::InvalidCookiesError);
+            return Err(DatabaseError::InvalidCookies);
         }
 
         // parse uid and id_str based on platform
         let (uid, id_str) = if platform == PlatformType::BiliBili {
             // For Bilibili, extract numeric uid from cookies
-            let uid = cookies
+            let uid = (*cookies
                 .split("DedeUserID=")
                 .collect::<Vec<&str>>()
                 .get(1)
                 .unwrap()
-                .split(";")
+                .split(';')
                 .collect::<Vec<&str>>()
                 .first()
-                .unwrap()
-                .to_string()
-                .parse::<u64>()
-                .map_err(|_| DatabaseError::InvalidCookiesError)?;
+                .unwrap())
+            .to_string()
+            .parse::<u64>()
+            .map_err(|_| DatabaseError::InvalidCookies)?;
             (uid, None)
         } else {
             // For Douyin, use temporary uid and will set id_str later with real sec_uid
-            let temp_uid = rand::thread_rng().gen_range(10000..=i32::MAX) as u64;
-            (temp_uid, Some(format!("temp_{}", temp_uid)))
+            // Fix: Generate a u32 within the desired range and then cast to u64 to avoid `clippy::cast-sign-loss`.
+            let temp_uid = rand::thread_rng().gen_range(10000u64..=i32::MAX as u64);
+            (temp_uid, Some(format!("temp_{temp_uid}")))
         };
 
+        let uid = i64::try_from(uid).map_err(|_| DatabaseError::InvalidCookies)?;
+
         let account = AccountRow {
             platform: platform.as_str().to_string(),
             uid,
             id_str,
-            name: "".into(),
-            avatar: "".into(),
+            name: String::new(),
+            avatar: String::new(),
             csrf: csrf.unwrap(),
             cookies: cookies.into(),
             created_at: Utc::now().to_rfc3339(),
         };
 
-        sqlx::query("INSERT INTO accounts (uid, platform, id_str, name, avatar, csrf, cookies, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)").bind(account.uid as i64).bind(&account.platform).bind(&account.id_str).bind(&account.name).bind(&account.avatar).bind(&account.csrf).bind(&account.cookies).bind(&account.created_at).execute(&lock).await?;
+        sqlx::query("INSERT INTO accounts (uid, platform, id_str, name, avatar, csrf, cookies, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)").bind(uid).bind(&account.platform).bind(&account.id_str).bind(&account.name).bind(&account.avatar).bind(&account.csrf).bind(&account.cookies).bind(&account.created_at).execute(&lock).await?;
 
         Ok(account)
     }
 
-    pub async fn remove_account(&self, platform: &str, uid: u64) -> Result<(), DatabaseError> {
+    pub async fn remove_account(&self, platform: &str, uid: i64) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         let sql = sqlx::query("DELETE FROM accounts WHERE uid = $1 and platform = $2")
-            .bind(uid as i64)
+            .bind(uid)
             .bind(platform)
             .execute(&lock)
             .await?;
         if sql.rows_affected() != 1 {
-            return Err(DatabaseError::NotFoundError);
+            return Err(DatabaseError::NotFound);
         }
         Ok(())
     }
@@ -105,7 +107,7 @@ impl Database {
     pub async fn update_account(
         &self,
         platform: &str,
-        uid: u64,
+        uid: i64,
         name: &str,
         avatar: &str,
     ) -> Result<(), DatabaseError> {
@@ -115,12 +117,12 @@ impl Database {
         )
         .bind(name)
         .bind(avatar)
-        .bind(uid as i64)
+        .bind(uid)
         .bind(platform)
         .execute(&lock)
         .await?;
         if sql.rows_affected() != 1 {
-            return Err(DatabaseError::NotFoundError);
+            return Err(DatabaseError::NotFound);
         }
         Ok(())
     }
@@ -133,19 +135,30 @@ impl Database {
         avatar: &str,
     ) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
-        
+
         // If the id_str changed, we need to delete the old record and create a new one
-        if old_account.id_str.as_deref() != Some(new_id_str) {
+        if old_account.id_str.as_deref() == Some(new_id_str) {
+            // id_str is the same, just update name and avatar
+            sqlx::query(
+                "UPDATE accounts SET name = $1, avatar = $2 WHERE uid = $3 and platform = $4",
+            )
+            .bind(name)
+            .bind(avatar)
+            .bind(old_account.uid)
+            .bind(&old_account.platform)
+            .execute(&lock)
+            .await?;
+        } else {
             // Delete the old record (for Douyin accounts, we use uid to identify)
             sqlx::query("DELETE FROM accounts WHERE uid = $1 and platform = $2")
-                .bind(old_account.uid as i64)
+                .bind(old_account.uid)
                 .bind(&old_account.platform)
                 .execute(&lock)
                 .await?;
-            
+
             // Insert the new record with updated id_str
             sqlx::query("INSERT INTO accounts (uid, platform, id_str, name, avatar, csrf, cookies, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)")
-                .bind(old_account.uid as i64)
+                .bind(old_account.uid)
                 .bind(&old_account.platform)
                 .bind(new_id_str)
                 .bind(name)
@@ -155,17 +168,8 @@ impl Database {
                 .bind(&old_account.created_at)
                 .execute(&lock)
                 .await?;
-        } else {
-            // id_str is the same, just update name and avatar
-            sqlx::query("UPDATE accounts SET name = $1, avatar = $2 WHERE uid = $3 and platform = $4")
-                .bind(name)
-                .bind(avatar)
-                .bind(old_account.uid as i64)
-                .bind(&old_account.platform)
-                .execute(&lock)
-                .await?;
         }
-        
+
         Ok(())
     }
 
@@ -176,12 +180,12 @@ impl Database {
             .await?)
     }
 
-    pub async fn get_account(&self, platform: &str, uid: u64) -> Result<AccountRow, DatabaseError> {
+    pub async fn get_account(&self, platform: &str, uid: i64) -> Result<AccountRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         Ok(sqlx::query_as::<_, AccountRow>(
             "SELECT * FROM accounts WHERE uid = $1 and platform = $2",
         )
-        .bind(uid as i64)
+        .bind(uid)
         .bind(platform)
         .fetch_one(&lock)
         .await?)
@@ -198,7 +202,7 @@ impl Database {
                 .fetch_all(&lock)
                 .await?;
         if accounts.is_empty() {
-            return Err(DatabaseError::NotFoundError);
+            return Err(DatabaseError::NotFound);
         }
         // randomly select one account
         let account = accounts.choose(&mut rand::thread_rng()).unwrap();

src-tauri/src/database/mod.rs

@@ -1,6 +1,6 @@
-use custom_error::custom_error;
 use sqlx::Pool;
 use sqlx::Sqlite;
+use thiserror::Error;
 use tokio::sync::RwLock;
 
 pub mod account;
@@ -14,23 +14,25 @@ pub struct Database {
     db: RwLock<Option<Pool<Sqlite>>>,
 }
 
-custom_error! { pub DatabaseError
-    InsertError = "Entry insert failed",
-    NotFoundError = "Entry not found",
-    InvalidCookiesError = "Cookies are invalid",
-    DBError {err: sqlx::Error } = "DB error: {err}",
-    SQLError { sql: String } = "SQL is incorret: {sql}"
+#[derive(Error, Debug)]
+pub enum DatabaseError {
+    #[error("Entry insert failed")]
+    Insert,
+    #[error("Entry not found")]
+    NotFound,
+    #[error("Cookies are invalid")]
+    InvalidCookies,
+    #[error("Number exceed i64 range")]
+    NumberExceedI64Range,
+    #[error("DB error: {0}")]
+    DB(#[from] sqlx::Error),
+    #[error("SQL is incorret: {sql}")]
+    Sql { sql: String },
 }
 
 impl From<DatabaseError> for String {
-    fn from(value: DatabaseError) -> Self {
-        value.to_string()
-    }
-}
-
-impl From<sqlx::Error> for DatabaseError {
-    fn from(value: sqlx::Error) -> Self {
-        DatabaseError::DBError { err: value }
+    fn from(err: DatabaseError) -> Self {
+        err.to_string()
     }
 }
 

src-tauri/src/database/record.rs

@@ -4,11 +4,12 @@ use super::Database;
 use super::DatabaseError;
 use chrono::Utc;
 
-#[derive(Debug, Clone, serde::Serialize, sqlx::FromRow)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]
 pub struct RecordRow {
     pub platform: String,
+    pub parent_id: String,
     pub live_id: String,
-    pub room_id: u64,
+    pub room_id: i64,
     pub title: String,
     pub length: i64,
     pub size: i64,
@@ -18,53 +19,76 @@ pub struct RecordRow {
 
 // CREATE TABLE records (live_id INTEGER PRIMARY KEY, room_id INTEGER, title TEXT, length INTEGER, size INTEGER, created_at TEXT);
 impl Database {
-    pub async fn get_records(&self, room_id: u64) -> Result<Vec<RecordRow>, DatabaseError> {
+    pub async fn get_records(
+        &self,
+        room_id: i64,
+        offset: i64,
+        limit: i64,
+    ) -> Result<Vec<RecordRow>, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
-        Ok(
-            sqlx::query_as::<_, RecordRow>("SELECT * FROM records WHERE room_id = $1")
-                .bind(room_id as i64)
-                .fetch_all(&lock)
-                .await?,
+        Ok(sqlx::query_as::<_, RecordRow>(
+            "SELECT * FROM records WHERE room_id = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3",
         )
+        .bind(room_id)
+        .bind(limit)
+        .bind(offset)
+        .fetch_all(&lock)
+        .await?)
     }
 
     pub async fn get_record(
         &self,
-        room_id: u64,
+        room_id: i64,
         live_id: &str,
     ) -> Result<RecordRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         Ok(sqlx::query_as::<_, RecordRow>(
-            "SELECT * FROM records WHERE live_id = $1 and room_id = $2",
+            "SELECT * FROM records WHERE room_id = $1 and live_id = $2",
         )
+        .bind(room_id)
         .bind(live_id)
-        .bind(room_id as i64)
         .fetch_one(&lock)
         .await?)
     }
 
+    pub async fn get_archives_by_parent_id(
+        &self,
+        room_id: i64,
+        parent_id: &str,
+    ) -> Result<Vec<RecordRow>, DatabaseError> {
+        let lock = self.db.read().await.clone().unwrap();
+        Ok(sqlx::query_as::<_, RecordRow>(
+            "SELECT * FROM records WHERE room_id = $1 and parent_id = $2",
+        )
+        .bind(room_id)
+        .bind(parent_id)
+        .fetch_all(&lock)
+        .await?)
+    }
+
     pub async fn add_record(
         &self,
         platform: PlatformType,
+        parent_id: &str,
         live_id: &str,
-        room_id: u64,
+        room_id: i64,
         title: &str,
         cover: Option<String>,
-        created_at: Option<&str>,
     ) -> Result<RecordRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         let record = RecordRow {
             platform: platform.as_str().to_string(),
+            parent_id: parent_id.to_string(),
             live_id: live_id.to_string(),
             room_id,
             title: title.into(),
             length: 0,
             size: 0,
-            created_at: created_at.unwrap_or(&Utc::now().to_rfc3339()).to_string(),
+            created_at: Utc::now().to_rfc3339().to_string(),
             cover,
         };
-        if let Err(e) = sqlx::query("INSERT INTO records (live_id, room_id, title, length, size, cover, created_at, platform) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)").bind(record.live_id.clone())
-            .bind(record.room_id as i64).bind(&record.title).bind(0).bind(0).bind(&record.cover).bind(&record.created_at).bind(platform.as_str().to_string()).execute(&lock).await {
+        if let Err(e) = sqlx::query("INSERT INTO records (live_id, room_id, title, length, size, cover, created_at, platform, parent_id) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)").bind(record.live_id.clone())
+            .bind(record.room_id).bind(&record.title).bind(0).bind(0).bind(&record.cover).bind(&record.created_at).bind(platform.as_str().to_string()).bind(parent_id).execute(&lock).await {
                 // if the record already exists, return the existing record
                 if e.to_string().contains("UNIQUE constraint failed") {
                     return self.get_record(room_id, live_id).await;
@@ -73,13 +97,17 @@ impl Database {
         Ok(record)
     }
 
-    pub async fn remove_record(&self, live_id: &str) -> Result<(), DatabaseError> {
+    pub async fn remove_record(&self, live_id: &str) -> Result<RecordRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
+        let to_delete = sqlx::query_as::<_, RecordRow>("SELECT * FROM records WHERE live_id = $1")
+            .bind(live_id)
+            .fetch_one(&lock)
+            .await?;
         sqlx::query("DELETE FROM records WHERE live_id = $1")
             .bind(live_id)
             .execute(&lock)
             .await?;
-        Ok(())
+        Ok(to_delete)
     }
 
     pub async fn update_record(
@@ -89,9 +117,38 @@ impl Database {
         size: u64,
     ) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
+        let size = i64::try_from(size).map_err(|_| DatabaseError::NumberExceedI64Range)?;
         sqlx::query("UPDATE records SET length = $1, size = $2 WHERE live_id = $3")
             .bind(length)
-            .bind(size as i64)
+            .bind(size)
+            .bind(live_id)
+            .execute(&lock)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn update_record_parent_id(
+        &self,
+        live_id: &str,
+        parent_id: &str,
+    ) -> Result<(), DatabaseError> {
+        let lock = self.db.read().await.clone().unwrap();
+        sqlx::query("UPDATE records SET parent_id = $1 WHERE live_id = $2")
+            .bind(parent_id)
+            .bind(live_id)
+            .execute(&lock)
+            .await?;
+        Ok(())
+    }
+
+    pub async fn update_record_cover(
+        &self,
+        live_id: &str,
+        cover: Option<String>,
+    ) -> Result<(), DatabaseError> {
+        let lock = self.db.read().await.clone().unwrap();
+        sqlx::query("UPDATE records SET cover = $1 WHERE live_id = $2")
+            .bind(cover)
             .bind(live_id)
             .execute(&lock)
             .await?;
@@ -123,28 +180,36 @@ impl Database {
 
     pub async fn get_recent_record(
         &self,
-        room_id: u64,
-        offset: u64,
-        limit: u64,
+        room_id: i64,
+        offset: i64,
+        limit: i64,
     ) -> Result<Vec<RecordRow>, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         if room_id == 0 {
             Ok(sqlx::query_as::<_, RecordRow>(
                 "SELECT * FROM records ORDER BY created_at DESC LIMIT $1 OFFSET $2",
             )
-            .bind(limit as i64)
-                .bind(offset as i64)
-                .fetch_all(&lock)
-                .await?)
+            .bind(limit)
+            .bind(offset)
+            .fetch_all(&lock)
+            .await?)
         } else {
             Ok(sqlx::query_as::<_, RecordRow>(
                 "SELECT * FROM records WHERE room_id = $1 ORDER BY created_at DESC LIMIT $2 OFFSET $3",
             )
-            .bind(room_id as i64)
-            .bind(limit as i64)
-            .bind(offset as i64)
+            .bind(room_id)
+            .bind(limit)
+            .bind(offset)
             .fetch_all(&lock)
             .await?)
         }
     }
+
+    pub async fn get_record_disk_usage(&self) -> Result<i64, DatabaseError> {
+        let lock = self.db.read().await.clone().unwrap();
+        let result: (i64,) = sqlx::query_as("SELECT SUM(size) FROM records;")
+            .fetch_one(&lock)
+            .await?;
+        Ok(result.0)
+    }
 }

src-tauri/src/database/recorder.rs

@@ -4,12 +4,13 @@ use crate::recorder::PlatformType;
 use chrono::Utc;
 /// Recorder in database is pretty simple
 /// because many room infos are collected in realtime
-#[derive(Debug, Clone, serde::Serialize, sqlx::FromRow)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]
 pub struct RecorderRow {
-    pub room_id: u64,
+    pub room_id: i64,
     pub created_at: String,
     pub platform: String,
     pub auto_start: bool,
+    pub extra: String,
 }
 
 // recorders
@@ -17,7 +18,8 @@ impl Database {
     pub async fn add_recorder(
         &self,
         platform: PlatformType,
-        room_id: u64,
+        room_id: i64,
+        extra: &str,
     ) -> Result<RecorderRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         let recorder = RecorderRow {
@@ -25,47 +27,54 @@ impl Database {
             created_at: Utc::now().to_rfc3339(),
             platform: platform.as_str().to_string(),
             auto_start: true,
+            extra: extra.to_string(),
         };
         let _ = sqlx::query(
-            "INSERT INTO recorders (room_id, created_at, platform, auto_start) VALUES ($1, $2, $3, $4)",
+            "INSERT OR REPLACE INTO recorders (room_id, created_at, platform, auto_start, extra) VALUES ($1, $2, $3, $4, $5)",
         )
-        .bind(room_id as i64)
+        .bind(room_id)
         .bind(&recorder.created_at)
         .bind(platform.as_str())
         .bind(recorder.auto_start)
+        .bind(extra)
         .execute(&lock)
         .await?;
         Ok(recorder)
     }
 
-    pub async fn remove_recorder(&self, room_id: u64) -> Result<(), DatabaseError> {
+    pub async fn remove_recorder(&self, room_id: i64) -> Result<RecorderRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
+        let recorder =
+            sqlx::query_as::<_, RecorderRow>("SELECT * FROM recorders WHERE room_id = $1")
+                .bind(room_id)
+                .fetch_one(&lock)
+                .await?;
         let sql = sqlx::query("DELETE FROM recorders WHERE room_id = $1")
-            .bind(room_id as i64)
+            .bind(room_id)
             .execute(&lock)
             .await?;
         if sql.rows_affected() != 1 {
-            return Err(DatabaseError::NotFoundError);
+            return Err(DatabaseError::NotFound);
         }
 
         // remove related archive
         let _ = self.remove_archive(room_id).await;
-        Ok(())
+        Ok(recorder)
     }
 
     pub async fn get_recorders(&self) -> Result<Vec<RecorderRow>, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         Ok(sqlx::query_as::<_, RecorderRow>(
-            "SELECT room_id, created_at, platform, auto_start FROM recorders",
+            "SELECT room_id, created_at, platform, auto_start, extra FROM recorders",
         )
         .fetch_all(&lock)
         .await?)
     }
 
-    pub async fn remove_archive(&self, room_id: u64) -> Result<(), DatabaseError> {
+    pub async fn remove_archive(&self, room_id: i64) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         let _ = sqlx::query("DELETE FROM records WHERE room_id = $1")
-            .bind(room_id as i64)
+            .bind(room_id)
             .execute(&lock)
             .await?;
         Ok(())
@@ -74,7 +83,7 @@ impl Database {
     pub async fn update_recorder(
         &self,
         platform: PlatformType,
-        room_id: u64,
+        room_id: i64,
         auto_start: bool,
     ) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
@@ -83,7 +92,7 @@ impl Database {
         )
         .bind(auto_start)
         .bind(platform.as_str().to_string())
-        .bind(room_id as i64)
+        .bind(room_id)
         .execute(&lock)
         .await?;
         Ok(())

src-tauri/src/database/task.rs

@@ -13,6 +13,27 @@ pub struct TaskRow {
 }
 
 impl Database {
+    pub async fn generate_task(
+        &self,
+        task_type: &str,
+        message: &str,
+        metadata: &str,
+    ) -> Result<TaskRow, DatabaseError> {
+        let task_id = uuid::Uuid::new_v4().to_string();
+        let task = TaskRow {
+            id: task_id,
+            task_type: task_type.to_string(),
+            status: "pending".to_string(),
+            message: message.to_string(),
+            metadata: metadata.to_string(),
+            created_at: chrono::Utc::now().to_rfc3339(),
+        };
+
+        self.add_task(&task).await?;
+
+        Ok(task)
+    }
+
     pub async fn add_task(&self, task: &TaskRow) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         let _ = sqlx::query(

src-tauri/src/database/video.rs

@@ -2,29 +2,13 @@ use super::Database;
 use super::DatabaseError;
 
 // CREATE TABLE videos (id INTEGER PRIMARY KEY, room_id INTEGER, cover TEXT, file TEXT, length INTEGER, size INTEGER, status INTEGER, bvid TEXT, title TEXT, desc TEXT, tags TEXT, area INTEGER, created_at TEXT);
-#[derive(Debug, Clone, serde::Serialize, sqlx::FromRow)]
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, sqlx::FromRow)]
 pub struct VideoRow {
     pub id: i64,
-    pub room_id: u64,
+    pub room_id: i64,
     pub cover: String,
     pub file: String,
-    pub length: i64,
-    pub size: i64,
-    pub status: i64,
-    pub bvid: String,
-    pub title: String,
-    pub desc: String,
-    pub tags: String,
-    pub area: i64,
-    pub created_at: String,
-    pub platform: String,
-}
-
-#[derive(Debug, Clone, serde::Serialize, sqlx::FromRow)]
-pub struct VideoNoCover {
-    pub id: i64,
-    pub room_id: u64,
-    pub file: String,
+    pub note: String,
     pub length: i64,
     pub size: i64,
     pub status: i64,
@@ -38,10 +22,10 @@ pub struct VideoNoCover {
 }
 
 impl Database {
-    pub async fn get_videos(&self, room_id: u64) -> Result<Vec<VideoNoCover>, DatabaseError> {
+    pub async fn get_videos(&self, room_id: i64) -> Result<Vec<VideoRow>, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
-        let videos = sqlx::query_as::<_, VideoNoCover>("SELECT * FROM videos WHERE room_id = $1;")
-            .bind(room_id as i64)
+        let videos = sqlx::query_as::<_, VideoRow>("SELECT * FROM videos WHERE room_id = $1;")
+            .bind(room_id)
             .fetch_all(&lock)
             .await?;
         Ok(videos)
@@ -59,13 +43,14 @@ impl Database {
 
     pub async fn update_video(&self, video_row: &VideoRow) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
-        sqlx::query("UPDATE videos SET status = $1, bvid = $2, title = $3, desc = $4, tags = $5, area = $6 WHERE id = $7")
+        sqlx::query("UPDATE videos SET status = $1, bvid = $2, title = $3, desc = $4, tags = $5, area = $6, note = $7 WHERE id = $8")
             .bind(video_row.status)
             .bind(&video_row.bvid)
             .bind(&video_row.title)
             .bind(&video_row.desc)
             .bind(&video_row.tags)
             .bind(video_row.area)
+            .bind(&video_row.note)
             .bind(video_row.id)
             .execute(&lock)
             .await?;
@@ -83,10 +68,11 @@ impl Database {
 
     pub async fn add_video(&self, video: &VideoRow) -> Result<VideoRow, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
-        let sql = sqlx::query("INSERT INTO videos (room_id, cover, file, length, size, status, bvid, title, desc, tags, area, created_at, platform) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)")
-            .bind(video.room_id as i64)
+        let sql = sqlx::query("INSERT INTO videos (room_id, cover, file, note, length, size, status, bvid, title, desc, tags, area, created_at, platform) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)")
+            .bind(video.room_id)
             .bind(&video.cover)
             .bind(&video.file)
+            .bind(&video.note)
             .bind(video.length)
             .bind(video.size)
             .bind(video.status)
@@ -106,7 +92,7 @@ impl Database {
         Ok(video)
     }
 
-    pub async fn update_video_cover(&self, id: i64, cover: String) -> Result<(), DatabaseError> {
+    pub async fn update_video_cover(&self, id: i64, cover: &str) -> Result<(), DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         sqlx::query("UPDATE videos SET cover = $1 WHERE id = $2")
             .bind(cover)
@@ -116,10 +102,10 @@ impl Database {
         Ok(())
     }
 
-    pub async fn get_all_videos(&self) -> Result<Vec<VideoNoCover>, DatabaseError> {
+    pub async fn get_all_videos(&self) -> Result<Vec<VideoRow>, DatabaseError> {
         let lock = self.db.read().await.clone().unwrap();
         let videos =
-            sqlx::query_as::<_, VideoNoCover>("SELECT * FROM videos ORDER BY created_at DESC;")
+            sqlx::query_as::<_, VideoRow>("SELECT * FROM videos ORDER BY created_at DESC;")
                 .fetch_all(&lock)
                 .await?;
         Ok(videos)

src-tauri/src/handlers/account.rs

@@ -23,7 +23,7 @@ pub async fn add_account(
 ) -> Result<AccountRow, String> {
     // check if cookies is valid
     if let Err(e) = cookies.parse::<HeaderValue>() {
-        return Err(format!("Invalid cookies: {}", e));
+        return Err(format!("Invalid cookies: {e}"));
     }
     let account = state.db.add_account(&platform, cookies).await?;
     if platform == "bilibili" {
@@ -43,8 +43,13 @@ pub async fn add_account(
         match douyin_client.get_user_info().await {
             Ok(user_info) => {
                 // For Douyin, use sec_uid as the primary identifier in id_str field
-                let avatar_url = user_info.avatar_thumb.url_list.first().cloned().unwrap_or_default();
-                
+                let avatar_url = user_info
+                    .avatar_thumb
+                    .url_list
+                    .first()
+                    .cloned()
+                    .unwrap_or_default();
+
                 state
                     .db
                     .update_account_with_id_str(
@@ -56,7 +61,7 @@ pub async fn add_account(
                     .await?;
             }
             Err(e) => {
-                log::warn!("Failed to get Douyin user info: {}", e);
+                log::warn!("Failed to get Douyin user info: {e}");
                 // Keep the account but with default values
             }
         }
@@ -68,7 +73,7 @@ pub async fn add_account(
 pub async fn remove_account(
     state: state_type!(),
     platform: String,
-    uid: u64,
+    uid: i64,
 ) -> Result<(), String> {
     if platform == "bilibili" {
         let account = state.db.get_account(&platform, uid).await?;

src-tauri/src/handlers/config.rs

@@ -14,16 +14,25 @@ pub async fn get_config(state: state_type!()) -> Result<Config, ()> {
 #[allow(dead_code)]
 pub async fn set_cache_path(state: state_type!(), cache_path: String) -> Result<(), String> {
     let old_cache_path = state.config.read().await.cache.clone();
+    log::info!("Try to set cache path: {old_cache_path} -> {cache_path}");
     if old_cache_path == cache_path {
         return Ok(());
     }
 
-    state.recorder_manager.set_migrating(true).await;
+    let old_cache_path_obj = std::path::Path::new(&old_cache_path);
+    let new_cache_path_obj = std::path::Path::new(&cache_path);
+    // check if new cache path is under old cache path
+    if new_cache_path_obj.starts_with(old_cache_path_obj) {
+        log::error!("New cache path is under old cache path: {old_cache_path} -> {cache_path}");
+        return Err("New cache path cannot be under old cache path".to_string());
+    }
+
+    state.recorder_manager.set_migrating(true);
     // stop and clear all recorders
     state.recorder_manager.stop_all().await;
     // first switch to new cache
     state.config.write().await.set_cache_path(&cache_path);
-    log::info!("Cache path changed: {}", cache_path);
+    log::info!("Cache path changed: {cache_path}");
     // Copy old cache to new cache
     log::info!("Start copy old cache to new cache");
     state
@@ -51,26 +60,28 @@ pub async fn set_cache_path(state: state_type!(), cache_path: String) -> Result<
         // if entry is a folder
         if entry.is_dir() {
             if let Err(e) = crate::handlers::utils::copy_dir_all(entry, &new_entry) {
-                log::error!("Copy old cache to new cache error: {}", e);
+                log::error!("Copy old cache to new cache error: {e}");
+                return Err(e.to_string());
             }
         } else if let Err(e) = std::fs::copy(entry, &new_entry) {
-            log::error!("Copy old cache to new cache error: {}", e);
+            log::error!("Copy old cache to new cache error: {e}");
+            return Err(e.to_string());
         }
     }
 
     log::info!("Copy old cache to new cache done");
     state.db.new_message("缓存目录切换", "缓存切换完成").await?;
 
-    state.recorder_manager.set_migrating(false).await;
+    state.recorder_manager.set_migrating(false);
 
     // remove all old cache entries
     for entry in old_cache_entries {
         if entry.is_dir() {
             if let Err(e) = std::fs::remove_dir_all(&entry) {
-                log::error!("Remove old cache error: {}", e);
+                log::error!("Remove old cache error: {e}");
             }
         } else if let Err(e) = std::fs::remove_file(&entry) {
-            log::error!("Remove old cache error: {}", e);
+            log::error!("Remove old cache error: {e}");
         }
     }
 
@@ -79,12 +90,22 @@ pub async fn set_cache_path(state: state_type!(), cache_path: String) -> Result<
 
 #[cfg_attr(feature = "gui", tauri::command)]
 #[allow(dead_code)]
-pub async fn set_output_path(state: state_type!(), output_path: String) -> Result<(), ()> {
+pub async fn set_output_path(state: state_type!(), output_path: String) -> Result<(), String> {
     let mut config = state.config.write().await;
     let old_output_path = config.output.clone();
+    log::info!("Try to set output path: {old_output_path} -> {output_path}");
     if old_output_path == output_path {
         return Ok(());
     }
+
+    let old_output_path_obj = std::path::Path::new(&old_output_path);
+    let new_output_path_obj = std::path::Path::new(&output_path);
+    // check if new output path is under old output path
+    if new_output_path_obj.starts_with(old_output_path_obj) {
+        log::error!("New output path is under old output path: {old_output_path} -> {output_path}");
+        return Err("New output path cannot be under old output path".to_string());
+    }
+
     // list all file and folder in old output
     let mut old_output_entries = vec![];
     if let Ok(entries) = std::fs::read_dir(&old_output_path) {
@@ -103,10 +124,12 @@ pub async fn set_output_path(state: state_type!(), output_path: String) -> Resul
         // if entry is a folder
         if entry.is_dir() {
             if let Err(e) = crate::handlers::utils::copy_dir_all(entry, &new_entry) {
-                log::error!("Copy old cache to new cache error: {}", e);
+                log::error!("Copy old output to new output error: {e}");
+                return Err(e.to_string());
             }
         } else if let Err(e) = std::fs::copy(entry, &new_entry) {
-            log::error!("Copy old cache to new cache error: {}", e);
+            log::error!("Copy old output to new output error: {e}");
+            return Err(e.to_string());
         }
     }
 
@@ -114,10 +137,10 @@ pub async fn set_output_path(state: state_type!(), output_path: String) -> Resul
     for entry in old_output_entries {
         if entry.is_dir() {
             if let Err(e) = std::fs::remove_dir_all(&entry) {
-                log::error!("Remove old cache error: {}", e);
+                log::error!("Remove old output error: {e}");
             }
         } else if let Err(e) = std::fs::remove_file(&entry) {
-            log::error!("Remove old cache error: {}", e);
+            log::error!("Remove old output error: {e}");
         }
     }
 
@@ -177,10 +200,7 @@ pub async fn update_subtitle_generator_type(
     state: state_type!(),
     subtitle_generator_type: String,
 ) -> Result<(), ()> {
-    log::info!(
-        "Updating subtitle generator type to {}",
-        subtitle_generator_type
-    );
+    log::info!("Updating subtitle generator type to {subtitle_generator_type}");
     let mut config = state.config.write().await;
     config.subtitle_generator_type = subtitle_generator_type;
     config.save();
@@ -201,7 +221,7 @@ pub async fn update_openai_api_endpoint(
     state: state_type!(),
     openai_api_endpoint: String,
 ) -> Result<(), ()> {
-    log::info!("Updating openai api endpoint to {}", openai_api_endpoint);
+    log::info!("Updating openai api endpoint to {openai_api_endpoint}");
     let mut config = state.config.write().await;
     config.openai_api_endpoint = openai_api_endpoint;
     config.save();
@@ -229,7 +249,7 @@ pub async fn update_status_check_interval(
     if interval < 10 {
         interval = 10; // Minimum interval of 10 seconds
     }
-    log::info!("Updating status check interval to {} seconds", interval);
+    log::info!("Updating status check interval to {interval} seconds");
     state.config.write().await.status_check_interval = interval;
     state.config.write().await.save();
     Ok(())
@@ -240,8 +260,23 @@ pub async fn update_whisper_language(
     state: state_type!(),
     whisper_language: String,
 ) -> Result<(), ()> {
-    log::info!("Updating whisper language to {}", whisper_language);
+    log::info!("Updating whisper language to {whisper_language}");
     state.config.write().await.whisper_language = whisper_language;
     state.config.write().await.save();
     Ok(())
 }
+
+#[cfg_attr(feature = "gui", tauri::command)]
+pub async fn update_webhook_url(state: state_type!(), webhook_url: String) -> Result<(), ()> {
+    log::info!("Updating webhook url to {webhook_url}");
+    let _ = state
+        .webhook_poster
+        .update_config(crate::webhook::poster::WebhookConfig {
+            url: webhook_url.clone(),
+            ..Default::default()
+        })
+        .await;
+    state.config.write().await.webhook_url = webhook_url;
+    state.config.write().await.save();
+    Ok(())
+}

src-tauri/src/handlers/mod.rs

@@ -13,10 +13,3 @@ use crate::database::account::AccountRow;
 pub struct AccountInfo {
     pub accounts: Vec<AccountRow>,
 }
-
-#[derive(serde::Serialize)]
-pub struct DiskInfo {
-    pub disk: String,
-    pub total: u64,
-    pub free: u64,
-}

src-tauri/src/handlers/recorder.rs

@@ -1,12 +1,17 @@
 use crate::danmu2ass;
 use crate::database::record::RecordRow;
 use crate::database::recorder::RecorderRow;
+use crate::database::task::TaskRow;
+use crate::progress::progress_reporter::EventEmitter;
+use crate::progress::progress_reporter::ProgressReporter;
+use crate::progress::progress_reporter::ProgressReporterTrait;
 use crate::recorder::danmu::DanmuEntry;
 use crate::recorder::PlatformType;
 use crate::recorder::RecorderInfo;
 use crate::recorder_manager::RecorderList;
 use crate::state::State;
 use crate::state_type;
+use crate::webhook::events;
 
 #[cfg(feature = "gui")]
 use tauri::State as TauriState;
@@ -23,9 +28,10 @@ pub async fn get_recorder_list(state: state_type!()) -> Result<RecorderList, ()>
 pub async fn add_recorder(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
+    extra: String,
 ) -> Result<RecorderRow, String> {
-    log::info!("Add recorder: {} {}", platform, room_id);
+    log::info!("Add recorder: {platform} {room_id}");
     let platform = PlatformType::from_str(&platform).unwrap();
     let account = match platform {
         PlatformType::BiliBili => {
@@ -50,25 +56,33 @@ pub async fn add_recorder(
     match account {
         Ok(account) => match state
             .recorder_manager
-            .add_recorder(&account, platform, room_id, true)
+            .add_recorder(&account, platform, room_id, &extra, true)
             .await
         {
             Ok(()) => {
-                let room = state.db.add_recorder(platform, room_id).await?;
+                let room = state.db.add_recorder(platform, room_id, &extra).await?;
                 state
                     .db
-                    .new_message("添加直播间", &format!("添加了新直播间 {}", room_id))
+                    .new_message("添加直播间", &format!("添加了新直播间 {room_id}"))
                     .await?;
+                // post webhook event
+                let event = events::new_webhook_event(
+                    events::RECORDER_ADDED,
+                    events::Payload::Recorder(room.clone()),
+                );
+                if let Err(e) = state.webhook_poster.post_event(&event).await {
+                    log::error!("Post webhook event error: {e}");
+                }
                 Ok(room)
             }
             Err(e) => {
-                log::error!("Failed to add recorder: {}", e);
-                Err(format!("添加失败: {}", e))
+                log::error!("Failed to add recorder: {e}");
+                Err(format!("添加失败: {e}"))
             }
         },
         Err(e) => {
-            log::error!("Failed to add recorder: {}", e);
-            Err(format!("添加失败: {}", e))
+            log::error!("Failed to add recorder: {e}");
+            Err(format!("添加失败: {e}"))
         }
     }
 }
@@ -77,25 +91,33 @@ pub async fn add_recorder(
 pub async fn remove_recorder(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
 ) -> Result<(), String> {
-    log::info!("Remove recorder: {} {}", platform, room_id);
+    log::info!("Remove recorder: {platform} {room_id}");
     let platform = PlatformType::from_str(&platform).unwrap();
     match state
         .recorder_manager
         .remove_recorder(platform, room_id)
         .await
     {
-        Ok(()) => {
+        Ok(recorder) => {
             state
                 .db
-                .new_message("移除直播间", &format!("移除了直播间 {}", room_id))
+                .new_message("移除直播间", &format!("移除了直播间 {room_id}"))
                 .await?;
+            // post webhook event
+            let event = events::new_webhook_event(
+                events::RECORDER_REMOVED,
+                events::Payload::Recorder(recorder),
+            );
+            if let Err(e) = state.webhook_poster.post_event(&event).await {
+                log::error!("Post webhook event error: {e}");
+            }
             log::info!("Removed recorder: {} {}", platform.as_str(), room_id);
             Ok(())
         }
         Err(e) => {
-            log::error!("Failed to remove recorder: {}", e);
+            log::error!("Failed to remove recorder: {e}");
             Err(e.to_string())
         }
     }
@@ -105,7 +127,7 @@ pub async fn remove_recorder(
 pub async fn get_room_info(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
 ) -> Result<RecorderInfo, String> {
     let platform = PlatformType::from_str(&platform).unwrap();
     if let Some(info) = state
@@ -120,14 +142,27 @@ pub async fn get_room_info(
 }
 
 #[cfg_attr(feature = "gui", tauri::command)]
-pub async fn get_archives(state: state_type!(), room_id: u64) -> Result<Vec<RecordRow>, String> {
-    Ok(state.recorder_manager.get_archives(room_id).await?)
+pub async fn get_archive_disk_usage(state: state_type!()) -> Result<i64, String> {
+    Ok(state.recorder_manager.get_archive_disk_usage().await?)
+}
+
+#[cfg_attr(feature = "gui", tauri::command)]
+pub async fn get_archives(
+    state: state_type!(),
+    room_id: i64,
+    offset: i64,
+    limit: i64,
+) -> Result<Vec<RecordRow>, String> {
+    Ok(state
+        .recorder_manager
+        .get_archives(room_id, offset, limit)
+        .await?)
 }
 
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn get_archive(
     state: state_type!(),
-    room_id: u64,
+    room_id: i64,
     live_id: String,
 ) -> Result<RecordRow, String> {
     Ok(state
@@ -136,46 +171,64 @@ pub async fn get_archive(
         .await?)
 }
 
+#[cfg_attr(feature = "gui", tauri::command)]
+pub async fn get_archives_by_parent_id(
+    state: state_type!(),
+    room_id: i64,
+    parent_id: String,
+) -> Result<Vec<RecordRow>, String> {
+    Ok(state
+        .db
+        .get_archives_by_parent_id(room_id, &parent_id)
+        .await?)
+}
+
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn get_archive_subtitle(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
     live_id: String,
 ) -> Result<String, String> {
     let platform = PlatformType::from_str(&platform);
     if platform.is_none() {
         return Err("Unsupported platform".to_string());
     }
-    Ok(state.recorder_manager.get_archive_subtitle(platform.unwrap(), room_id, &live_id).await?)
+    Ok(state
+        .recorder_manager
+        .get_archive_subtitle(platform.unwrap(), room_id, &live_id)
+        .await?)
 }
 
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn generate_archive_subtitle(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
     live_id: String,
 ) -> Result<String, String> {
     let platform = PlatformType::from_str(&platform);
     if platform.is_none() {
         return Err("Unsupported platform".to_string());
     }
-    Ok(state.recorder_manager.generate_archive_subtitle(platform.unwrap(), room_id, &live_id).await?)
+    Ok(state
+        .recorder_manager
+        .generate_archive_subtitle(platform.unwrap(), room_id, &live_id)
+        .await?)
 }
 
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn delete_archive(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
     live_id: String,
 ) -> Result<(), String> {
     let platform = PlatformType::from_str(&platform);
     if platform.is_none() {
         return Err("Unsupported platform".to_string());
     }
-    state
+    let to_delete = state
         .recorder_manager
         .delete_archive(platform.unwrap(), room_id, &live_id)
         .await?;
@@ -183,9 +236,55 @@ pub async fn delete_archive(
         .db
         .new_message(
             "删除历史缓存",
-            &format!("删除了房间 {} 的历史缓存 {}", room_id, live_id),
+            &format!("删除了房间 {room_id} 的历史缓存 {live_id}"),
         )
         .await?;
+    // post webhook event
+    let event =
+        events::new_webhook_event(events::ARCHIVE_DELETED, events::Payload::Archive(to_delete));
+    if let Err(e) = state.webhook_poster.post_event(&event).await {
+        log::error!("Post webhook event error: {e}");
+    }
+    Ok(())
+}
+
+#[cfg_attr(feature = "gui", tauri::command)]
+pub async fn delete_archives(
+    state: state_type!(),
+    platform: String,
+    room_id: i64,
+    live_ids: Vec<String>,
+) -> Result<(), String> {
+    let platform = PlatformType::from_str(&platform);
+    if platform.is_none() {
+        return Err("Unsupported platform".to_string());
+    }
+    let to_deletes = state
+        .recorder_manager
+        .delete_archives(
+            platform.unwrap(),
+            room_id,
+            &live_ids
+                .iter()
+                .map(std::string::String::as_str)
+                .collect::<Vec<&str>>(),
+        )
+        .await?;
+    state
+        .db
+        .new_message(
+            "删除历史缓存",
+            &format!("删除了房间 {} 的历史缓存 {}", room_id, live_ids.join(", ")),
+        )
+        .await?;
+    for to_delete in to_deletes {
+        // post webhook event
+        let event =
+            events::new_webhook_event(events::ARCHIVE_DELETED, events::Payload::Archive(to_delete));
+        if let Err(e) = state.webhook_poster.post_event(&event).await {
+            log::error!("Post webhook event error: {e}");
+        }
+    }
     Ok(())
 }
 
@@ -193,7 +292,7 @@ pub async fn delete_archive(
 pub async fn get_danmu_record(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
     live_id: String,
 ) -> Result<Vec<DanmuEntry>, String> {
     let platform = PlatformType::from_str(&platform);
@@ -210,7 +309,7 @@ pub async fn get_danmu_record(
 #[serde(rename_all = "camelCase")]
 pub struct ExportDanmuOptions {
     platform: String,
-    room_id: u64,
+    room_id: i64,
     live_id: String,
     x: i64,
     y: i64,
@@ -255,8 +354,8 @@ pub async fn export_danmu(
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn send_danmaku(
     state: state_type!(),
-    uid: u64,
-    room_id: u64,
+    uid: i64,
+    room_id: i64,
     message: String,
 ) -> Result<(), String> {
     let account = state.db.get_account("bilibili", uid).await?;
@@ -271,7 +370,7 @@ pub async fn send_danmaku(
 pub async fn get_total_length(state: state_type!()) -> Result<i64, String> {
     match state.db.get_total_length().await {
         Ok(total_length) => Ok(total_length),
-        Err(e) => Err(format!("Failed to get total length: {}", e)),
+        Err(e) => Err(format!("Failed to get total length: {e}")),
     }
 }
 
@@ -279,20 +378,20 @@ pub async fn get_total_length(state: state_type!()) -> Result<i64, String> {
 pub async fn get_today_record_count(state: state_type!()) -> Result<i64, String> {
     match state.db.get_today_record_count().await {
         Ok(count) => Ok(count),
-        Err(e) => Err(format!("Failed to get today record count: {}", e)),
+        Err(e) => Err(format!("Failed to get today record count: {e}")),
     }
 }
 
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn get_recent_record(
     state: state_type!(),
-    room_id: u64,
-    offset: u64,
-    limit: u64,
+    room_id: i64,
+    offset: i64,
+    limit: i64,
 ) -> Result<Vec<RecordRow>, String> {
     match state.db.get_recent_record(room_id, offset, limit).await {
         Ok(records) => Ok(records),
-        Err(e) => Err(format!("Failed to get recent record: {}", e)),
+        Err(e) => Err(format!("Failed to get recent record: {e}")),
     }
 }
 
@@ -300,7 +399,7 @@ pub async fn get_recent_record(
 pub async fn set_enable(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
     enabled: bool,
 ) -> Result<(), String> {
     log::info!("Set enable for recorder {platform} {room_id} {enabled}");
@@ -323,9 +422,70 @@ pub async fn fetch_hls(state: state_type!(), uri: String) -> Result<Vec<u8>, Str
     } else {
         uri
     };
-    state
+    Ok(state
         .recorder_manager
         .handle_hls_request(&uri)
         .await
-        .map_err(|e| e.to_string())
+        .unwrap())
+}
+
+#[cfg_attr(feature = "gui", tauri::command)]
+pub async fn generate_whole_clip(
+    state: state_type!(),
+    platform: String,
+    room_id: i64,
+    parent_id: String,
+) -> Result<TaskRow, String> {
+    log::info!("Generate whole clip for {platform} {room_id} {parent_id}");
+
+    let task = state
+        .db
+        .generate_task(
+            "generate_whole_clip",
+            "",
+            &serde_json::json!({
+                "platform": platform,
+                "room_id": room_id,
+                "parent_id": parent_id,
+            })
+            .to_string(),
+        )
+        .await?;
+
+    #[cfg(feature = "gui")]
+    let emitter = EventEmitter::new(state.app_handle.clone());
+    #[cfg(feature = "headless")]
+    let emitter = EventEmitter::new(state.progress_manager.get_event_sender());
+    let reporter = ProgressReporter::new(&emitter, &task.id).await?;
+
+    log::info!("Create task: {} {}", task.id, task.task_type);
+    // create a tokio task to run in background
+    #[cfg(feature = "gui")]
+    let state_clone = (*state).clone();
+    #[cfg(feature = "headless")]
+    let state_clone = state.clone();
+
+    let task_id = task.id.clone();
+    tokio::spawn(async move {
+        if (state_clone
+            .recorder_manager
+            .generate_whole_clip(Some(&reporter), platform, room_id, parent_id)
+            .await)
+            .is_ok()
+        {
+            reporter.finish(true, "切片生成完成").await;
+            let _ = state_clone
+                .db
+                .update_task(&task_id, "success", "切片生成完成", None)
+                .await;
+            return;
+        }
+
+        reporter.finish(false, "切片生成失败").await;
+        let _ = state_clone
+            .db
+            .update_task(&task_id, "failed", "切片生成失败", None)
+            .await;
+    });
+    Ok(task)
 }

src-tauri/src/handlers/utils.rs

@@ -57,9 +57,13 @@ pub fn show_in_folder(path: String) {
                     path2.into_os_string().into_string().unwrap()
                 }
             };
-            Command::new("xdg-open").arg(&new_path).spawn().unwrap();
+            let _ = Command::new("xdg-open")
+                .arg(&new_path)
+                .spawn()
+                .unwrap()
+                .wait();
         } else {
-            Command::new("dbus-send")
+            let _ = Command::new("dbus-send")
                 .args([
                     "--session",
                     "--dest=org.freedesktop.FileManager1",
@@ -70,7 +74,8 @@ pub fn show_in_folder(path: String) {
                     "string:\"\"",
                 ])
                 .spawn()
-                .unwrap();
+                .unwrap()
+                .wait();
         }
     }
 
@@ -109,10 +114,10 @@ pub async fn get_disk_info(state: state_type!()) -> Result<DiskInfo, ()> {
 #[cfg_attr(feature = "gui", tauri::command)]
 pub async fn console_log(_state: state_type!(), level: &str, message: &str) -> Result<(), ()> {
     match level {
-        "error" => log::error!("[frontend] {}", message),
-        "warn" => log::warn!("[frontend] {}", message),
-        "info" => log::info!("[frontend] {}", message),
-        _ => log::debug!("[frontend] {}", message),
+        "error" => log::error!("[frontend] {message}"),
+        "warn" => log::warn!("[frontend] {message}"),
+        "info" => log::info!("[frontend] {message}"),
+        _ => log::debug!("[frontend] {message}"),
     }
     Ok(())
 }
@@ -139,7 +144,7 @@ pub async fn get_disk_info_inner(target: PathBuf) -> Result<DiskInfo, ()> {
         let total = parts[1].parse::<u64>().unwrap() * 1024;
         let free = parts[3].parse::<u64>().unwrap() * 1024;
 
-        return Ok(DiskInfo { disk, total, free });
+        Ok(DiskInfo { disk, total, free })
     }
 
     #[cfg(any(target_os = "windows", target_os = "macos"))]
@@ -148,7 +153,7 @@ pub async fn get_disk_info_inner(target: PathBuf) -> Result<DiskInfo, ()> {
         let disks = sysinfo::Disks::new_with_refreshed_list();
         // get target disk info
         let mut disk_info = DiskInfo {
-            disk: "".into(),
+            disk: String::new(),
             total: 0,
             free: 0,
         };
@@ -157,11 +162,11 @@ pub async fn get_disk_info_inner(target: PathBuf) -> Result<DiskInfo, ()> {
         let mut longest_match = 0;
         for disk in disks.list() {
             let mount_point = disk.mount_point().to_str().unwrap();
-            if target.starts_with(mount_point) && mount_point.split("/").count() > longest_match {
+            if target.starts_with(mount_point) && mount_point.split('/').count() > longest_match {
                 disk_info.disk = mount_point.into();
                 disk_info.total = disk.total_space();
                 disk_info.free = disk.available_space();
-                longest_match = mount_point.split("/").count();
+                longest_match = mount_point.split('/').count();
             }
         }
 
@@ -187,10 +192,10 @@ pub async fn export_to_file(
     }
     let mut file = file.unwrap();
     if let Err(e) = file.write_all(content.as_bytes()).await {
-        return Err(format!("Write file failed: {}", e));
+        return Err(format!("Write file failed: {e}"));
     }
     if let Err(e) = file.flush().await {
-        return Err(format!("Flush file failed: {}", e));
+        return Err(format!("Flush file failed: {e}"));
     }
     Ok(())
 }
@@ -211,10 +216,10 @@ pub async fn open_log_folder(state: state_type!()) -> Result<(), String> {
 pub async fn open_live(
     state: state_type!(),
     platform: String,
-    room_id: u64,
+    room_id: i64,
     live_id: String,
 ) -> Result<(), String> {
-    log::info!("Open player window: {} {}", room_id, live_id);
+    log::info!("Open player window: {room_id} {live_id}");
     #[cfg(feature = "gui")]
     {
         let platform = PlatformType::from_str(&platform).unwrap();
@@ -225,7 +230,7 @@ pub async fn open_live(
             .unwrap();
         let builder = tauri::WebviewWindowBuilder::new(
             &state.app_handle,
-            format!("Live:{}:{}", room_id, live_id),
+            format!("Live:{room_id}:{live_id}"),
             tauri::WebviewUrl::App(
                 format!(
                     "index_live.html?platform={}&room_id={}&live_id={}",
@@ -253,7 +258,7 @@ pub async fn open_live(
         });
 
         if let Err(e) = builder.decorations(true).build() {
-            log::error!("live window build failed: {}", e);
+            log::error!("live window build failed: {e}");
         }
     }
 
@@ -263,13 +268,13 @@ pub async fn open_live(
 #[cfg(feature = "gui")]
 #[tauri::command]
 pub async fn open_clip(state: state_type!(), video_id: i64) -> Result<(), String> {
-    log::info!("Open clip window: {}", video_id);
+    log::info!("Open clip window: {video_id}");
     let builder = tauri::WebviewWindowBuilder::new(
         &state.app_handle,
-        format!("Clip:{}", video_id),
-        tauri::WebviewUrl::App(format!("index_clip.html?id={}", video_id).into()),
+        format!("Clip:{video_id}"),
+        tauri::WebviewUrl::App(format!("index_clip.html?id={video_id}").into()),
     )
-    .title(format!("Clip window:{}", video_id))
+    .title(format!("Clip window:{video_id}"))
     .theme(Some(Theme::Light))
     .inner_size(1200.0, 800.0)
     .effects(WindowEffectsConfig {
@@ -283,7 +288,7 @@ pub async fn open_clip(state: state_type!(), video_id: i64) -> Result<(), String
     });
 
     if let Err(e) = builder.decorations(true).build() {
-        log::error!("clip window build failed: {}", e);
+        log::error!("clip window build failed: {e}");
     }
 
     Ok(())
@@ -301,4 +306,129 @@ pub async fn list_folder(_state: state_type!(), path: String) -> Result<Vec<Stri
         files.push(entry.path().to_str().unwrap().to_string());
     }
     Ok(files)
-}
+}
+
+/// 高级文件名清理函数，全面处理各种危险字符和控制字符
+///
+/// 适用于需要严格文件名清理的场景，支持中文字符
+///
+/// # 参数
+/// - `name`: 需要清理的文件名
+/// - `max_length`: 最大长度限制（默认100字符）
+///
+/// # 返回
+/// 经过全面清理的安全文件名
+#[cfg(feature = "headless")]
+pub fn sanitize_filename_advanced(name: &str, max_length: Option<usize>) -> String {
+    let max_len = max_length.unwrap_or(100);
+
+    // 先清理所有字符
+    let cleaned: String = name
+        .chars()
+        .map(|c| match c {
+            // 文件系统危险字符
+            '\\' | '/' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            // 控制字符和不可见字符
+            c if c.is_control() => '_',
+            // 保留安全的字符（白名单）
+            c if c.is_alphanumeric()
+                || c == ' '
+                || c == '.'
+                || c == '-'
+                || c == '_'
+                || c == '('
+                || c == ')'
+                || c == '['
+                || c == ']'
+                || c == '《'
+                || c == '》'
+                || c == '（'
+                || c == '）' =>
+            {
+                c
+            }
+            // 其他字符替换为下划线
+            _ => '_',
+        })
+        .collect();
+
+    // 如果清理后的长度在限制内，直接返回
+    if cleaned.chars().count() <= max_len {
+        return cleaned;
+    }
+
+    // 智能截断：保护文件扩展名
+    if let Some(dot_pos) = cleaned.rfind('.') {
+        let extension = &cleaned[dot_pos..];
+        let main_part = &cleaned[..dot_pos];
+
+        // 确保扩展名不会太长（最多10个字符，包括点号）
+        if extension.chars().count() <= 10 {
+            let ext_len = extension.chars().count();
+            let available_for_main = max_len.saturating_sub(ext_len);
+
+            if available_for_main > 0 {
+                let truncated_main: String = main_part.chars().take(available_for_main).collect();
+                return format!("{}{}", truncated_main, extension);
+            }
+        }
+    }
+
+    // 如果没有扩展名或扩展名太长，直接截断
+    cleaned.chars().take(max_len).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "headless")]
+    fn test_sanitize_filename_advanced() {
+        use super::sanitize_filename_advanced;
+
+        assert_eq!(
+            sanitize_filename_advanced("test<>file.txt", None),
+            "test__file.txt"
+        );
+        assert_eq!(sanitize_filename_advanced("文件名.txt", None), "文件名.txt");
+        assert_eq!(
+            sanitize_filename_advanced("《视频》（高清）.mp4", None),
+            "《视频》（高清）.mp4"
+        );
+        assert_eq!(
+            sanitize_filename_advanced("file\x00with\x01control.txt", None),
+            "file_with_control.txt"
+        );
+
+        // 测试空白字符处理（函数不自动移除空白字符）
+        assert_eq!(
+            sanitize_filename_advanced("   .hidden_file.txt   ", None),
+            "   .hidden_file.txt   "
+        );
+        assert_eq!(
+            sanitize_filename_advanced("  normal_file.mp4  ", None),
+            "  normal_file.mp4  "
+        );
+
+        // 测试特殊字符替换
+        assert_eq!(
+            sanitize_filename_advanced("file@#$%^&.txt", None),
+            "file______.txt"
+        );
+
+        // 测试长度限制 - 无扩展名
+        let long_name = "测试".repeat(60);
+        let result = sanitize_filename_advanced(&long_name, Some(10));
+        assert_eq!(result.chars().count(), 10);
+
+        // 测试长度限制 - 有扩展名
+        let long_name_with_ext = format!("{}.txt", "测试".repeat(60));
+        let result = sanitize_filename_advanced(&long_name_with_ext, Some(10));
+        assert!(result.ends_with(".txt"));
+        assert_eq!(result.chars().count(), 10); // 6个测试字符 + .txt (4个字符)
+
+        // 测试短文件名不被截断
+        let short_name = "test.mp4";
+        let result = sanitize_filename_advanced(short_name, Some(50));
+        assert_eq!(result, "test.mp4");
+    }
+}

src-tauri/src/main.rs

@@ -1,30 +1,33 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-mod archive_migration;
 mod config;
+mod constants;
 mod danmu2ass;
 mod database;
 mod ffmpeg;
 mod handlers;
 #[cfg(feature = "headless")]
 mod http_server;
-#[cfg(feature = "headless")]
 mod migration;
-mod progress_manager;
-mod progress_reporter;
+mod progress;
 mod recorder;
 mod recorder_manager;
 mod state;
 mod subtitle_generator;
 #[cfg(feature = "gui")]
 mod tray;
+mod webhook;
 
-use archive_migration::try_rebuild_archives;
 use async_std::fs;
 use chrono::Utc;
 use config::Config;
 use database::Database;
+use migration::migration_methods::try_add_parent_id_to_records;
+use migration::migration_methods::try_convert_clip_covers;
+use migration::migration_methods::try_convert_entry_to_m3u8;
+use migration::migration_methods::try_convert_live_covers;
+use migration::migration_methods::try_rebuild_archives;
 use recorder::bilibili::client::BiliClient;
 use recorder::PlatformType;
 use recorder_manager::RecorderManager;
@@ -117,6 +120,9 @@ async fn setup_logging(log_dir: &Path) -> Result<(), Box<dyn std::error::Error>>
         ),
     ])?;
 
+    // logging current package version
+    log::info!("Current version: {}", env!("CARGO_PKG_VERSION"));
+
     Ok(())
 }
 
@@ -125,41 +131,73 @@ fn get_migrations() -> Vec<Migration> {
         Migration {
             version: 1,
             description: "create_initial_tables",
-            sql: r#"
+            sql: r"
                 CREATE TABLE accounts (uid INTEGER, platform TEXT NOT NULL DEFAULT 'bilibili', name TEXT, avatar TEXT, csrf TEXT, cookies TEXT, created_at TEXT, PRIMARY KEY(uid, platform));
                 CREATE TABLE recorders (room_id INTEGER PRIMARY KEY, platform TEXT NOT NULL DEFAULT 'bilibili', created_at TEXT);
                 CREATE TABLE records (live_id TEXT PRIMARY KEY, platform TEXT NOT NULL DEFAULT 'bilibili', room_id INTEGER, title TEXT, length INTEGER, size INTEGER, cover BLOB, created_at TEXT);
                 CREATE TABLE danmu_statistics (live_id TEXT PRIMARY KEY, room_id INTEGER, value INTEGER, time_point TEXT);
                 CREATE TABLE messages (id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT, content TEXT, read INTEGER, created_at TEXT);
                 CREATE TABLE videos (id INTEGER PRIMARY KEY AUTOINCREMENT, room_id INTEGER, cover TEXT, file TEXT, length INTEGER, size INTEGER, status INTEGER, bvid TEXT, title TEXT, desc TEXT, tags TEXT, area INTEGER, created_at TEXT);
-                "#,
+                ",
             kind: MigrationKind::Up,
         },
         Migration {
             version: 2,
             description: "add_auto_start_column",
-            sql: r#"ALTER TABLE recorders ADD COLUMN auto_start INTEGER NOT NULL DEFAULT 1;"#,
+            sql: r"ALTER TABLE recorders ADD COLUMN auto_start INTEGER NOT NULL DEFAULT 1;",
             kind: MigrationKind::Up,
         },
         // add platform column to videos table
         Migration {
             version: 3,
             description: "add_platform_column",
-            sql: r#"ALTER TABLE videos ADD COLUMN platform TEXT;"#,
+            sql: r"ALTER TABLE videos ADD COLUMN platform TEXT;",
             kind: MigrationKind::Up,
         },
         // add task table to record encode/upload task
         Migration {
             version: 4,
             description: "add_task_table",
-            sql: r#"CREATE TABLE tasks (id TEXT PRIMARY KEY, type TEXT, status TEXT, message TEXT, metadata TEXT, created_at TEXT);"#,
+            sql: r"CREATE TABLE tasks (id TEXT PRIMARY KEY, type TEXT, status TEXT, message TEXT, metadata TEXT, created_at TEXT);",
             kind: MigrationKind::Up,
         },
         // add id_str column to support string IDs like Douyin sec_uid while keeping uid for Bilibili compatibility
         Migration {
             version: 5,
             description: "add_id_str_column",
-            sql: r#"ALTER TABLE accounts ADD COLUMN id_str TEXT;"#,
+            sql: r"ALTER TABLE accounts ADD COLUMN id_str TEXT;",
+            kind: MigrationKind::Up,
+        },
+        // add extra column to recorders
+        Migration {
+            version: 6,
+            description: "add_extra_column_to_recorders",
+            sql: r"ALTER TABLE recorders ADD COLUMN extra TEXT;",
+            kind: MigrationKind::Up,
+        },
+        // add indexes
+        Migration {
+            version: 7,
+            description: "add_indexes",
+            sql: r"
+                CREATE INDEX idx_records_live_id ON records (room_id, live_id);
+                CREATE INDEX idx_records_created_at ON records (room_id, created_at);
+                CREATE INDEX idx_videos_room_id ON videos (room_id);
+                CREATE INDEX idx_videos_created_at ON videos (created_at);
+            ",
+            kind: MigrationKind::Up,
+        },
+        // add note column for video
+        Migration {
+            version: 8,
+            description: "add_note_column_for_video",
+            sql: r"ALTER TABLE videos ADD COLUMN note TEXT;",
+            kind: MigrationKind::Up,
+        },
+        Migration {
+            version: 9,
+            description: "add_parent_id_column_for_record",
+            sql: r"ALTER TABLE records ADD COLUMN parent_id TEXT;",
             kind: MigrationKind::Up,
         },
     ]
@@ -194,8 +232,8 @@ impl MigrationSource<'static> for MigrationList {
 async fn setup_server_state(args: Args) -> Result<State, Box<dyn std::error::Error>> {
     use std::path::PathBuf;
 
-    use progress_manager::ProgressManager;
-    use progress_reporter::EventEmitter;
+    use progress::progress_manager::ProgressManager;
+    use progress::progress_reporter::EventEmitter;
 
     setup_logging(Path::new("./")).await?;
     log::info!("Setting up server state...");
@@ -239,7 +277,14 @@ async fn setup_server_state(args: Args) -> Result<State, Box<dyn std::error::Err
 
     let progress_manager = Arc::new(ProgressManager::new());
     let emitter = EventEmitter::new(progress_manager.get_event_sender());
-    let recorder_manager = Arc::new(RecorderManager::new(emitter, db.clone(), config.clone()));
+    let webhook_poster =
+        webhook::poster::create_webhook_poster(&config.read().await.webhook_url, None).unwrap();
+    let recorder_manager = Arc::new(RecorderManager::new(
+        emitter,
+        db.clone(),
+        config.clone(),
+        webhook_poster.clone(),
+    ));
 
     // Update account infos for headless mode
     let accounts = db.get_accounts().await?;
@@ -298,11 +343,16 @@ async fn setup_server_state(args: Args) -> Result<State, Box<dyn std::error::Err
     }
 
     let _ = try_rebuild_archives(&db, config.read().await.cache.clone().into()).await;
+    let _ = try_convert_live_covers(&db, config.read().await.cache.clone().into()).await;
+    let _ = try_convert_clip_covers(&db, config.read().await.output.clone().into()).await;
+    let _ = try_add_parent_id_to_records(&db).await;
+    let _ = try_convert_entry_to_m3u8(&db, config.read().await.cache.clone().into()).await;
 
     Ok(State {
         db,
         client,
         config,
+        webhook_poster,
         recorder_manager,
         progress_manager,
         readonly: args.readonly,
@@ -312,7 +362,7 @@ async fn setup_server_state(args: Args) -> Result<State, Box<dyn std::error::Err
 #[cfg(feature = "gui")]
 async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::Error>> {
     use platform_dirs::AppDirs;
-    use progress_reporter::EventEmitter;
+    use progress::progress_reporter::EventEmitter;
 
     let log_dir = app.path().app_log_dir()?;
     setup_logging(&log_dir).await?;
@@ -322,7 +372,7 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
     let config_path = app_dirs.config_dir.join("Conf.toml");
     let cache_path = app_dirs.cache_dir.join("cache");
     let output_path = app_dirs.data_dir.join("output");
-    log::info!("Loading config from {:?}", config_path);
+    log::info!("Loading config from {config_path:?}");
     let config = match Config::load(&config_path, &cache_path, &output_path) {
         Ok(config) => config,
         Err(e) => {
@@ -346,12 +396,15 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
     };
     db_clone.set(sqlite_pool.unwrap().clone()).await;
     db_clone.finish_pending_tasks().await?;
+    let webhook_poster =
+        webhook::poster::create_webhook_poster(&config.read().await.webhook_url, None).unwrap();
 
     let recorder_manager = Arc::new(RecorderManager::new(
         app.app_handle().clone(),
         emitter,
         db.clone(),
         config.clone(),
+        webhook_poster.clone(),
     ));
 
     let accounts = db_clone.get_accounts().await?;
@@ -363,10 +416,11 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
             config,
             recorder_manager,
             app_handle: app.handle().clone(),
+            webhook_poster,
         });
     }
 
-    // update account infos
+    // update account info
     for account in accounts {
         let platform = PlatformType::from_str(&account.platform).unwrap();
 
@@ -382,11 +436,11 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
                         )
                         .await
                     {
-                        log::error!("Error when updating Bilibili account info {}", e);
+                        log::error!("Error when updating Bilibili account info {e}");
                     }
                 }
                 Err(e) => {
-                    log::error!("Get Bilibili user info failed {}", e);
+                    log::error!("Get Bilibili user info failed {e}");
                 }
             }
         } else if platform == PlatformType::Douyin {
@@ -411,11 +465,11 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
                         )
                         .await
                     {
-                        log::error!("Error when updating Douyin account info {}", e);
+                        log::error!("Error when updating Douyin account info {e}");
                     }
                 }
                 Err(e) => {
-                    log::error!("Get Douyin user info failed {}", e);
+                    log::error!("Get Douyin user info failed {e}");
                 }
             }
         }
@@ -423,9 +477,14 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
 
     // try to rebuild archive table
     let cache_path = config_clone.read().await.cache.clone();
-    if let Err(e) = try_rebuild_archives(&db_clone, cache_path.into()).await {
-        log::warn!("Rebuilding archive table failed: {}", e);
+    let output_path = config_clone.read().await.output.clone();
+    if let Err(e) = try_rebuild_archives(&db_clone, cache_path.clone().into()).await {
+        log::warn!("Rebuilding archive table failed: {e}");
     }
+    let _ = try_convert_live_covers(&db_clone, cache_path.clone().into()).await;
+    let _ = try_convert_clip_covers(&db_clone, output_path.clone().into()).await;
+    let _ = try_add_parent_id_to_records(&db_clone).await;
+    let _ = try_convert_entry_to_m3u8(&db_clone, cache_path.clone().into()).await;
 
     Ok(State {
         db,
@@ -433,6 +492,7 @@ async fn setup_app_state(app: &tauri::App) -> Result<State, Box<dyn std::error::
         config,
         recorder_manager,
         app_handle: app.handle().clone(),
+        webhook_poster,
     })
 }
 
@@ -501,6 +561,7 @@ fn setup_invoke_handlers(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<
         crate::handlers::config::update_auto_generate,
         crate::handlers::config::update_status_check_interval,
         crate::handlers::config::update_whisper_language,
+        crate::handlers::config::update_webhook_url,
         crate::handlers::message::get_messages,
         crate::handlers::message::read_message,
         crate::handlers::message::delete_message,
@@ -508,11 +569,14 @@ fn setup_invoke_handlers(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<
         crate::handlers::recorder::add_recorder,
         crate::handlers::recorder::remove_recorder,
         crate::handlers::recorder::get_room_info,
+        crate::handlers::recorder::get_archive_disk_usage,
         crate::handlers::recorder::get_archives,
         crate::handlers::recorder::get_archive,
+        crate::handlers::recorder::get_archives_by_parent_id,
         crate::handlers::recorder::get_archive_subtitle,
         crate::handlers::recorder::generate_archive_subtitle,
         crate::handlers::recorder::delete_archive,
+        crate::handlers::recorder::delete_archives,
         crate::handlers::recorder::get_danmu_record,
         crate::handlers::recorder::export_danmu,
         crate::handlers::recorder::send_danmaku,
@@ -521,6 +585,7 @@ fn setup_invoke_handlers(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<
         crate::handlers::recorder::get_recent_record,
         crate::handlers::recorder::set_enable,
         crate::handlers::recorder::fetch_hls,
+        crate::handlers::recorder::generate_whole_clip,
         crate::handlers::video::clip_range,
         crate::handlers::video::upload_procedure,
         crate::handlers::video::cancel,
@@ -534,8 +599,14 @@ fn setup_invoke_handlers(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<
         crate::handlers::video::generate_video_subtitle,
         crate::handlers::video::get_video_subtitle,
         crate::handlers::video::update_video_subtitle,
+        crate::handlers::video::update_video_note,
         crate::handlers::video::encode_video_subtitle,
         crate::handlers::video::generic_ffmpeg_command,
+        crate::handlers::video::import_external_video,
+        crate::handlers::video::batch_import_external_videos,
+        crate::handlers::video::clip_video,
+        crate::handlers::video::get_file_size,
+        crate::handlers::video::get_import_progress,
         crate::handlers::task::get_tasks,
         crate::handlers::task::delete_task,
         crate::handlers::utils::show_in_folder,
@@ -553,7 +624,7 @@ fn setup_invoke_handlers(builder: tauri::Builder<tauri::Wry>) -> tauri::Builder<
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let _ = fix_path_env::fix();
 
-    let builder = tauri::Builder::default();
+    let builder = tauri::Builder::default().plugin(tauri_plugin_deep_link::init());
     let builder = setup_plugins(builder);
     let builder = setup_event_handlers(builder);
     let builder = setup_invoke_handlers(builder);

src-tauri/src/migration/migration_methods.rs

@@ -0,0 +1,170 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use base64::Engine;
+
+use crate::database::Database;
+use crate::recorder::entry::EntryStore;
+use crate::recorder::PlatformType;
+
+pub async fn try_rebuild_archives(
+    db: &Arc<Database>,
+    cache_path: PathBuf,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let rooms = db.get_recorders().await?;
+    for room in rooms {
+        let room_id = room.room_id;
+        let room_cache_path = cache_path.join(format!("{}/{}", room.platform, room_id));
+        let mut files = tokio::fs::read_dir(room_cache_path).await?;
+        while let Some(file) = files.next_entry().await? {
+            if file.file_type().await?.is_dir() {
+                // use folder name as live_id
+                let live_id = file.file_name();
+                let live_id = live_id.to_str().unwrap();
+                // check if live_id is in db
+                let record = db.get_record(room_id, live_id).await;
+                if record.is_ok() {
+                    continue;
+                }
+
+                // create a record for this live_id
+                let record = db
+                    .add_record(
+                        PlatformType::from_str(room.platform.as_str()).unwrap(),
+                        live_id,
+                        live_id,
+                        room_id,
+                        &format!("UnknownLive {live_id}"),
+                        None,
+                    )
+                    .await?;
+
+                log::info!("rebuild archive {record:?}");
+            }
+        }
+    }
+    Ok(())
+}
+
+pub async fn try_convert_live_covers(
+    db: &Arc<Database>,
+    cache_path: PathBuf,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let rooms = db.get_recorders().await?;
+    for room in rooms {
+        let room_id = room.room_id;
+        let room_cache_path = cache_path.join(format!("{}/{}", room.platform, room_id));
+        let records = db.get_records(room_id, 0, 999_999_999).await?;
+        for record in &records {
+            let record_path = room_cache_path.join(record.live_id.clone());
+            let cover = record.cover.clone();
+            if cover.is_none() {
+                continue;
+            }
+
+            let cover = cover.unwrap();
+            if cover.starts_with("data:") {
+                let base64 = cover.split("base64,").nth(1).unwrap();
+                let bytes = base64::engine::general_purpose::STANDARD
+                    .decode(base64)
+                    .unwrap();
+                let path = record_path.join("cover.jpg");
+                tokio::fs::write(&path, bytes).await?;
+
+                log::info!("convert live cover: {}", path.display());
+                // update record
+                db.update_record_cover(
+                    record.live_id.as_str(),
+                    Some(format!(
+                        "{}/{}/{}/cover.jpg",
+                        room.platform, room_id, record.live_id
+                    )),
+                )
+                .await?;
+            }
+        }
+    }
+    Ok(())
+}
+
+pub async fn try_convert_clip_covers(
+    db: &Arc<Database>,
+    output_path: PathBuf,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let videos = db.get_all_videos().await?;
+    log::debug!("videos: {}", videos.len());
+    for video in &videos {
+        let cover = video.cover.clone();
+        if cover.starts_with("data:") {
+            let base64 = cover.split("base64,").nth(1).unwrap();
+            let bytes = base64::engine::general_purpose::STANDARD
+                .decode(base64)
+                .unwrap();
+
+            let video_file_path = output_path.join(video.file.clone());
+            let cover_file_path = video_file_path.with_extension("jpg");
+            log::debug!("cover_file_path: {}", cover_file_path.display());
+            tokio::fs::write(&cover_file_path, bytes).await?;
+
+            log::info!("convert clip cover: {}", cover_file_path.display());
+            // update record
+            db.update_video_cover(
+                video.id,
+                cover_file_path.file_name().unwrap().to_str().unwrap(),
+            )
+            .await?;
+        }
+    }
+    Ok(())
+}
+
+pub async fn try_add_parent_id_to_records(
+    db: &Arc<Database>,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let rooms = db.get_recorders().await?;
+    for room in &rooms {
+        let records = db.get_records(room.room_id, 0, 999_999_999).await?;
+        for record in &records {
+            if record.parent_id.is_empty() {
+                db.update_record_parent_id(record.live_id.as_str(), record.live_id.as_str())
+                    .await?;
+            }
+        }
+    }
+    Ok(())
+}
+
+pub async fn try_convert_entry_to_m3u8(
+    db: &Arc<Database>,
+    cache_path: PathBuf,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let rooms = db.get_recorders().await?;
+    for room in &rooms {
+        let records = db.get_records(room.room_id, 0, 999_999_999).await?;
+        for record in &records {
+            let record_path = cache_path.join(format!(
+                "{}/{}/{}",
+                room.platform, room.room_id, record.live_id
+            ));
+            let entry_file = record_path.join("entries.log");
+            let m3u8_file_path = record_path.join("playlist.m3u8");
+            if !entry_file.exists() || m3u8_file_path.exists() {
+                continue;
+            }
+            let entry_store = EntryStore::new(record_path.to_str().unwrap()).await;
+            if entry_store.len() == 0 {
+                continue;
+            }
+            let m3u8_content = entry_store.manifest(true, true, None);
+
+            tokio::fs::write(&m3u8_file_path, m3u8_content).await?;
+            log::info!(
+                "Convert entry to m3u8: {} => {}",
+                entry_file.display(),
+                m3u8_file_path.display()
+            );
+        }
+    }
+
+    Ok(())
+}

src-tauri/src/migration/mod.rs

@@ -1,3 +1,5 @@
+pub mod migration_methods;
+
 use sqlx::migrate::MigrationType;
 
 #[derive(Debug)]
@@ -6,6 +8,7 @@ pub enum MigrationKind {
     Down,
 }
 
+#[cfg(feature = "headless")]
 #[derive(Debug)]
 pub struct Migration {
     pub version: i64,

src-tauri/src/progress/mod.rs

@@ -0,0 +1,2 @@
+pub mod progress_manager;
+pub mod progress_reporter;

src-tauri/src/progress/progress_manager.rs

@@ -15,7 +15,7 @@ pub enum Event {
         message: String,
     },
     DanmuReceived {
-        room: u64,
+        room: i64,
         ts: i64,
         content: String,
     },
@@ -30,7 +30,7 @@ pub struct ProgressManager {
 #[cfg(feature = "headless")]
 impl ProgressManager {
     pub fn new() -> Self {
-        let (progress_sender, progress_receiver) = broadcast::channel(16);
+        let (progress_sender, progress_receiver) = broadcast::channel(256);
         Self {
             progress_sender,
             progress_receiver,

src-tauri/src/progress/progress_reporter.rs

@@ -4,7 +4,7 @@ use std::sync::Arc;
 use std::sync::LazyLock;
 use tokio::sync::RwLock;
 
-use crate::progress_manager::Event;
+use crate::progress::progress_manager::Event;
 
 #[cfg(feature = "gui")]
 use {
@@ -98,7 +98,7 @@ impl EventEmitter {
                 Event::DanmuReceived { room, ts, content } => {
                     self.app_handle
                         .emit(
-                            &format!("danmu:{}", room),
+                            &format!("danmu:{room}"),
                             DanmuEntry {
                                 ts: *ts,
                                 content: content.clone(),
@@ -117,7 +117,7 @@ impl ProgressReporter {
     pub async fn new(emitter: &EventEmitter, event_id: &str) -> Result<Self, String> {
         // if already exists, return
         if CANCEL_FLAG_MAP.read().await.get(event_id).is_some() {
-            log::error!("Task already exists: {}", event_id);
+            log::error!("Task already exists: {event_id}");
             emitter.emit(&Event::ProgressFinished {
                 id: event_id.to_string(),
                 success: false,

src-tauri/src/recorder/bilibili/client.rs

@@ -7,11 +7,13 @@ use super::response::PostVideoMetaResponse;
 use super::response::PreuploadResponse;
 use super::response::VideoSubmitData;
 use crate::database::account::AccountRow;
-use crate::progress_reporter::ProgressReporter;
-use crate::progress_reporter::ProgressReporterTrait;
-use base64::Engine;
+use crate::progress::progress_reporter::ProgressReporter;
+use crate::progress::progress_reporter::ProgressReporterTrait;
+use crate::recorder::user_agent_generator;
+use chrono::TimeZone;
 use pct_str::PctString;
 use pct_str::URIReserved;
+use rand::seq::SliceRandom;
 use regex::Regex;
 use reqwest::Client;
 use serde::Deserialize;
@@ -38,15 +40,16 @@ struct UploadParams<'a> {
 pub struct RoomInfo {
     pub live_status: u8,
     pub room_cover_url: String,
-    pub room_id: u64,
+    pub room_id: i64,
     pub room_keyframe_url: String,
     pub room_title: String,
-    pub user_id: u64,
+    pub user_id: i64,
+    pub live_start_time: i64,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct UserInfo {
-    pub user_id: u64,
+    pub user_id: i64,
     pub user_name: String,
     pub user_sign: String,
     pub user_avatar_url: String,
@@ -66,71 +69,138 @@ pub struct QrStatus {
     pub cookies: String,
 }
 
-/// BiliClient is thread safe
+/// `BiliClient` is thread safe
 pub struct BiliClient {
     client: Client,
-    headers: reqwest::header::HeaderMap,
-}
-
-#[derive(Clone, Copy, PartialEq, Eq, Debug)]
-pub enum StreamType {
-    TS,
-    FMP4,
 }
 
 #[derive(Clone, Debug)]
 pub struct BiliStream {
-    pub format: StreamType,
+    pub format: Format,
+    pub codec: Codec,
+    pub base_url: String,
+    pub url_info: Vec<UrlInfo>,
+    pub drm: bool,
+    pub master_url: Option<String>,
+}
+
+#[derive(Clone, Debug)]
+pub struct UrlInfo {
     pub host: String,
-    pub path: String,
     pub extra: String,
-    pub expire: i64,
+}
+
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub enum Protocol {
+    HttpStream,
+    HttpHls,
+}
+
+impl fmt::Display for Protocol {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Format {
+    Flv,
+    TS,
+    FMP4,
+}
+
+impl fmt::Display for Format {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum Codec {
+    Avc,
+    Hevc,
+}
+
+impl fmt::Display for Codec {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+// 30000	杜比
+// 20000	4K
+// 15000    2K
+// 10000	原画
+// 400	蓝光
+// 250	超清
+// 150	高清
+// 80	流畅
+
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub enum Qn {
+    Dolby = 30000,
+    Q4K = 20000,
+    Q2K = 15000,
+    Q1080PH = 10000,
+    Q1080P = 400,
+    Q720P = 250,
+    Hd = 150,
+    Smooth = 80,
+}
+
+impl fmt::Display for Qn {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
 }
 
 impl fmt::Display for BiliStream {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
-            "type: {:?}, host: {}, path: {}, extra: {}, expire: {}",
-            self.format, self.host, self.path, self.extra, self.expire
+            "type: {:?}, codec: {:?}, base_url: {}, url_info: {:?}, drm: {}, master_url: {:?}",
+            self.format, self.codec, self.base_url, self.url_info, self.drm, self.master_url
         )
     }
 }
 
 impl BiliStream {
-    pub fn new(format: StreamType, base_url: &str, host: &str, extra: &str) -> BiliStream {
+    pub fn new(
+        format: Format,
+        codec: Codec,
+        base_url: &str,
+        url_info: Vec<UrlInfo>,
+        drm: bool,
+        master_url: Option<String>,
+    ) -> BiliStream {
         BiliStream {
             format,
-            host: host.into(),
-            path: BiliStream::get_path(base_url),
-            extra: extra.into(),
-            expire: BiliStream::get_expire(extra).unwrap_or(600000),
+            codec,
+            base_url: base_url.into(),
+            url_info,
+            drm,
+            master_url,
         }
     }
 
     pub fn index(&self) -> String {
-        format!(
-            "https://{}/{}/{}?{}",
-            self.host, self.path, "index.m3u8", self.extra
-        )
+        // random choose a url_info
+        let url_info = self.url_info.choose(&mut rand::thread_rng()).unwrap();
+        format!("{}{}{}", url_info.host, self.base_url, url_info.extra)
     }
 
     pub fn ts_url(&self, seg_name: &str) -> String {
-        format!(
-            "https://{}/{}/{}?{}",
-            self.host, self.path, seg_name, self.extra
-        )
+        let m3u8_filename = self.base_url.split('/').next_back().unwrap();
+        let base_url = self.base_url.replace(m3u8_filename, seg_name);
+        let url_info = self.url_info.choose(&mut rand::thread_rng()).unwrap();
+        format!("{}{}?{}", url_info.host, base_url, url_info.extra)
     }
 
-    pub fn get_path(base_url: &str) -> String {
-        match base_url.rfind('/') {
-            Some(pos) => base_url[..pos + 1].to_string(),
-            None => base_url.to_string(),
-        }
-    }
-
-    pub fn get_expire(extra: &str) -> Option<i64> {
-        extra.split('&').find_map(|param| {
+    pub fn get_expire(&self) -> Option<i64> {
+        let url_info = self.url_info.choose(&mut rand::thread_rng()).unwrap();
+        url_info.extra.split('&').find_map(|param| {
             if param.starts_with("expires=") {
                 param.split('=').nth(1)?.parse().ok()
             } else {
@@ -138,38 +208,30 @@ impl BiliStream {
             }
         })
     }
-
-    pub fn is_same(&self, other: &BiliStream) -> bool {
-        // Extract live_id part from path (e.g., live_1848752274_71463808)
-        let get_live_id = |path: &str| {
-            path.split('/')
-                .find(|part| part.starts_with("live_"))
-                .unwrap_or("")
-                .to_string()
-        };
-        let self_live_id = get_live_id(&self.path);
-        let other_live_id = get_live_id(&other.path);
-        self_live_id == other_live_id
-    }
 }
 
 impl BiliClient {
     pub fn new() -> Result<BiliClient, BiliClientError> {
-        let mut headers = reqwest::header::HeaderMap::new();
-        headers.insert("user-agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36".parse().unwrap());
-
         if let Ok(client) = Client::builder().timeout(Duration::from_secs(10)).build() {
-            Ok(BiliClient { client, headers })
+            Ok(BiliClient { client })
         } else {
             Err(BiliClientError::InitClientError)
         }
     }
 
+    fn generate_user_agent_header(&self) -> reqwest::header::HeaderMap {
+        let user_agent = user_agent_generator::UserAgentGenerator::new().generate();
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert("user-agent", user_agent.parse().unwrap());
+        headers
+    }
+
     pub async fn get_qr(&self) -> Result<QrInfo, BiliClientError> {
+        let headers = self.generate_user_agent_header();
         let res: serde_json::Value = self
             .client
             .get("https://passport.bilibili.com/x/passport-login/web/qrcode/generate")
-            .headers(self.headers.clone())
+            .headers(headers)
             .send()
             .await?
             .json()
@@ -187,19 +249,19 @@ impl BiliClient {
     }
 
     pub async fn get_qr_status(&self, qrcode_key: &str) -> Result<QrStatus, BiliClientError> {
+        let headers = self.generate_user_agent_header();
         let res: serde_json::Value = self
             .client
             .get(format!(
-                "https://passport.bilibili.com/x/passport-login/web/qrcode/poll?qrcode_key={}",
-                qrcode_key
+                "https://passport.bilibili.com/x/passport-login/web/qrcode/poll?qrcode_key={qrcode_key}"
             ))
-            .headers(self.headers.clone())
+            .headers(headers)
             .send()
             .await?
             .json()
             .await?;
         let code: u8 = res["data"]["code"].as_u64().unwrap_or(400) as u8;
-        let mut cookies: String = "".to_string();
+        let mut cookies: String = String::new();
         if code == 0 {
             let url = res["data"]["url"]
                 .as_str()
@@ -212,8 +274,8 @@ impl BiliClient {
     }
 
     pub async fn logout(&self, account: &AccountRow) -> Result<(), BiliClientError> {
+        let mut headers = self.generate_user_agent_header();
         let url = "https://passport.bilibili.com/login/exit/v2";
-        let mut headers = self.headers.clone();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -234,7 +296,7 @@ impl BiliClient {
     pub async fn get_user_info(
         &self,
         account: &AccountRow,
-        user_id: u64,
+        user_id: i64,
     ) -> Result<UserInfo, BiliClientError> {
         let params: Value = json!({
             "mid": user_id.to_string(),
@@ -244,7 +306,7 @@ impl BiliClient {
             "w_webid": "",
         });
         let params = self.get_sign(params).await?;
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -253,8 +315,7 @@ impl BiliClient {
         let resp = self
             .client
             .get(format!(
-                "https://api.bilibili.com/x/space/wbi/acc/info?{}",
-                params
+                "https://api.bilibili.com/x/space/wbi/acc/info?{params}"
             ))
             .headers(headers)
             .send()
@@ -274,7 +335,7 @@ impl BiliClient {
             .as_u64()
             .ok_or(BiliClientError::InvalidResponseJson { resp: res.clone() })?;
         if code != 0 {
-            log::error!("Get user info failed {}", code);
+            log::error!("Get user info failed {code}");
             return Err(BiliClientError::InvalidMessageCode { code });
         }
         Ok(UserInfo {
@@ -288,9 +349,9 @@ impl BiliClient {
     pub async fn get_room_info(
         &self,
         account: &AccountRow,
-        room_id: u64,
+        room_id: i64,
     ) -> Result<RoomInfo, BiliClientError> {
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -299,8 +360,7 @@ impl BiliClient {
         let response = self
             .client
             .get(format!(
-                "https://api.live.bilibili.com/room/v1/Room/get_info?room_id={}",
-                room_id
+                "https://api.live.bilibili.com/room/v1/Room/get_info?room_id={room_id}"
             ))
             .headers(headers)
             .send()
@@ -324,7 +384,7 @@ impl BiliClient {
         }
 
         let room_id = res["data"]["room_id"]
-            .as_u64()
+            .as_i64()
             .ok_or(BiliClientError::InvalidValue)?;
         let room_title = res["data"]["title"]
             .as_str()
@@ -339,30 +399,169 @@ impl BiliClient {
             .ok_or(BiliClientError::InvalidValue)?
             .to_string();
         let user_id = res["data"]["uid"]
-            .as_u64()
+            .as_i64()
             .ok_or(BiliClientError::InvalidValue)?;
         let live_status = res["data"]["live_status"]
             .as_u64()
             .ok_or(BiliClientError::InvalidValue)? as u8;
+        // "live_time": "2025-08-09 18:33:35",
+        let live_start_time_str = res["data"]["live_time"]
+            .as_str()
+            .ok_or(BiliClientError::InvalidValue)?;
+        let live_start_time = if live_start_time_str == "0000-00-00 00:00:00" {
+            0
+        } else {
+            // this is a fixed Asia/Shanghai datetime str
+            let naive =
+                chrono::NaiveDateTime::parse_from_str(live_start_time_str, "%Y-%m-%d %H:%M:%S")
+                    .map_err(|_| BiliClientError::InvalidValue)?;
+            // parse as UTC datetime and convert to timestamp
+            chrono::Utc
+                .from_local_datetime(&naive)
+                .earliest()
+                .ok_or(BiliClientError::InvalidValue)?
+                .timestamp()
+                - 8 * 3600
+        };
         Ok(RoomInfo {
-            room_id,
-            room_title,
-            room_cover_url,
-            room_keyframe_url,
-            user_id,
             live_status,
+            room_cover_url,
+            room_id,
+            room_keyframe_url,
+            room_title,
+            user_id,
+            live_start_time,
         })
     }
 
-    /// Get and encode response data into base64
-    pub async fn get_cover_base64(&self, url: &str) -> Result<String, BiliClientError> {
+    /// Get stream info from room id
+    ///
+    /// https://socialsisteryi.github.io/bilibili-API-collect/docs/live/info.html#%E8%8E%B7%E5%8F%96%E7%9B%B4%E6%92%AD%E9%97%B4%E4%BF%A1%E6%81%AF-1
+    /// https://api.live.bilibili.com/xlive/web-room/v2/index/getRoomPlayInfo?room_id=31368705&protocol=1&format=1&codec=0&qn=10000&platform=h5
+    pub async fn get_stream_info(
+        &self,
+        account: &AccountRow,
+        room_id: i64,
+        protocol: Protocol,
+        format: Format,
+        codec: Codec,
+        qn: Qn,
+    ) -> Result<BiliStream, BiliClientError> {
+        let url = format!(
+            "https://api.live.bilibili.com/xlive/web-room/v2/index/getRoomPlayInfo?room_id={}&protocol={}&format={}&codec={}&qn={}&platform=h5",
+            room_id,
+            protocol.clone() as u8,
+            format.clone() as u8,
+            codec.clone() as u8,
+            qn as i64,
+        );
+        let mut headers = self.generate_user_agent_header();
+        if let Ok(cookies) = account.cookies.parse() {
+            headers.insert("cookie", cookies);
+        } else {
+            return Err(BiliClientError::InvalidCookie);
+        }
+        let response = self.client.get(url).headers(headers).send().await?;
+        let res: serde_json::Value = response.json().await?;
+
+        let code = res["code"].as_u64().unwrap_or(0);
+        let message = res["message"].as_str().unwrap_or("");
+        if code != 0 {
+            return Err(BiliClientError::ApiError(format!(
+                "Code {} not found, message: {}",
+                code, message
+            )));
+        }
+
+        log::debug!("Get stream info response: {res}");
+
+        // Parse the new API response structure
+        let playurl_info = &res["data"]["playurl_info"]["playurl"];
+        let empty_vec = vec![];
+        let streams = playurl_info["stream"].as_array().unwrap_or(&empty_vec);
+
+        if streams.is_empty() {
+            return Err(BiliClientError::ApiError(
+                "No streams available".to_string(),
+            ));
+        }
+
+        // Find the matching protocol
+        let target_protocol = match protocol {
+            Protocol::HttpStream => "http_stream",
+            Protocol::HttpHls => "http_hls",
+        };
+
+        let stream = streams
+            .iter()
+            .find(|s| s["protocol_name"].as_str() == Some(target_protocol))
+            .ok_or_else(|| {
+                BiliClientError::ApiError(format!("Protocol {} not found", target_protocol))
+            })?;
+
+        // Find the matching format
+        let target_format = match format {
+            Format::Flv => "flv",
+            Format::TS => "ts",
+            Format::FMP4 => "fmp4",
+        };
+
+        let empty_vec = vec![];
+        let format_info = stream["format"]
+            .as_array()
+            .unwrap_or(&empty_vec)
+            .iter()
+            .find(|f| f["format_name"].as_str() == Some(target_format))
+            .ok_or_else(|| BiliClientError::FormatNotFound(target_format.to_owned()))?;
+
+        // Find the matching codec
+        let target_codec = match codec {
+            Codec::Avc => "avc",
+            Codec::Hevc => "hevc",
+        };
+
+        let codec_info = format_info["codec"]
+            .as_array()
+            .unwrap_or(&empty_vec)
+            .iter()
+            .find(|c| c["codec_name"].as_str() == Some(target_codec))
+            .ok_or_else(|| BiliClientError::CodecNotFound(target_codec.to_owned()))?;
+
+        let url_info = codec_info["url_info"].as_array().unwrap_or(&empty_vec);
+
+        let url_info = url_info
+            .iter()
+            .map(|u| UrlInfo {
+                host: u["host"].as_str().unwrap_or("").to_string(),
+                extra: u["extra"].as_str().unwrap_or("").to_string(),
+            })
+            .collect();
+
+        let drm = codec_info["drm"].as_bool().unwrap_or(false);
+        let base_url = codec_info["base_url"].as_str().unwrap_or("").to_string();
+        let master_url = format_info["master_url"].as_str().map(|s| s.to_string());
+
+        Ok(BiliStream {
+            format,
+            codec,
+            base_url,
+            url_info,
+            drm,
+            master_url,
+        })
+    }
+
+    /// Download file from url to path
+    pub async fn download_file(&self, url: &str, path: &Path) -> Result<(), BiliClientError> {
+        if !path.parent().unwrap().exists() {
+            std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+        }
         let response = self.client.get(url).send().await?;
         let bytes = response.bytes().await?;
-        let base64 = base64::engine::general_purpose::STANDARD.encode(bytes);
-        let mime_type = mime_guess::from_path(url)
-            .first_or_octet_stream()
-            .to_string();
-        Ok(format!("data:{};base64,{}", mime_type, base64))
+        let mut file = tokio::fs::File::create(&path).await?;
+        let mut content = std::io::Cursor::new(bytes);
+        tokio::io::copy(&mut content, &mut file).await?;
+        Ok(())
     }
 
     pub async fn get_index_content(
@@ -370,7 +569,7 @@ impl BiliClient {
         account: &AccountRow,
         url: &String,
     ) -> Result<String, BiliClientError> {
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -391,11 +590,12 @@ impl BiliClient {
         }
     }
 
+    #[allow(unused)]
     pub async fn download_ts(&self, url: &str, file_path: &str) -> Result<u64, BiliClientError> {
         let res = self
             .client
             .get(url)
-            .headers(self.headers.clone())
+            .headers(self.generate_user_agent_header())
             .send()
             .await?;
         let mut file = tokio::fs::File::create(file_path).await?;
@@ -406,6 +606,12 @@ impl BiliClient {
         Ok(size)
     }
 
+    pub async fn download_ts_raw(&self, url: &str) -> Result<Vec<u8>, BiliClientError> {
+        let res = self.client.get(url).send().await?;
+        let bytes = res.bytes().await?;
+        Ok(bytes.to_vec())
+    }
+
     // Method from js code
     pub async fn get_sign(&self, mut parameters: Value) -> Result<String, BiliClientError> {
         let table = vec![
@@ -416,7 +622,7 @@ impl BiliClient {
         let nav_info: Value = self
             .client
             .get("https://api.bilibili.com/x/web-interface/nav")
-            .headers(self.headers.clone())
+            .headers(self.generate_user_agent_header())
             .send()
             .await?
             .json()
@@ -434,13 +640,13 @@ impl BiliClient {
             .get(1)
             .unwrap()
             .as_str();
-        let raw_string = format!("{}{}", img, sub);
+        let raw_string = format!("{img}{sub}");
         let mut encoded = Vec::new();
-        table.into_iter().for_each(|x| {
+        for x in table {
             if x < raw_string.len() {
                 encoded.push(raw_string.as_bytes()[x]);
             }
-        });
+        }
         // only keep 32 bytes of encoded
         encoded = encoded[0..32].to_vec();
         let encoded = String::from_utf8(encoded).unwrap();
@@ -458,12 +664,12 @@ impl BiliClient {
             .as_object()
             .unwrap()
             .keys()
-            .map(|x| x.to_owned())
+            .map(std::borrow::ToOwned::to_owned)
             .collect::<Vec<String>>();
         // sort keys
         keys.sort();
         let mut params = String::new();
-        keys.iter().for_each(|x| {
+        for x in &keys {
             params.push_str(x);
             params.push('=');
             // Value filters !'()* characters
@@ -479,10 +685,10 @@ impl BiliClient {
             if x != keys.last().unwrap() {
                 params.push('&');
             }
-        });
+        }
         // md5 params+encoded
         let w_rid = md5::compute(params.to_string() + encoded.as_str());
-        let params = params + format!("&w_rid={:x}", w_rid).as_str();
+        let params = params + format!("&w_rid={w_rid:x}").as_str();
         Ok(params)
     }
 
@@ -491,7 +697,7 @@ impl BiliClient {
         account: &AccountRow,
         video_file: &Path,
     ) -> Result<PreuploadResponse, BiliClientError> {
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -560,7 +766,7 @@ impl BiliClient {
             }
 
             read_total += size;
-            log::debug!("size: {}, total: {}", size, read_total);
+            log::debug!("size: {size}, total: {read_total}");
             if size > 0 && (read_total as u64) < chunk_size {
                 continue;
             }
@@ -622,7 +828,7 @@ impl BiliClient {
                         }
                     }
                     Err(e) => {
-                        log::error!("Upload error: {}", e);
+                        log::error!("Upload error: {e}");
                         retry_count += 1;
                         if retry_count < max_retries {
                             tokio::time::sleep(Duration::from_secs(2u64.pow(retry_count as u32)))
@@ -634,10 +840,7 @@ impl BiliClient {
 
             if !success {
                 return Err(BiliClientError::UploadError {
-                    err: format!(
-                        "Failed to upload chunk {} after {} retries",
-                        chunk, max_retries
-                    ),
+                    err: format!("Failed to upload chunk {chunk} after {max_retries} retries"),
                 });
             }
 
@@ -702,9 +905,9 @@ impl BiliClient {
     ) -> Result<profile::Video, BiliClientError> {
         log::info!("Start Preparing Video: {}", video_file.to_str().unwrap());
         let preupload = self.preupload_video(account, video_file).await?;
-        log::info!("Preupload Response: {:?}", preupload);
+        log::info!("Preupload Response: {preupload:?}");
         let metaposted = self.post_video_meta(&preupload, video_file).await?;
-        log::info!("Post Video Meta Response: {:?}", metaposted);
+        log::info!("Post Video Meta Response: {metaposted:?}");
         let uploaded = self
             .upload_video(UploadParams {
                 reporter,
@@ -713,7 +916,7 @@ impl BiliClient {
                 video_file,
             })
             .await?;
-        log::info!("Uploaded: {}", uploaded);
+        log::info!("Uploaded: {uploaded}");
         self.end_upload(&preupload, &metaposted, uploaded).await?;
         let filename = Path::new(&metaposted.key)
             .file_stem()
@@ -721,9 +924,9 @@ impl BiliClient {
             .to_str()
             .unwrap();
         Ok(profile::Video {
-            title: "".to_string(),
+            title: filename.to_string(),
             filename: filename.to_string(),
-            desc: "".to_string(),
+            desc: String::new(),
             cid: preupload.biz_id,
         })
     }
@@ -734,7 +937,7 @@ impl BiliClient {
         profile_template: &Profile,
         video: &profile::Video,
     ) -> Result<VideoSubmitData, BiliClientError> {
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -752,7 +955,7 @@ impl BiliClient {
             .post(&url)
             .headers(headers)
             .header("Content-Type", "application/json; charset=UTF-8")
-            .body(serde_json::ser::to_string(&preprofile).unwrap_or("".to_string()))
+            .body(serde_json::ser::to_string(&preprofile).unwrap_or_default())
             .send()
             .await
         {
@@ -764,12 +967,12 @@ impl BiliClient {
                         _ => Err(BiliClientError::InvalidResponse),
                     }
                 } else {
-                    log::error!("Parse response failed: {}", json);
+                    log::error!("Parse response failed: {json}");
                     Err(BiliClientError::InvalidResponse)
                 }
             }
             Err(e) => {
-                log::error!("Send failed {}", e);
+                log::error!("Send failed {e}");
                 Err(BiliClientError::InvalidResponse)
             }
         }
@@ -784,7 +987,7 @@ impl BiliClient {
             "https://member.bilibili.com/x/vu/web/cover/up?ts={}",
             chrono::Local::now().timestamp(),
         );
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -808,12 +1011,12 @@ impl BiliClient {
                         _ => Err(BiliClientError::InvalidResponse),
                     }
                 } else {
-                    log::error!("Parse response failed: {}", json);
+                    log::error!("Parse response failed: {json}");
                     Err(BiliClientError::InvalidResponse)
                 }
             }
             Err(e) => {
-                log::error!("Send failed {}", e);
+                log::error!("Send failed {e}");
                 Err(BiliClientError::InvalidResponse)
             }
         }
@@ -822,11 +1025,11 @@ impl BiliClient {
     pub async fn send_danmaku(
         &self,
         account: &AccountRow,
-        room_id: u64,
+        room_id: i64,
         message: &str,
     ) -> Result<(), BiliClientError> {
         let url = "https://api.live.bilibili.com/msg/send".to_string();
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {
@@ -840,7 +1043,7 @@ impl BiliClient {
             ("fontsize", "25"),
             ("room_type", "0"),
             ("rnd", &format!("{}", chrono::Local::now().timestamp())),
-            ("roomid", &format!("{}", room_id)),
+            ("roomid", &format!("{room_id}")),
             ("csrf", &account.csrf),
             ("csrf_token", &account.csrf),
         ];
@@ -860,7 +1063,7 @@ impl BiliClient {
         account: &AccountRow,
     ) -> Result<Vec<response::Typelist>, BiliClientError> {
         let url = "https://member.bilibili.com/x/vupre/web/archive/pre?lang=cn";
-        let mut headers = self.headers.clone();
+        let mut headers = self.generate_user_agent_header();
         if let Ok(cookies) = account.cookies.parse() {
             headers.insert("cookie", cookies);
         } else {