feat: introduce static server for file access (close #220) (#223)

* bump version to 2.16.1

* fix: read segment with params

.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/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,46 @@
+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
+        exclude: '(\.json$|public/)'
+
+  - 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
 
@@ -48,15 +48,9 @@ COPY src-tauri/crates ./src-tauri/crates
 WORKDIR /app/src-tauri
 RUN rustup component add rustfmt
 RUN cargo build --no-default-features --features headless --release
-# Download and install FFmpeg static build
-RUN wget https://johnvansickle.com/ffmpeg/releases/ffmpeg-release-amd64-static.tar.xz \
-    && tar xf ffmpeg-release-amd64-static.tar.xz \
-    && mv ffmpeg-*-static/ffmpeg ./  \
-    && mv ffmpeg-*-static/ffprobe ./ \
-    && rm -rf ffmpeg-*-static ffmpeg-release-amd64-static.tar.xz
 
 # Final stage
-FROM debian:bookworm-slim AS final
+FROM debian:trixie-slim AS final
 
 WORKDIR /app
 
@@ -65,9 +59,16 @@ RUN apt-get update && apt-get install -y \
     libssl3 \
     ca-certificates \
     fonts-wqy-microhei \
+    netbase \
+    nscd \
+    ffmpeg \
     && update-ca-certificates \
     && rm -rf /var/lib/apt/lists/*
 
+
+RUN touch /etc/netgroup
+RUN mkdir -p /var/run/nscd && chmod 755 /var/run/nscd
+
 # Add /app to PATH
 ENV PATH="/app:${PATH}"
 
@@ -76,11 +77,9 @@ COPY --from=frontend-builder /app/dist ./dist
 
 # Copy built Rust binary
 COPY --from=rust-builder /app/src-tauri/target/release/bili-shadowreplay .
-COPY --from=rust-builder /app/src-tauri/ffmpeg ./ffmpeg
-COPY --from=rust-builder /app/src-tauri/ffprobe ./ffprobe
 
 # Expose port
 EXPOSE 3000
 
 # Run the application
-CMD ["./bili-shadowreplay"]
+CMD ["sh", "-c", "nscd && ./bili-shadowreplay"]

README.md

@@ -4,24 +4,29 @@
 
 ![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)
 
 ## 赞助
 
-![donate](docs/public/images/donate.png)
+<!-- markdownlint-disable MD033 -->
+<img src="docs/public/images/donate.png" alt="donate" width="300">

_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

@@ -1,27 +1,12 @@
-# 配置使用
-
-## 账号配置
+# 账号配置
 
 要添加直播间，至少需要配置一个同平台的账号。在账号页面，你可以通过添加账号按钮添加一个账号。
 
 - B 站账号：目前支持扫码登录和 Cookie 手动配置两种方式，推荐使用扫码登录
 - 抖音账号：目前仅支持 Cookie 手动配置登陆
 
-### 抖音账号配置
+## 抖音账号配置
 
 首先确保已经登录抖音，然后打开[个人主页](https://www.douyin.com/user/self)，右键单击网页，在菜单中选择 `检查（Inspect）`，打开开发者工具，切换到 `网络（Network）` 选项卡，然后刷新网页，此时能在列表中找到 `self` 请求（一般是列表中第一个），单击该请求，查看`请求标头`，在 `请求标头` 中找到 `Cookie`，复制该字段的值，粘贴到配置页面的 `Cookie` 输入框中，要注意复制完全。
 
 ![DouyinCookie](/images/douyin_cookie.png)
-
-## FFmpeg 配置
-
-如果想要使用切片生成和压制功能，请确保 FFmpeg 已正确配置；除了 Windows 平台打包自带 FFfmpeg 以外，其他平台需要手动安装 FFfmpeg，请参考 [FFfmpeg 配置](/getting-started/ffmpeg)。
-
-## Whisper 模型配置
-
-要使用 AI 字幕识别功能，需要在设置页面配置 Whisper 模型路径，模型文件可以从网络上下载，例如：
-
-- [Whisper.cpp（国内镜像，内容较旧）](https://www.modelscope.cn/models/cjc1887415157/whisper.cpp/files)
-- [Whisper.cpp](https://huggingface.co/ggerganov/whisper.cpp/tree/main)
-
-可以跟据自己的需求选择不同的模型，要注意带有 `en` 的模型是英文模型，其他模型为多语言模型。

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/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,24 @@
+# 桌面端安装
+
+桌面端目前提供了 Windows、Linux 和 MacOS 三个平台的安装包。
+
+由于程序会对账号等敏感信息进行管理，请从信任的来源进行下载；所有版本均可在 [GitHub Releases](https://github.com/Xinrea/bili-shadowreplay/releases) 页面下载安装。
+
+对于 MacOS 用户，请先手动安装 FFmpeg，详情见 [FFmpeg 配置](../config/ffmpeg.md)。
+
+## 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: 📹
@@ -38,9 +38,9 @@ features:
   - icon: 🔍
     title: 云端部署
     details: 支持 Docker 部署，提供 Web 控制界面
-  - icon: 📦
-    title: 多平台支持
-    details: 桌面端支持 Windows/Linux/macOS
+  - icon: 🤖
+    title: AI Agent 支持
+    details: 支持 AI 助手管理录播，分析直播内容，生成切片
 ---
 
 ## 总览
@@ -63,7 +63,7 @@ features:
 
 ## 封面编辑
 
-![cover](/images/coveredit.png)
+![cover](/images/cover_edit.png)
 
 ## 设置
 

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]
+
+```

index_live.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="stylesheet" href="shaka-player/controls.min.css" />
+    <link rel="stylesheet" href="shaka-player/controls.css" />
     <link rel="stylesheet" href="shaka-player/youtube-theme.css" />
     <script src="shaka-player/shaka-player.ui.js"></script>
   </head>

package.json

@@ -1,7 +1,7 @@
 {
   "name": "bili-shadowreplay",
   "private": true,
-  "version": "2.7.5",
+  "version": "2.16.3",
   "type": "module",
   "scripts": {
     "dev": "vite",
@@ -11,10 +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": {
-    "@tauri-apps/api": "^2.4.1",
+    "@langchain/core": "^0.3.64",
+    "@langchain/deepseek": "^0.1.0",
+    "@langchain/langgraph": "^0.3.10",
+    "@langchain/ollama": "^0.2.3",
+    "@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",
@@ -23,7 +29,10 @@
     "@tauri-apps/plugin-shell": "~2",
     "@tauri-apps/plugin-sql": "~2",
     "lucide-svelte": "^0.479.0",
-    "qrcode": "^1.5.4"
+    "marked": "^16.1.1",
+    "qrcode": "^1.5.4",
+    "socket.io-client": "^4.8.1",
+    "wavesurfer.js": "^7.11.0"
   },
   "devDependencies": {
     "@sveltejs/vite-plugin-svelte": "^2.0.0",
@@ -35,6 +44,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",
@@ -42,8 +52,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"
   }
 }

public/shaka-player/controls.css

@@ -0,0 +1,983 @@
+/*! @license
+ * Shaka Player
+ * Copyright 2016 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+.shaka-hidden {
+  display: none !important;
+}
+.shaka-video-container {
+  position: relative;
+  top: 0;
+  left: 0;
+  display: flex;
+  font-family: Roboto, sans-serif, TengwarTelcontar;
+  font-weight: 400;
+  -webkit-font-smoothing: antialiased;
+  user-select: none;
+  -webkit-user-select: none;
+}
+.shaka-video-container .material-svg-icon {
+  font-size: 24px;
+}
+.shaka-video-container:fullscreen {
+  width: 100%;
+  height: 100%;
+  background-color: #000;
+}
+.shaka-video-container:fullscreen .shaka-text-container {
+  font-size: 4.4vmin;
+}
+.shaka-video-container:-webkit-full-screen {
+  width: 100%;
+  height: 100%;
+  background-color: #000;
+}
+.shaka-video-container:-webkit-full-screen .shaka-text-container {
+  font-size: 4.4vmin;
+}
+.shaka-video-container:-moz-full-screen {
+  width: 100%;
+  height: 100%;
+  background-color: #000;
+}
+.shaka-video-container:-moz-full-screen .shaka-text-container {
+  font-size: 4.4vmin;
+}
+.shaka-video-container:-ms-fullscreen {
+  width: 100%;
+  height: 100%;
+  background-color: #000;
+}
+.shaka-video-container:-ms-fullscreen .shaka-text-container {
+  font-size: 4.4vmin;
+}
+.shaka-controls-container {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: column;
+  justify-content: flex-end;
+  align-items: center;
+  z-index: 1;
+}
+.shaka-video-container:not([shaka-controls="true"]) .shaka-controls-container {
+  display: none;
+}
+.shaka-controls-container * {
+  flex-shrink: 0;
+}
+.shaka-controls-container[casting="true"] .shaka-fullscreen-button {
+  display: none;
+}
+.shaka-canvas-container {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+}
+.shaka-vr-canvas-container {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  pointer-events: none;
+}
+.shaka-bottom-controls {
+  width: 98%;
+  padding: 0;
+  z-index: 1;
+}
+.shaka-controls-button-panel {
+  padding: 0;
+  margin: 0;
+  display: flex;
+  flex-direction: row;
+  justify-content: flex-end;
+  align-items: center;
+  overflow: hidden;
+  min-width: 48px;
+  font-size: 12px;
+  font-weight: 400;
+  font-style: normal;
+  user-select: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+}
+.shaka-controls-container[casting="true"] .shaka-controls-button-panel,
+.shaka-controls-container[shown="true"] .shaka-controls-button-panel {
+  opacity: 1;
+}
+.shaka-controls-button-panel > * {
+  color: #fff;
+  height: 48px;
+  width: 48px;
+  line-height: 0.5;
+  padding: 0 2px;
+  background: 0 0;
+  border: 0;
+  cursor: pointer;
+  opacity: 0.9;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.1s;
+  text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
+}
+.shaka-controls-button-panel > .shaka-fast-forward-button .material-svg-icon,
+.shaka-controls-button-panel > .shaka-rewind-button .material-svg-icon,
+.shaka-controls-button-panel > .shaka-skip-next-button .material-svg-icon,
+.shaka-controls-button-panel > .shaka-skip-previous-button .material-svg-icon,
+.shaka-controls-button-panel > .shaka-small-play-button .material-svg-icon {
+  font-size: 32px;
+}
+.shaka-controls-button-panel > .shaka-fullscreen-button .material-svg-icon {
+  font-size: 24px;
+}
+.shaka-controls-button-panel > .shaka-overflow-menu-button {
+  position: relative;
+}
+.shaka-controls-button-panel > .shaka-overflow-menu-button .material-svg-icon {
+  font-size: 24px;
+}
+.shaka-controls-button-panel > :hover {
+  opacity: 1;
+}
+.shaka-controls-button-panel .shaka-overflow-menu-only {
+  display: none;
+}
+.shaka-play-button-container {
+  margin: 0;
+  width: 100%;
+  height: 100%;
+  flex-shrink: 1;
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 1;
+}
+.shaka-statistics-container {
+  overflow-x: hidden;
+  overflow-y: auto;
+  scrollbar-color: white rgba(0, 0, 0, 0.5);
+  scrollbar-width: thin;
+  min-width: 300px;
+  color: #fff;
+  background-color: rgba(35, 35, 35, 0.9);
+  font-size: 14px;
+  padding: 5px 10px;
+  border-radius: 2px;
+  position: absolute;
+  z-index: 2;
+  left: 15px;
+  top: 15px;
+  max-height: calc(100% - 115px);
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+}
+.shaka-controls-container[casting="true"] .shaka-statistics-container,
+.shaka-controls-container[shown="true"] .shaka-statistics-container {
+  opacity: 1;
+}
+.shaka-statistics-container div {
+  display: flex;
+  justify-content: space-between;
+}
+.shaka-statistics-container span {
+  color: #969696;
+}
+.shaka-ad-statistics-container {
+  overflow-x: hidden;
+  overflow-y: auto;
+  scrollbar-color: white rgba(0, 0, 0, 0.5);
+  scrollbar-width: thin;
+  min-width: 150px;
+  color: #fff;
+  background-color: rgba(35, 35, 35, 0.9);
+  font-size: 14px;
+  padding: 5px 10px;
+  border-radius: 2px;
+  position: absolute;
+  z-index: 2;
+  right: 15px;
+  top: 15px;
+  max-height: calc(100% - 115px);
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+}
+.shaka-controls-container[casting="true"] .shaka-ad-statistics-container,
+.shaka-controls-container[shown="true"] .shaka-ad-statistics-container {
+  opacity: 1;
+}
+.shaka-ad-statistics-container div {
+  display: flex;
+  justify-content: space-between;
+}
+.shaka-ad-statistics-container span {
+  color: #969696;
+}
+.shaka-context-menu {
+  overflow-x: hidden;
+  overflow-y: auto;
+  white-space: nowrap;
+  background: rgba(28, 28, 28, 0.9);
+  border-radius: 2px;
+  min-width: 190px;
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  position: absolute;
+  z-index: 3;
+}
+.shaka-controls-container[casting="true"] .shaka-context-menu,
+.shaka-controls-container[shown="true"] .shaka-context-menu {
+  opacity: 1;
+}
+.shaka-context-menu button {
+  font-size: 14px;
+  background: 0 0;
+  color: #fff;
+  border: none;
+  min-height: 30px;
+  padding: 10px;
+  display: flex;
+  align-items: center;
+  cursor: pointer;
+}
+.shaka-context-menu button:hover {
+  background: rgba(255, 255, 255, 0.1);
+}
+.shaka-context-menu button label {
+  cursor: pointer;
+  margin-left: 5px;
+}
+.shaka-keyboard-navigation .shaka-context-menu button:focus {
+  background: rgba(255, 255, 255, 0.1);
+}
+.shaka-context-menu button .shaka-current-selection-span {
+  display: none;
+}
+.shaka-scrim-container {
+  margin: 0;
+  width: 100%;
+  position: absolute;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  flex-shrink: 1;
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+  height: 61px;
+  background: linear-gradient(rgba(0, 0, 0, 0) 0, rgba(0, 0, 0, 0.5) 100%);
+}
+.shaka-controls-container[casting="true"] .shaka-scrim-container,
+.shaka-controls-container[shown="true"] .shaka-scrim-container {
+  opacity: 1;
+}
+.shaka-text-container {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  pointer-events: none;
+  bottom: 0;
+  width: 100%;
+  min-width: 48px;
+  transition: bottom cubic-bezier(0.4, 0, 0.6, 1) 0.1s;
+  transition-delay: 0.5s;
+  font-size: 20px;
+  line-height: 1.4;
+  color: #fff;
+}
+.shaka-text-container span.shaka-text-wrapper {
+  display: inline;
+  background: 0 0;
+}
+.shaka-controls-container[shown="true"] ~ .shaka-text-container {
+  transition-delay: 0s;
+}
+.shaka-spinner-container {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  width: 100%;
+  height: 100%;
+  flex-shrink: 1;
+  display: flex;
+  justify-content: center;
+  align-items: center;
+}
+.shaka-video-container:not([shaka-controls="true"]) .shaka-spinner-container {
+  display: none;
+}
+.shaka-hidden-fast-forward-container,
+.shaka-hidden-rewind-container {
+  height: 100%;
+  width: 40%;
+  flex-shrink: 1;
+  z-index: 1;
+}
+.shaka-hidden-fast-forward-container {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  left: 60%;
+}
+.shaka-hidden-rewind-container {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+}
+.shaka-video-container.no-cursor {
+  cursor: none !important;
+}
+.shaka-video-container.no-cursor * {
+  cursor: none !important;
+}
+.shaka-play-button {
+  box-sizing: border-box;
+  padding: calc(15% / 2);
+  width: 0;
+  height: 0;
+  margin: 0;
+  border-radius: 50%;
+  box-shadow: rgba(0, 0, 0, 0.1) 0 0 20px 0;
+  border: none;
+  background-size: 50%;
+  background-repeat: no-repeat;
+  background-position: center center;
+  background-color: rgba(255, 255, 255, 0.9);
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+}
+.shaka-controls-container[casting="true"] .shaka-play-button,
+.shaka-controls-container[shown="true"] .shaka-play-button {
+  opacity: 1;
+}
+.shaka-play-button[icon="play"] {
+  background-image: url("data:image/svg+xml,%3Csvg%20fill%3D%22%23000000%22%20height%3D%2224%22%20viewBox%3D%220%200%2024%2024%22%20width%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpath%20d%3D%22M8%205v14l11-7z%22%2F%3E%0A%20%20%20%20%3Cpath%20d%3D%22M0%200h24v24H0z%22%20fill%3D%22none%22%2F%3E%0A%3C%2Fsvg%3E");
+}
+.shaka-play-button[icon="pause"] {
+  background-image: url("data:image/svg+xml,%3Csvg%20fill%3D%22%23000000%22%20height%3D%2224%22%20viewBox%3D%220%200%2024%2024%22%20width%3D%2224%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%20%20%3Cpath%20d%3D%22M6%2019h4V5H6v14zm8-14v14h4V5h-4z%22%2F%3E%0A%20%20%20%20%3Cpath%20d%3D%22M0%200h24v24H0z%22%20fill%3D%22none%22%2F%3E%0A%3C%2Fsvg%3E");
+}
+.shaka-play-button[icon="replay"] {
+  background-image: url("data:image/svg+xml,%3Csvg%20fill%3D%22%231f1f1f%22%20height%3D%2224px%22%20viewBox%3D%220%20-960%20960%20960%22%20width%3D%2224px%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%3E%0A%20%20%3Cpath%20d%3D%22M480-80q-75%200-140.5-28.5t-114-77q-48.5-48.5-77-114T120-440h80q0%20117%2081.5%20198.5T480-160q117%200%20198.5-81.5T760-440q0-117-81.5-198.5T480-720h-6l62%2062-56%2058-160-160%20160-160%2056%2058-62%2062h6q75%200%20140.5%2028.5t114%2077q48.5%2048.5%2077%20114T840-440q0%2075-28.5%20140.5t-77%20114q-48.5%2048.5-114%2077T480-80Z%22%2F%3E%0A%3C%2Fsvg%3E");
+}
+@media (prefers-reduced-transparency: no-preference) {
+  .shaka-controls-container[shown="true"] .shaka-play-button {
+    opacity: 0.75;
+  }
+}
+.shaka-current-time {
+  font-size: 14px;
+  color: #fff;
+  cursor: pointer;
+  width: auto;
+  padding: 0 5px;
+}
+.shaka-current-time[disabled] {
+  background-color: transparent;
+  color: #fff;
+  cursor: default;
+}
+.shaka-controls-container button:focus,
+.shaka-controls-container input:focus {
+  outline: 1px solid Highlight;
+}
+.shaka-controls-container button:-moz-focus-inner,
+.shaka-controls-container input:-moz-focus-outer {
+  outline: 0;
+  border: 0;
+}
+.shaka-controls-container:not(.shaka-keyboard-navigation) button:focus,
+.shaka-controls-container:not(.shaka-keyboard-navigation) input:focus {
+  outline: 0;
+}
+.shaka-fast-forward-container,
+.shaka-rewind-container {
+  height: 100%;
+  width: 100%;
+  flex-shrink: 1;
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+  display: flex;
+  flex-direction: row;
+  justify-content: center;
+  align-items: center;
+  margin: 0;
+  border: none;
+  color: #fff;
+  background-color: rgba(0, 0, 0, 0.5);
+  cursor: default;
+  font-size: 20px;
+  opacity: 0;
+  user-select: none;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+}
+.shaka-fast-forward-container {
+  border-radius: 40% 0 0 40%;
+}
+.shaka-rewind-container {
+  border-radius: 0 40% 40% 0;
+}
+.shaka-forward-rewind-container-icon {
+  font-size: 32px;
+}
+.shaka-range-container {
+  position: relative;
+  top: 0;
+  left: 0;
+  margin: calc((12px - 4px) / 2) 6px;
+  height: 4px;
+  border-radius: 4px;
+  background: #fff;
+  box-sizing: content-box;
+}
+.shaka-volume-bar-container {
+  width: 100px;
+  padding: 0;
+  transition-property: opacity, width;
+  transition-duration: 250ms;
+  transition-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
+}
+.shaka-volume-bar-container:hover {
+  width: 100px !important;
+  opacity: 1 !important;
+}
+@media (max-width: 474px) {
+  .shaka-volume-bar-container {
+    width: 50px;
+  }
+  .shaka-volume-bar-container:hover {
+    width: 50px !important;
+  }
+  .shaka-mute-button:hover + .shaka-volume-bar-container-allow-hiding {
+    width: 50px;
+    opacity: 1;
+  }
+}
+.shaka-mute-button
+  + .shaka-volume-bar-container-allow-hiding:not(:focus-within) {
+  width: 0;
+  opacity: 0;
+}
+@media (min-width: 475px) {
+  .shaka-mute-button:hover + .shaka-volume-bar-container-allow-hiding {
+    width: 100px;
+    opacity: 1;
+  }
+}
+.shaka-range-element {
+  -webkit-appearance: none;
+  background: 0 0;
+  cursor: pointer;
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  height: 12px;
+  top: calc((4px - 12px) / 2);
+  z-index: 1;
+}
+.shaka-range-element::-webkit-slider-runnable-track {
+  width: 100%;
+  cursor: pointer;
+  height: 12px;
+  background: 0 0;
+  color: transparent;
+  border: none;
+}
+.shaka-range-element::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  border: none;
+  border-radius: 12px;
+  height: 12px;
+  width: 12px;
+  background: #fff;
+}
+.shaka-range-element::-moz-range-track {
+  width: 100%;
+  cursor: pointer;
+  height: 12px;
+  background: 0 0;
+  color: transparent;
+  border: none;
+}
+.shaka-range-element::-moz-range-thumb {
+  -webkit-appearance: none;
+  border: none;
+  border-radius: 12px;
+  height: 12px;
+  width: 12px;
+  background: #fff;
+}
+.shaka-seek-bar-container {
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+  top: 5px;
+  height: 5px;
+  margin-bottom: 0;
+  background-clip: padding-box !important;
+  border-top: 4px solid transparent;
+  border-bottom: 4px solid transparent;
+}
+.shaka-controls-container[casting="true"] .shaka-seek-bar-container,
+.shaka-controls-container[shown="true"] .shaka-seek-bar-container {
+  opacity: 1;
+}
+.shaka-seek-bar-container .shaka-seek-bar {
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 250ms;
+  opacity: 0;
+}
+.shaka-seek-bar-container:hover .shaka-seek-bar {
+  opacity: 1;
+}
+.shaka-ad-markers {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+}
+.shaka-spacer {
+  cursor: default;
+  flex-shrink: 1;
+  flex-grow: 1;
+  margin: 0;
+}
+.shaka-overflow-menu,
+.shaka-settings-menu {
+  overflow-x: hidden;
+  overflow-y: auto;
+  scrollbar-color: white rgba(0, 0, 0, 0.5);
+  scrollbar-width: thin;
+  white-space: nowrap;
+  background: rgba(28, 28, 28, 0.9);
+  border-radius: 15px;
+  max-height: 250px;
+  min-width: 190px;
+  padding: 5px 0;
+  opacity: 0;
+  transition: opacity cubic-bezier(0.4, 0, 0.6, 1) 0.6s;
+  display: flex;
+  flex-direction: column;
+  align-items: stretch;
+  position: absolute;
+  z-index: 2;
+  right: 15px;
+  bottom: 62px;
+}
+.shaka-controls-container[casting="true"] .shaka-overflow-menu,
+.shaka-controls-container[casting="true"] .shaka-settings-menu,
+.shaka-controls-container[shown="true"] .shaka-overflow-menu,
+.shaka-controls-container[shown="true"] .shaka-settings-menu {
+  opacity: 1;
+}
+.shaka-overflow-menu button,
+.shaka-settings-menu button {
+  font-size: 14px;
+  background: 0 0;
+  color: #fff;
+  border: none;
+  min-height: 30px;
+  padding: 10px;
+  display: flex;
+  align-items: center;
+  cursor: pointer;
+}
+.shaka-overflow-menu button:hover,
+.shaka-settings-menu button:hover {
+  background: rgba(255, 255, 255, 0.1);
+}
+.shaka-overflow-menu button label,
+.shaka-settings-menu button label {
+  cursor: pointer;
+}
+.shaka-keyboard-navigation .shaka-overflow-menu button:focus,
+.shaka-keyboard-navigation .shaka-settings-menu button:focus {
+  background: rgba(255, 255, 255, 0.1);
+}
+.shaka-overflow-menu .material-svg-icon,
+.shaka-settings-menu .material-svg-icon {
+  padding-left: 0;
+  padding-right: 10px;
+}
+.shaka-overflow-menu .material-svg-icon.shaka-chosen-item,
+.shaka-settings-menu .material-svg-icon.shaka-chosen-item {
+  order: -1;
+  line-height: 17px;
+  font-size: 18px;
+}
+.shaka-overflow-menu.shaka-low-position,
+.shaka-settings-menu.shaka-low-position {
+  bottom: 48px;
+}
+.shaka-overflow-menu span {
+  text-align: left;
+}
+.shaka-overflow-button-label {
+  position: relative;
+  display: flex;
+  flex-direction: column;
+}
+.shaka-overflow-button-label-inline {
+  box-sizing: border-box;
+  flex-direction: row;
+  justify-content: space-between;
+  width: calc(100% - 34px);
+  padding-right: 28px;
+  background-image: url("data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMjRweCIgZmlsbD0iI2VlZWVlZSI+PHBhdGggZD0iTTAgMGgyNHYyNEgwVjB6IiBmaWxsPSJub25lIi8+PHBhdGggZD0iTTguNTkgMTYuNTlMMTMuMTcgMTIgOC41OSA3LjQxIDEwIDZsNiA2LTYgNi0xLjQxLTEuNDF6Ii8+PC9zdmc+");
+  background-repeat: no-repeat;
+  background-position: right 5px center;
+  background-size: 24px 24px;
+}
+.shaka-simple-overflow-button-label-inline {
+  box-sizing: border-box;
+  flex-direction: row;
+  justify-content: space-between;
+  width: calc(100% - 50px);
+}
+.shaka-current-selection-span {
+  font-size: 12px;
+  padding-left: 10px;
+}
+.shaka-current-auto-quality {
+  margin-left: 5px;
+  font-size: 11px;
+  color: #ccc;
+}
+.shaka-current-quality-mark,
+.shaka-quality-mark {
+  color: red;
+  margin-left: 2px !important;
+  font-size: 10px;
+  height: 17px;
+}
+.shaka-quality-mark {
+  line-height: 6px;
+}
+.shaka-overflow-playback-rate-mark,
+.shaka-overflow-quality-mark {
+  background: red;
+  color: #fff;
+  border-radius: 2px;
+  font-family: Roboto, sans-serif, TengwarTelcontar;
+  font-size: 10px;
+  font-weight: 700;
+  line-height: 10px;
+  text-shadow: none;
+  padding: 1px;
+  position: absolute;
+  right: 4px;
+  top: 10px;
+}
+.shaka-settings-menu span {
+  margin-left: 28px;
+}
+.shaka-settings-menu span.shaka-chosen-item {
+  margin-left: 0;
+}
+.shaka-settings-menu .shaka-chapter {
+  margin-left: 10px;
+}
+.shaka-back-to-overflow-button {
+  border-bottom: 1px solid rgba(255, 255, 255, 0.2) !important;
+}
+.shaka-back-to-overflow-button span {
+  margin-left: 0;
+}
+.shaka-back-to-overflow-button .material-svg-icon {
+  padding-right: 10px;
+  font-size: 18px !important;
+}
+.shaka-back-to-overflow-button:hover {
+  background: 0 0 !important;
+}
+.shaka-controls-container[ad-active="true"] {
+  pointer-events: none;
+}
+.shaka-controls-container[ad-active="true"] .shaka-bottom-controls {
+  pointer-events: auto;
+}
+.shaka-client-side-ad-container,
+.shaka-server-side-ad-container {
+  position: absolute;
+  left: 0;
+  right: 0;
+  top: 0;
+  bottom: 0;
+}
+.shaka-video-container[shaka-controls="true"]
+  .shaka-client-side-ad-container
+  iframe,
+.shaka-video-container[shaka-controls="true"]
+  .shaka-server-side-ad-container
+  iframe {
+  height: 90%;
+}
+.shaka-ad-controls {
+  display: flex;
+  flex-direction: row;
+  z-index: 1;
+  padding-bottom: 1%;
+}
+.shaka-video-container:not([shaka-controls="true"]) .shaka-ad-controls {
+  display: none;
+}
+.shaka-ad-controls button,
+.shaka-ad-controls div {
+  color: #fff;
+  font-size: initial;
+}
+.shaka-ad-info {
+  font-size: 14px;
+  color: #fff;
+  width: auto;
+  padding: 0 5px;
+}
+.shaka-ad-info[disabled] {
+  background-color: transparent;
+  color: #fff;
+  cursor: default;
+  padding: 0;
+}
+.shaka-skip-ad-container {
+  position: relative;
+  right: calc((100% - 98%) / 2 * -1);
+  display: flex;
+  flex-direction: row;
+  margin: 0;
+  margin-left: auto;
+}
+.shaka-skip-ad-button {
+  padding: 5px 15px;
+  background: rgba(0, 0, 0, 0.7);
+  border: none;
+  cursor: pointer;
+}
+.shaka-skip-ad-button:disabled {
+  background: rgba(0, 0, 0, 0.3);
+}
+.shaka-skip-ad-counter {
+  padding: 5px;
+  background: rgba(0, 0, 0, 0.7);
+  margin: 0;
+} /*!
+ * @license
+ * The tooltip is based on https://github.com/felipefialho/css-components/
+ * Local modifications have been performed.
+ *
+ * Copyright (c) 2017 Felipe Fialho
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+.shaka-tooltips-on {
+  overflow: visible;
+}
+.shaka-tooltips-on > .shaka-tooltip,
+.shaka-tooltips-on > .shaka-tooltip-status {
+  position: relative;
+}
+.shaka-tooltips-on > .shaka-tooltip-status:active:after,
+.shaka-tooltips-on > .shaka-tooltip-status:focus-visible:after,
+.shaka-tooltips-on > .shaka-tooltip-status:hover:after,
+.shaka-tooltips-on > .shaka-tooltip:active:after,
+.shaka-tooltips-on > .shaka-tooltip:focus-visible:after,
+.shaka-tooltips-on > .shaka-tooltip:hover:after {
+  content: attr(aria-label);
+  font-family: Roboto, sans-serif, TengwarTelcontar;
+  line-height: 20px;
+  white-space: nowrap;
+  font-size: 14px;
+  background: rgba(0, 0, 0, 0.5);
+  color: #fff;
+  border-radius: 2px;
+  padding: 2px 10px;
+  position: absolute;
+  bottom: 62px;
+  left: calc(48px / 2);
+  -webkit-transform: translateX(-50%);
+  -moz-transform: translateX(-50%);
+  -ms-transform: translateX(-50%);
+  -o-transform: translateX(-50%);
+  transform: translateX(-50%);
+}
+@media (prefers-reduced-transparency) {
+  .shaka-tooltips-on > .shaka-tooltip-status:active:after,
+  .shaka-tooltips-on > .shaka-tooltip-status:focus-visible:after,
+  .shaka-tooltips-on > .shaka-tooltip-status:hover:after,
+  .shaka-tooltips-on > .shaka-tooltip:active:after,
+  .shaka-tooltips-on > .shaka-tooltip:focus-visible:after,
+  .shaka-tooltips-on > .shaka-tooltip:hover:after {
+    background-color: rgba(0, 0, 0, 0.9);
+  }
+}
+.shaka-tooltips-on.shaka-tooltips-low-position > .shaka-tooltip:active:after,
+.shaka-tooltips-on.shaka-tooltips-low-position
+  > .shaka-tooltip:focus-visible:after,
+.shaka-tooltips-on.shaka-tooltips-low-position > .shaka-tooltip:hover:after {
+  bottom: 48px;
+}
+.shaka-tooltips-on > .shaka-tooltip-status:active:after,
+.shaka-tooltips-on > .shaka-tooltip-status:focus-visible:after,
+.shaka-tooltips-on > .shaka-tooltip-status:hover:after {
+  content: attr(aria-label) " (" attr(shaka-status) ")";
+}
+.shaka-tooltips-on button:first-child:active:after,
+.shaka-tooltips-on button:first-child:focus-visible:after,
+.shaka-tooltips-on button:first-child:hover:after {
+  left: 0;
+  -webkit-transform: translateX(0);
+  -moz-transform: translateX(0);
+  -ms-transform: translateX(0);
+  -o-transform: translateX(0);
+  transform: translateX(0);
+}
+.shaka-tooltips-on button:last-child:active:after,
+.shaka-tooltips-on button:last-child:focus-visible:after,
+.shaka-tooltips-on button:last-child:hover:after {
+  left: 48px;
+  -webkit-transform: translateX(-100%);
+  -moz-transform: translateX(-100%);
+  -ms-transform: translateX(-100%);
+  -o-transform: translateX(-100%);
+  transform: translateX(-100%);
+}
+#shaka-player-ui-thumbnail-container {
+  background-color: #000;
+  border: 1px solid #000;
+  box-shadow: 0 8px 8px 0 rgba(0, 0, 0, 0.5);
+  min-width: 150px;
+  overflow: hidden;
+  position: absolute;
+  visibility: hidden;
+  width: 15%;
+  z-index: 1;
+  pointer-events: none;
+}
+#shaka-player-ui-thumbnail-container #shaka-player-ui-thumbnail-image {
+  position: absolute;
+}
+#shaka-player-ui-thumbnail-container #shaka-player-ui-thumbnail-time-container {
+  bottom: 0;
+  left: 0;
+  position: absolute;
+  right: 0;
+  display: flex;
+  justify-content: center;
+}
+#shaka-player-ui-thumbnail-container
+  #shaka-player-ui-thumbnail-time-container
+  #shaka-player-ui-thumbnail-time {
+  background-color: rgba(0, 0, 0, 0.5);
+  border-radius: 14px;
+  color: #fff;
+  font-size: 14px;
+  padding: 0 5px;
+}
+@media (prefers-reduced-transparency) {
+  #shaka-player-ui-thumbnail-container
+    #shaka-player-ui-thumbnail-time-container
+    #shaka-player-ui-thumbnail-time {
+    background-color: rgba(0, 0, 0, 0.9);
+  }
+}
+#shaka-player-ui-thumbnail-container.portrait-thumbnail {
+  min-width: 75px;
+  width: 7.5%;
+}
+#shaka-player-ui-time-container {
+  background-color: rgba(0, 0, 0, 0.5);
+  border-radius: 5px;
+  color: #fff;
+  display: flex;
+  font-size: 14px;
+  justify-content: center;
+  overflow: hidden;
+  padding: 0 3px;
+  position: absolute;
+  visibility: hidden;
+  z-index: 1;
+}
+@media (prefers-reduced-transparency) {
+  #shaka-player-ui-time-container {
+    background-color: rgba(0, 0, 0, 0.9);
+  }
+}
+.material-svg-icon {
+  display: inline-block;
+  fill: currentcolor;
+  width: 1em;
+  height: 1em;
+}
+@font-face {
+  font-family: Roboto;
+  font-style: normal;
+  font-weight: 400;
+  font-stretch: normal;
+  src: url(./fonts/KFOMCnqEu92Fr1ME7kSn66aGLdTylUAMQXC89YmC2DPNWubEbVmUiA8.ttf)
+    format("truetype");
+} /*# sourceMappingURL=controls.css.map */

public/shaka-player/youtube-theme.css

@@ -1,19 +1,19 @@
 @font-face {
-  font-family: 'Roboto';
+  font-family: "Roboto";
   font-style: normal;
   font-weight: 400;
   font-display: swap;
-  src: url(https://fonts.gstatic.com/s/roboto/v27/KFOmCnqEu92Fr1Me5Q.ttf) format('truetype');
+  src: url(./fonts/KFOmCnqEu92Fr1Me5Q.ttf) format("truetype");
 }
 @font-face {
-  font-family: 'Roboto';
+  font-family: "Roboto";
   font-style: normal;
   font-weight: 500;
   font-display: swap;
-  src: url(https://fonts.gstatic.com/s/roboto/v27/KFOlCnqEu92Fr1MmEU9vAw.ttf) format('truetype');
+  src: url(./fonts/KFOlCnqEu92Fr1MmEU9vAw.ttf) format("truetype");
 }
 .youtube-theme {
-  font-family: 'Roboto', sans-serif;
+  font-family: "Roboto", sans-serif;
 }
 .youtube-theme .shaka-bottom-controls {
   width: 100%;
@@ -27,18 +27,18 @@
   display: flex;
   -webkit-box-orient: vertical;
   -webkit-box-direction: normal;
-      -ms-flex-direction: column;
-          flex-direction: column;
+  -ms-flex-direction: column;
+  flex-direction: column;
 }
 .youtube-theme .shaka-ad-controls {
   -webkit-box-ordinal-group: 2;
-      -ms-flex-order: 1;
-          order: 1;
+  -ms-flex-order: 1;
+  order: 1;
 }
 .youtube-theme .shaka-controls-button-panel {
   -webkit-box-ordinal-group: 3;
-      -ms-flex-order: 2;
-          order: 2;
+  -ms-flex-order: 2;
+  order: 2;
   height: 40px;
   padding: 0 10px;
 }
@@ -48,36 +48,36 @@
 }
 .youtube-theme .shaka-small-play-button {
   -webkit-box-ordinal-group: -2;
-      -ms-flex-order: -3;
-          order: -3;
+  -ms-flex-order: -3;
+  order: -3;
 }
 .youtube-theme .shaka-mute-button {
   -webkit-box-ordinal-group: -1;
-      -ms-flex-order: -2;
-          order: -2;
+  -ms-flex-order: -2;
+  order: -2;
 }
 .youtube-theme .shaka-controls-button-panel > * {
   margin: 0;
   padding: 3px 8px;
-  color: #EEE;
+  color: #eee;
   height: 40px;
 }
 .youtube-theme .shaka-controls-button-panel > *:focus {
   outline: none;
   -webkit-box-shadow: inset 0 0 0 2px rgba(27, 127, 204, 0.8);
-          box-shadow: inset 0 0 0 2px rgba(27, 127, 204, 0.8);
-  color: #FFF;
+  box-shadow: inset 0 0 0 2px rgba(27, 127, 204, 0.8);
+  color: #fff;
 }
 .youtube-theme .shaka-controls-button-panel > *:hover {
-  color: #FFF;
+  color: #fff;
 }
 .youtube-theme .shaka-controls-button-panel .shaka-volume-bar-container {
   position: relative;
   z-index: 10;
   left: -1px;
   -webkit-box-ordinal-group: 0;
-      -ms-flex-order: -1;
-          order: -1;
+  -ms-flex-order: -1;
+  order: -1;
   opacity: 0;
   width: 0px;
   -webkit-transition: width 0.2s cubic-bezier(0.4, 0, 1, 1);
@@ -120,23 +120,25 @@
   opacity: 1;
   cursor: pointer;
 }
-.youtube-theme .shaka-seek-bar-container input[type=range]::-webkit-slider-thumb {
-  background: #FF0000;
+.youtube-theme
+  .shaka-seek-bar-container
+  input[type="range"]::-webkit-slider-thumb {
+  background: #ff0000;
   cursor: pointer;
 }
-.youtube-theme .shaka-seek-bar-container input[type=range]::-moz-range-thumb {
-  background: #FF0000;
+.youtube-theme .shaka-seek-bar-container input[type="range"]::-moz-range-thumb {
+  background: #ff0000;
   cursor: pointer;
 }
-.youtube-theme .shaka-seek-bar-container input[type=range]::-ms-thumb {
-  background: #FF0000;
+.youtube-theme .shaka-seek-bar-container input[type="range"]::-ms-thumb {
+  background: #ff0000;
   cursor: pointer;
 }
 .youtube-theme .shaka-video-container * {
-  font-family: 'Roboto', sans-serif;
+  font-family: "Roboto", sans-serif;
 }
 .youtube-theme .shaka-video-container .material-icons-round {
-  font-family: 'Material Icons Sharp';
+  font-family: "Material Icons Sharp";
 }
 .youtube-theme .shaka-overflow-menu,
 .youtube-theme .shaka-settings-menu {
@@ -170,14 +172,14 @@
 }
 .youtube-theme .shaka-settings-menu button[aria-selected="true"] span {
   -webkit-box-ordinal-group: 3;
-      -ms-flex-order: 2;
-          order: 2;
+  -ms-flex-order: 2;
+  order: 2;
   margin-left: 0;
 }
 .youtube-theme .shaka-settings-menu button[aria-selected="true"] i {
   -webkit-box-ordinal-group: 2;
-      -ms-flex-order: 1;
-          order: 1;
+  -ms-flex-order: 1;
+  order: 1;
   font-size: 18px;
   padding-left: 5px;
 }
@@ -192,25 +194,25 @@
   display: -ms-flexbox;
   display: flex;
   -webkit-box-pack: justify;
-      -ms-flex-pack: justify;
-          justify-content: space-between;
+  -ms-flex-pack: justify;
+  justify-content: space-between;
   -webkit-box-orient: horizontal;
   -webkit-box-direction: normal;
-      -ms-flex-direction: row;
-          flex-direction: row;
+  -ms-flex-direction: row;
+  flex-direction: row;
   -webkit-box-align: center;
-      -ms-flex-align: center;
-          align-items: center;
+  -ms-flex-align: center;
+  align-items: center;
   cursor: default;
   outline: none;
   height: 40px;
   -webkit-box-flex: 0;
-      -ms-flex: 0 0 100%;
-          flex: 0 0 100%;
+  -ms-flex: 0 0 100%;
+  flex: 0 0 100%;
 }
 .youtube-theme .shaka-overflow-menu button .shaka-overflow-button-label span {
   -ms-flex-negative: initial;
-      flex-shrink: initial;
+  flex-shrink: initial;
   padding-left: 15px;
   font-size: 13px;
   font-weight: 500;
@@ -218,11 +220,11 @@
   display: -ms-flexbox;
   display: flex;
   -webkit-box-align: center;
-      -ms-flex-align: center;
-          align-items: center;
+  -ms-flex-align: center;
+  align-items: center;
 }
 .youtube-theme .shaka-overflow-menu span + span {
-  color: #FFF;
+  color: #fff;
   font-weight: 400 !important;
   font-size: 12px !important;
   padding-right: 8px;
@@ -230,7 +232,7 @@
 }
 .youtube-theme .shaka-overflow-menu span + span:after {
   content: "navigate_next";
-  font-family: 'Material Icons Sharp';
+  font-family: "Material Icons Sharp";
   font-size: 20px;
 }
 .youtube-theme .shaka-overflow-menu .shaka-pip-button span + span {
@@ -270,10 +272,10 @@
 }
 .youtube-theme .shaka-overflow-menu button,
 .youtube-theme .shaka-settings-menu button {
-  color: #EEE;
+  color: #eee;
 }
 .youtube-theme .shaka-captions-off {
-  color: #BFBFBF;
+  color: #bfbfbf;
 }
 .youtube-theme .shaka-overflow-menu-button {
   font-size: 18px;

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

@@ -1,22 +1,30 @@
 [workspace]
-members = ["crates/danmu_stream"]
+members = ["crates/danmu_stream", "crates/recorder"]
 resolver = "2"
 
 [package]
 name = "bili-shadowreplay"
-version = "1.0.0"
+version = "2.16.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]
 danmu_stream = { path = "crates/danmu_stream" }
+recorder = { path = "crates/recorder" }
 serde_json = "1.0"
-reqwest = { version = "0.11", features = ["blocking", "json", "multipart"] }
+reqwest = { workspace = true}
 serde_derive = "1.0.158"
 serde = "1.0.158"
 sysinfo = "0.32.0"
@@ -25,7 +33,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"
@@ -43,14 +50,21 @@ mime_guess = "2.0"
 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"] }
+uuid = { workspace = true }
+axum = { version = "0.7", features = ["macros", "multipart"] }
 tower-http = { version = "0.5", features = ["cors", "fs"] }
 futures-core = "0.3"
 futures = "0.3"
 tokio-util = { version = "0.7", features = ["io"] }
+tokio-stream = "0.1"
 clap = { version = "4.5.37", features = ["derive"] }
 url = "2.5.4"
+srtparse = "0.2.0"
+thiserror = "2"
+deno_core = "0.355"
+sanitize-filename = "0.6.0"
+socketioxide = "0.17.2"
+scraper = "0.24.0"
 
 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem
@@ -70,6 +84,7 @@ gui = [
     "tauri-utils",
     "tauri-plugin-os",
     "tauri-plugin-notification",
+    "tauri-plugin-deep-link",
     "fix-path-env",
     "tauri-build",
 ]
@@ -82,6 +97,7 @@ optional = true
 [dependencies.tauri-plugin-single-instance]
 version = "2"
 optional = true
+features = ["deep-link"]
 
 [dependencies.tauri-plugin-dialog]
 version = "2"
@@ -116,6 +132,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
@@ -131,3 +151,7 @@ whisper-rs = { version = "0.14.2", default-features = false }
 [target.'cfg(darwin)'.dependencies.whisper-rs]
 version = "0.14.2"
 features = ["metal"]
+
+[workspace.dependencies]
+reqwest = { version = "0.11", features = ["blocking", "json", "multipart", "gzip"] }
+uuid = { version = "1.4", features = ["v4"] }

src-tauri/build.rs

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

src-tauri/capabilities/migrated.json

@@ -36,19 +36,10 @@
       "identifier": "http:default",
       "allow": [
         {
-          "url": "https://*.hdslb.com/"
+          "url": "https://*.*"
         },
         {
-          "url": "https://afdian.com/"
-        },
-        {
-          "url": "https://*.afdiancdn.com/"
-        },
-        {
-          "url": "https://*.douyin.com/"
-        },
-        {
-          "url": "https://*.douyinpic.com/"
+          "url": "http://*.*"
         }
       ]
     },
@@ -65,6 +56,7 @@
     "shell:default",
     "sql:default",
     "os:default",
-    "dialog:default"
+    "dialog:default",
+    "deep-link:default"
   ]
 }

src-tauri/crates/danmu_stream/Cargo.toml

@@ -7,37 +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"
+async-trait = "0.1"
+uuid = { workspace = true}
 
 [build-dependencies]
-tonic-build = "0.10"
+tonic-build = "0.14"

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

@@ -8,7 +8,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize logging
     env_logger::init();
     // Replace these with actual values
-    let room_id = 768756;
+    let room_id = "768756";
     let cookie = "";
     let stream = Arc::new(DanmuStream::new(ProviderType::BiliBili, cookie, room_id).await?);
 

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

@@ -8,7 +8,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize logging
     env_logger::init();
     // Replace these with actual values
-    let room_id = 7514298567821937427; // Replace with actual Douyin room_id. When live starts, the room_id will be generated, so it's more like a live_id.
+    let room_id = "7514298567821937427"; // Replace with actual Douyin room_id. When live starts, the room_id will be generated, so it's more like a live_id.
     let cookie = "your_cookie";
     let stream = Arc::new(DanmuStream::new(ProviderType::Douyin, cookie, room_id).await?);
 

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: String,
     pub provider: Arc<RwLock<Box<dyn DanmuProvider>>>,
     tx: mpsc::UnboundedSender<DanmuMessageType>,
     rx: Arc<RwLock<mpsc::UnboundedReceiver<DanmuMessageType>>>,
@@ -20,14 +21,14 @@ impl DanmuStream {
     pub async fn new(
         provider_type: ProviderType,
         identifier: &str,
-        room_id: u64,
+        room_id: &str,
     ) -> Result<Self, DanmuStreamError> {
         let (tx, rx) = mpsc::unbounded_channel();
         let provider = new(provider_type, identifier, room_id).await?;
         Ok(Self {
             provider_type,
             identifier: identifier.to_string(),
-            room_id,
+            room_id: room_id.to_string(),
             provider: Arc::new(RwLock::new(provider)),
             tx,
             rx: Arc::new(RwLock::new(rx)),

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: String,
     pub user_id: u64,
     pub user_name: String,
     pub message: String,

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

@@ -36,23 +36,25 @@ type WsWriteType = futures_util::stream::SplitSink<
 
 pub struct BiliDanmu {
     client: ApiClient,
-    room_id: u64,
-    user_id: u64,
+    room_id: String,
+    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: &str) -> Result<Self, DanmuStreamError> {
         // find DedeUserID=<user_id> in cookie str
         let user_id = BiliDanmu::parse_user_id(cookie)?;
-        let client = ApiClient::new(cookie);
+        // add buvid3 to cookie
+        let cookie = format!("{};buvid3={}", cookie, uuid::Uuid::new_v4());
+        let client = ApiClient::new(&cookie);
 
         Ok(Self {
             client,
             user_id,
-            room_id,
+            room_id: room_id.to_string(),
             stop: Arc::new(RwLock::new(false)),
             write: Arc::new(RwLock::new(None)),
         })
@@ -63,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: {}",
@@ -72,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(())
@@ -121,7 +126,10 @@ 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.to_string().as_str())
+            .await?;
         let ws_hosts = danmu_info.data.host_list.clone();
         let mut conn = None;
         log::debug!("ws_hosts: {:?}", ws_hosts);
@@ -150,7 +158,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,
@@ -235,9 +243,8 @@ impl BiliDanmu {
     async fn get_danmu_info(
         &self,
         wbi_key: &str,
-        room_id: u64,
+        room_id: &str,
     ) -> Result<DanmuInfo, DanmuStreamError> {
-        let room_id = self.get_real_room(wbi_key, room_id).await?;
         let params = self
             .get_sign(
                 wbi_key,
@@ -263,7 +270,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: &str) -> Result<i64, DanmuStreamError> {
         let params = self
             .get_sign(
                 wbi_key,
@@ -291,14 +298,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());
             }
         }
 
@@ -402,8 +409,8 @@ impl BiliDanmu {
 
 #[derive(Serialize)]
 struct WsSend {
-    uid: u64,
-    roomid: u64,
+    uid: i64,
+    roomid: i64,
     key: String,
     protover: u32,
     platform: String,
@@ -434,5 +441,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 {
@@ -66,7 +65,7 @@ impl WsStreamCtx {
 
         if let Some(danmu_msg) = danmu_msg {
             Ok(DanmuMessageType::DanmuMessage(DanmuMessage {
-                room_id: 0,
+                room_id: "".to_string(),
                 user_id: danmu_msg.uid,
                 user_name: danmu_msg.username,
                 message: danmu_msg.msg,

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: String,
     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),
             })?;
@@ -193,7 +192,7 @@ impl DouyinDanmu {
         });
 
         // Main message handling loop
-        let room_id = self.room_id;
+        let room_id = self.room_id.clone();
         let stop = Arc::clone(&self.stop);
         let write = Arc::clone(&self.write);
         let message_handle = tokio::spawn(async move {
@@ -211,10 +210,10 @@ impl DouyinDanmu {
 
                 match msg {
                     WsMessage::Binary(data) => {
-                        if let Ok(Some(ack)) = handle_binary_message(&data, &tx, room_id).await {
+                        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: &str,
 ) -> Result<Option<PushFrame>, DanmuStreamError> {
     // First decode the PushFrame
     let push_frame = PushFrame::decode(Bytes::from(data.to_vec())).map_err(|e| {
@@ -329,7 +328,7 @@ async fn handle_binary_message(
                     })?;
                 if let Some(user) = chat_msg.user {
                     let danmu_msg = DanmuMessage {
-                        room_id,
+                        room_id: room_id.to_string(),
                         user_id: user.id,
                         user_name: user.nick_name,
                         message: chat_msg.content,
@@ -395,9 +394,9 @@ 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: &str) -> Result<Self, DanmuStreamError> {
         Ok(Self {
-            room_id,
+            room_id: room_id.to_string(),
             cookie: identifier.to_string(),
             stop: Arc::new(RwLock::new(false)),
             write: Arc::new(RwLock::new(None)),
@@ -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: &str) -> 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: &str,
 ) -> Result<Box<dyn DanmuProvider>, DanmuStreamError> {
     match provider_type {
         ProviderType::BiliBili => {

src-tauri/crates/recorder/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+name = "recorder"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "recorder"
+path = "src/lib.rs"
+
+[dependencies]
+danmu_stream = { path = "../danmu_stream" }
+async-trait = "0.1.89"
+rand = "0.9.2"
+chrono = "0.4.42"
+tokio = "1.48.0"
+reqwest = { workspace = true}
+pct-str = "2.0.0"
+serde_json = "1.0.145"
+serde = "1.0.228"
+regex = "1.12.2"
+deno_core = "0.355"
+uuid = { workspace = true}
+serde_derive = "1.0.228"
+thiserror = "2.0.17"
+log = "0.4.28"
+sanitize-filename = "0.6.0"
+m3u8-rs = "6.0.0"
+async-ffmpeg-sidecar = "0.0.3"
+md5 = "0.8.0"
+scraper = "0.24.0"
+base64 = "0.22.1"
+url = "2.5.0"
+urlencoding = "2.1.3"
+fastrand = "2.0.1"
+
+[dev-dependencies]
+env_logger = "0.11"

src-tauri/crates/recorder/src/account.rs

@@ -0,0 +1,9 @@
+#[derive(Debug, Clone, Default)]
+pub struct Account {
+    pub platform: String,
+    pub id: String,
+    pub name: String,
+    pub avatar: String,
+    pub csrf: String,
+    pub cookies: String,
+}

src-tauri/crates/recorder/src/core/hls_recorder.rs

@@ -0,0 +1,437 @@
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, AtomicI64, AtomicU64, Ordering};
+use std::{path::PathBuf, sync::Arc};
+
+use chrono::Utc;
+use m3u8_rs::{MediaPlaylist, Playlist};
+use reqwest::header::HeaderMap;
+use std::time::Duration;
+use tokio::fs::{File, OpenOptions};
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::sync::{broadcast, Mutex, RwLock};
+
+use crate::core::playlist::HlsPlaylist;
+use crate::core::{Codec, Format};
+use crate::errors::RecorderError;
+use crate::ffmpeg::VideoMetadata;
+use crate::{core::HlsStream, events::RecorderEvent};
+
+const UPDATE_TIMEOUT: Duration = Duration::from_secs(20);
+const UPDATE_INTERVAL: Duration = Duration::from_secs(1);
+const PLAYLIST_FILE_NAME: &str = "playlist.m3u8";
+const DOWNLOAD_RETRY: u32 = 3;
+/// A recorder for HLS streams
+///
+/// This recorder fetches, caches and serves TS entries, currently supporting `StreamType::FMP4, StreamType::TS`.
+///
+/// Segments will be downloaded to work_dir, and `playlist.m3u8` will be generated in work_dir.
+#[derive(Clone)]
+pub struct HlsRecorder {
+    room_id: String,
+    stream: Arc<HlsStream>,
+    client: reqwest::Client,
+    event_channel: broadcast::Sender<RecorderEvent>,
+    work_dir: PathBuf,
+    playlist: Arc<Mutex<HlsPlaylist>>,
+    headers: HeaderMap,
+
+    enabled: Arc<AtomicBool>,
+
+    sequence: Arc<AtomicU64>,
+    updated_at: Arc<AtomicI64>,
+
+    cached_duration_secs: Arc<AtomicU64>,
+    cached_size_bytes: Arc<AtomicU64>,
+
+    pre_metadata: Arc<RwLock<Option<VideoMetadata>>>,
+}
+
+impl HlsRecorder {
+    pub async fn new(
+        room_id: String,
+        stream: Arc<HlsStream>,
+        client: reqwest::Client,
+        cookies: Option<String>,
+        event_channel: broadcast::Sender<RecorderEvent>,
+        work_dir: PathBuf,
+        enabled: Arc<AtomicBool>,
+    ) -> Self {
+        // try to create work_dir
+        if !work_dir.exists() {
+            std::fs::create_dir_all(&work_dir).unwrap();
+        }
+        let playlist_path = work_dir.join(PLAYLIST_FILE_NAME);
+
+        // set user agent
+        let user_agent =
+            crate::utils::user_agent_generator::UserAgentGenerator::new().generate(false);
+        let mut headers = reqwest::header::HeaderMap::new();
+        headers.insert("user-agent", user_agent.parse().unwrap());
+        if let Some(cookies) = cookies {
+            headers.insert("cookie", cookies.parse().unwrap());
+        }
+        Self {
+            room_id,
+            stream,
+            client,
+            event_channel,
+            work_dir,
+            playlist: Arc::new(Mutex::new(HlsPlaylist::new(playlist_path).await)),
+            headers,
+            enabled,
+            sequence: Arc::new(AtomicU64::new(0)),
+            updated_at: Arc::new(AtomicI64::new(chrono::Utc::now().timestamp_millis())),
+            cached_duration_secs: Arc::new(AtomicU64::new(0)),
+            cached_size_bytes: Arc::new(AtomicU64::new(0)),
+            pre_metadata: Arc::new(RwLock::new(None)),
+        }
+    }
+
+    /// Start the recorder blockingly
+    ///
+    /// This will start the recorder and update the entries periodically.
+    pub async fn start(&self) -> Result<(), RecorderError> {
+        while self.enabled.load(Ordering::Relaxed) {
+            let result = self.update_entries().await;
+            if let Err(e) = result {
+                match e {
+                    RecorderError::ResolutionChanged { .. } => {
+                        log::error!("Resolution changed: {}", e);
+                        self.playlist.lock().await.close().await?;
+                        return Err(e);
+                    }
+                    RecorderError::UpdateTimeout => {
+                        log::error!(
+                            "Source playlist is not updated for a long time, stop recording"
+                        );
+                        self.playlist.lock().await.close().await?;
+                        return Err(e);
+                    }
+                    RecorderError::M3u8ParseFailed { .. } => {
+                        log::error!("[{}]M3u8 parse failed: {}", self.room_id, e);
+                        return Err(e);
+                    }
+                    _ => {
+                        // Other errors are not critical, just log it
+                        log::error!("[{}]Update entries error: {}", self.room_id, e);
+                        return Err(e);
+                    }
+                }
+            }
+
+            tokio::time::sleep(UPDATE_INTERVAL).await;
+        }
+
+        Ok(())
+    }
+
+    pub async fn stop(&self) {
+        self.enabled.store(false, Ordering::Relaxed);
+    }
+
+    async fn query_playlist(&self, stream: &HlsStream) -> Result<Playlist, RecorderError> {
+        let url = stream.index();
+        let response = self
+            .client
+            .get(url)
+            .headers(self.headers.clone())
+            .send()
+            .await?;
+        let bytes = response.bytes().await?;
+        let (_, playlist) =
+            m3u8_rs::parse_playlist(&bytes).map_err(|_| RecorderError::M3u8ParseFailed {
+                content: String::from_utf8(bytes.to_vec()).unwrap(),
+            })?;
+        Ok(playlist)
+    }
+
+    async fn query_media_playlist(&self) -> Result<MediaPlaylist, RecorderError> {
+        let playlist = self.query_playlist(&self.stream).await?;
+        match playlist {
+            Playlist::MediaPlaylist(playlist) => Ok(playlist),
+            Playlist::MasterPlaylist(playlist) => {
+                // just return the first variant
+                match playlist.variants.first() {
+                    Some(variant) => {
+                        let real_stream = construct_stream_from_variant(
+                            &self.stream.id,
+                            &variant.uri,
+                            self.stream.format.clone(),
+                            self.stream.codec.clone(),
+                        )
+                        .await?;
+                        let playlist = self.query_playlist(&real_stream).await?;
+                        match playlist {
+                            Playlist::MediaPlaylist(playlist) => Ok(playlist),
+                            Playlist::MasterPlaylist(_) => Err(RecorderError::M3u8ParseFailed {
+                                content: "No media playlist found".to_string(),
+                            }),
+                        }
+                    }
+                    None => Err(RecorderError::M3u8ParseFailed {
+                        content: "No variants found".to_string(),
+                    }),
+                }
+            }
+        }
+    }
+
+    async fn update_entries(&self) -> Result<(), RecorderError> {
+        let media_playlist = self.query_media_playlist().await?;
+        let playlist_sequence = media_playlist.media_sequence;
+        let last_sequence = self.sequence.load(Ordering::Relaxed);
+        let last_metadata = self.pre_metadata.read().await.clone();
+        let mut updated = false;
+        for (i, segment) in media_playlist.segments.iter().enumerate() {
+            let segment_sequence = playlist_sequence + i as u64;
+            if segment_sequence <= last_sequence {
+                continue;
+            }
+
+            let segment_full_url = self.stream.ts_url(&segment.uri);
+            // to get filename, we need to remove the query parameters
+            // for example: 1.ts?expires=1760808243
+            // we need to remove the query parameters: 1.ts
+            let filename = segment.uri.split('?').next().unwrap_or(&segment.uri);
+            let segment_path = self.work_dir.join(filename);
+            let Ok(size) = download(
+                &self.client,
+                &segment_full_url,
+                &segment_path,
+                DOWNLOAD_RETRY,
+            )
+            .await
+            else {
+                log::error!("Download failed: {:#?}", segment);
+                return Err(RecorderError::IoError(std::io::Error::other(
+                    "Download failed",
+                )));
+            };
+
+            let mut segment = segment.clone();
+            if segment.program_date_time.is_none() {
+                segment.program_date_time.replace(Utc::now().into());
+            }
+
+            // check if the stream is changed
+            let segment_metadata = crate::ffmpeg::extract_video_metadata(&segment_path)
+                .await
+                .map_err(RecorderError::FfmpegError)?;
+
+            // IMPORTANT: This handles bilibili ts stream segment, which might lack of SPS/PPS and need to be appended behind last segment
+            if segment_metadata.seems_corrupted() {
+                let mut playlist = self.playlist.lock().await;
+                if playlist.is_empty().await {
+                    // ignore this segment
+                    log::error!(
+                        "Segment is corrupted and has no previous segment, ignore: {}",
+                        segment_path.display()
+                    );
+                    continue;
+                }
+
+                let last_segment = playlist.last_segment().await;
+                let last_segment_uri = last_segment.unwrap().uri.clone();
+                let last_segment_path = segment_path.with_file_name(last_segment_uri);
+                // append segment data behind last segment data
+                let mut last_segment_file = OpenOptions::new()
+                    .append(true)
+                    .open(&last_segment_path)
+                    .await?;
+                log::debug!(
+                    "Appending segment data behind last segment: {}",
+                    last_segment_path.display()
+                );
+                let mut segment_file = File::open(&segment_path).await?;
+                let mut buffer = Vec::new();
+                segment_file.read_to_end(&mut buffer).await?;
+                last_segment_file.write_all(&buffer).await?;
+                let _ = tokio::fs::remove_file(&segment_path).await;
+                playlist.append_last_segment(segment.clone()).await?;
+
+                self.cached_duration_secs
+                    .fetch_add(segment_metadata.duration as u64, Ordering::Relaxed);
+                self.cached_size_bytes.fetch_add(size, Ordering::Relaxed);
+                self.sequence.store(segment_sequence, Ordering::Relaxed);
+                self.updated_at
+                    .store(chrono::Utc::now().timestamp_millis(), Ordering::Relaxed);
+                updated = true;
+                continue;
+            }
+
+            if let Some(last_metadata) = &last_metadata {
+                if last_metadata != &segment_metadata {
+                    return Err(RecorderError::ResolutionChanged {
+                        err: "Resolution changed".to_string(),
+                    });
+                }
+            } else {
+                self.pre_metadata
+                    .write()
+                    .await
+                    .replace(segment_metadata.clone());
+            }
+
+            let mut new_segment = segment.clone();
+            new_segment.duration = segment_metadata.duration as f32;
+
+            self.playlist.lock().await.add_segment(new_segment).await?;
+
+            self.cached_duration_secs
+                .fetch_add(segment_metadata.duration as u64, Ordering::Relaxed);
+            self.cached_size_bytes.fetch_add(size, Ordering::Relaxed);
+            self.sequence.store(segment_sequence, Ordering::Relaxed);
+            self.updated_at
+                .store(chrono::Utc::now().timestamp_millis(), Ordering::Relaxed);
+            updated = true;
+        }
+
+        // Source playlist may not be updated for a long time, check if it's timeout
+        let current_time = chrono::Utc::now().timestamp_millis();
+        if self.updated_at.load(Ordering::Relaxed) + (UPDATE_TIMEOUT.as_millis() as i64)
+            < current_time
+        {
+            return Err(RecorderError::UpdateTimeout);
+        }
+
+        if updated {
+            let _ = self.event_channel.send(RecorderEvent::RecordUpdate {
+                live_id: self.stream.id.clone(),
+                duration_secs: self.cached_duration_secs.load(Ordering::Relaxed),
+                cached_size_bytes: self.cached_size_bytes.load(Ordering::Relaxed),
+            });
+        }
+
+        Ok(())
+    }
+}
+
+/// Download url content into fpath
+async fn download_inner(
+    client: &reqwest::Client,
+    url: &str,
+    path: &Path,
+) -> Result<u64, RecorderError> {
+    if !path.parent().unwrap().exists() {
+        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+    }
+    let response = client.get(url).send().await?;
+    if !response.status().is_success() {
+        let status = response.status();
+        log::warn!("Download segment failed: {url}: {status}");
+        return Err(RecorderError::InvalidResponseStatus { status });
+    }
+    let bytes = response.bytes().await?;
+    let size = bytes.len() as u64;
+    let mut file = tokio::fs::File::create(&path).await?;
+    let mut content = std::io::Cursor::new(bytes.clone());
+    tokio::io::copy(&mut content, &mut file).await?;
+    Ok(size)
+}
+
+async fn download(
+    client: &reqwest::Client,
+    url: &str,
+    path: &Path,
+    retry: u32,
+) -> Result<u64, RecorderError> {
+    for i in 0..retry {
+        let result = download_inner(client, url, path).await;
+        if let Ok(size) = result {
+            return Ok(size);
+        }
+        log::error!("Download failed, retry: {}", i);
+        // sleep for 500 ms
+        tokio::time::sleep(Duration::from_millis(500)).await;
+    }
+
+    Err(RecorderError::IoError(std::io::Error::other(
+        "Download failed",
+    )))
+}
+
+pub async fn construct_stream_from_variant(
+    id: &str,
+    variant_url: &str,
+    format: Format,
+    codec: Codec,
+) -> Result<HlsStream, RecorderError> {
+    // construct the real stream from variant
+    // example: https://cn-jsnt-ct-01-07.bilivideo.com/live-bvc/930889/live_2124647716_1414766_bluray/index.m3u8?expires=1760808243
+    let (body, extra) = variant_url.split_once('?').unwrap_or((variant_url, ""));
+    // body example: https://cn-jsnt-ct-01-07.bilivideo.com/live-bvc/930889/live_2124647716_1414766_bluray/index.m3u8
+
+    // extract host, should be like: https://cn-jsnt-ct-01-07.bilivideo.com, which contains http schema
+    let host = if let Some(schema_end) = body.find("://") {
+        let after_schema = &body[schema_end + 3..];
+        if let Some(path_start) = after_schema.find('/') {
+            format!("{}{}", &body[..schema_end + 3], &after_schema[..path_start])
+        } else {
+            body.to_string()
+        }
+    } else {
+        return Err(RecorderError::M3u8ParseFailed {
+            content: "Invalid URL format: missing protocol".to_string(),
+        });
+    };
+
+    // extract base, should be like: /live-bvc/930889/live_2124647716_1414766_bluray/index.m3u8
+    let base = if let Some(schema_end) = body.find("://") {
+        let after_schema = &body[schema_end + 3..];
+        if let Some(path_start) = after_schema.find('/') {
+            format!("/{}", &after_schema[path_start + 1..])
+        } else {
+            "/".to_string()
+        }
+    } else {
+        return Err(RecorderError::M3u8ParseFailed {
+            content: "Invalid URL format: missing protocol".to_string(),
+        });
+    };
+
+    // Add '?' to base if there are query parameters, to match the expected format
+    let base_with_query = if !extra.is_empty() {
+        format!("{}?", base)
+    } else {
+        base
+    };
+
+    let real_stream = HlsStream::new(
+        id.to_string(),
+        host,
+        base_with_query,
+        extra.to_string(),
+        format,
+        codec,
+    );
+
+    Ok(real_stream)
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::core::{Codec, Format};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_construct_stream_from_variant() {
+        let stream = construct_stream_from_variant(
+            "test",
+            "https://hs.hls.huya.com/huyalive/156976698-156976698-674209784144068608-314076852-10057-A-0-1.m3u8?ratio=2000&wsSecret=7abc7dec8809146f31f92046eb044e3b&wsTime=68fa41ba&fm=RFdxOEJjSjNoNkRKdDZUWV8kMF8kMV8kMl8kMw%3D%3D&ctype=tars_mobile&fs=bgct&t=103",
+            Format::TS,
+            Codec::Avc,
+        ).await.unwrap();
+        assert_eq!(stream.index(), "https://hs.hls.huya.com/huyalive/156976698-156976698-674209784144068608-314076852-10057-A-0-1.m3u8?ratio=2000&wsSecret=7abc7dec8809146f31f92046eb044e3b&wsTime=68fa41ba&fm=RFdxOEJjSjNoNkRKdDZUWV8kMF8kMV8kMl8kMw%3D%3D&ctype=tars_mobile&fs=bgct&t=103");
+        assert_eq!(stream.ts_url("1.ts"), "https://hs.hls.huya.com/huyalive/1.ts?ratio=2000&wsSecret=7abc7dec8809146f31f92046eb044e3b&wsTime=68fa41ba&fm=RFdxOEJjSjNoNkRKdDZUWV8kMF8kMV8kMl8kMw%3D%3D&ctype=tars_mobile&fs=bgct&t=103");
+        assert_eq!(stream.ts_url("1.ts?expires=1760808243"), "https://hs.hls.huya.com/huyalive/1.ts?expires=1760808243&ratio=2000&wsSecret=7abc7dec8809146f31f92046eb044e3b&wsTime=68fa41ba&fm=RFdxOEJjSjNoNkRKdDZUWV8kMF8kMV8kMl8kMw%3D%3D&ctype=tars_mobile&fs=bgct&t=103");
+        assert_eq!(stream.host, "https://hs.hls.huya.com");
+        assert_eq!(
+            stream.base,
+            "/huyalive/156976698-156976698-674209784144068608-314076852-10057-A-0-1.m3u8?"
+        );
+        assert_eq!(stream.extra, "ratio=2000&wsSecret=7abc7dec8809146f31f92046eb044e3b&wsTime=68fa41ba&fm=RFdxOEJjSjNoNkRKdDZUWV8kMF8kMV8kMl8kMw%3D%3D&ctype=tars_mobile&fs=bgct&t=103");
+        assert_eq!(stream.format, Format::TS);
+        assert_eq!(stream.codec, Codec::Avc);
+    }
+}