fix: pin 1.5.1 frontend release source

fix: pin 1.5.1-rc1 frontend version
裁剪1下
2026-11-11 00:30:54 +00:00 · 2026-09-24 23:21:05 +08:00 · 2026-09-24 17:25:06 +08:00 · 2026-09-24 17:21:44 +08:00 · 2026-09-24 17:21:37 +08:00 · 2026-09-14 21:13:26 +08:00
265 changed files with 33675 additions and 7608 deletions
@@ -23,6 +23,15 @@ runs:
      with:
        node-version: ${{ inputs.node-version }}

+    - name: Install zstd
+      shell: bash
+      run: |
+        set -euxo pipefail
+        if ! command -v zstd >/dev/null 2>&1; then
+          sudo apt-get update
+          sudo apt-get install -y zstd
+        fi
+
    - name: Clone and build frontend
      shell: bash
      run: |
@@ -38,9 +47,12 @@ runs:
        npm run build
        cd ..

-        mkdir -p web/public/defaultTheme/dist
-        rm -rf web/public/defaultTheme/dist/*
-        cp -r komari-web/dist/* web/public/defaultTheme/dist/
+        mkdir -p web/public/defaultTheme
+        rm -rf web/public/defaultTheme/dist web/public/defaultTheme/dist.tar.zst
+        test -f komari-web/dist/index.html
+        tar -cf "$RUNNER_TEMP/komari-default-dist.tar" -C komari-web/dist .
+        zstd -19 -T0 -q -f "$RUNNER_TEMP/komari-default-dist.tar" -o web/public/defaultTheme/dist.tar.zst
+        rm -f "$RUNNER_TEMP/komari-default-dist.tar"
        cp -f komari-web/komari-theme.json web/public/defaultTheme/
        if [ -f komari-web/preview.png ]; then cp -f komari-web/preview.png web/public/defaultTheme/; fi
        if [ -f komari-web/perview.png ]; then cp -f komari-web/perview.png web/public/defaultTheme/; fi
@@ -22,3 +22,4 @@ runs:
        mkdir -p web/public/defaultTheme
        rm -rf web/public/defaultTheme/*
        tar -xzf "$RUNNER_TEMP/frontend-artifact/${{ inputs.artifact-name }}.tar.gz" -C web/public/defaultTheme
+        test -s web/public/defaultTheme/dist.tar.zst
@@ -98,7 +98,11 @@ jobs:
          fi
          VERSION="${{ github.sha }}"
          VERSION_HASH="${{ github.sha }}"
-          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}" -o $BINARY_NAME
+          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
+          if [ "${{ matrix.goos }}" = "linux" ]; then
+            LDFLAGS="$LDFLAGS -extldflags=-Wl,--strip-all"
+          fi
+          go build -trimpath -ldflags="$LDFLAGS" -o "$BINARY_NAME"

      - name: Upload binary as artifact
        uses: actions/upload-artifact@v4
@@ -14,11 +14,6 @@ jobs:
      - name: Checkout code
        uses: actions/checkout@v4

-      #- name: Create dummy index.html
-      #  run: |
-      #    mkdir -p web/public/defaultTheme/dist
-      #    echo "<html><body><h1>This is komari development server.</h1></body></html>" > web/public/defaultTheme/dist/index.html
-
      - name: Clone and build frontend
        uses: ./.github/actions/build-frontend

@@ -33,7 +28,7 @@ jobs:
          GOARCH: amd64
        run: |
          VERSION_SHA="${{ github.sha }}"
-          go build -ldflags "-X github.com/komari-monitor/komari/utils.CurrentVersion=dev -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_SHA}" -o komari .
+          go build -ldflags "-s -w -extldflags=-Wl,--strip-all -X github.com/komari-monitor/komari/utils.CurrentVersion=dev -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_SHA}" -o komari .

      - name: Upload binary as artifact
        uses: actions/upload-artifact@v4
@@ -50,7 +50,7 @@ jobs:
        run: |
          VERSION="${{ github.ref_name }}"
          VERSION_HASH="${{ github.sha }}"
-          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
+          LDFLAGS="-s -w -extldflags=-Wl,--strip-all -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"

          echo "Building for linux/amd64..."
          GOARCH=amd64 CC="zig cc -target x86_64-linux-musl" go build -trimpath -ldflags="$LDFLAGS" -o komari-linux-amd64
@@ -102,7 +102,11 @@ jobs:
        run: |
          BINARY_NAME=komari-${{ matrix.goos }}-${{ matrix.goarch }}${{ matrix.binary_extension }}
          VERSION_HASH="$(git rev-parse HEAD)"
-          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${RELEASE_TAG} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}" -o "$BINARY_NAME"
+          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${RELEASE_TAG} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
+          if [ "${{ matrix.goos }}" = "linux" ]; then
+            LDFLAGS="$LDFLAGS -extldflags=-Wl,--strip-all"
+          fi
+          go build -trimpath -ldflags="$LDFLAGS" -o "$BINARY_NAME"

      - name: Upload binary to release
        env:
@@ -56,7 +56,7 @@ jobs:
          VERSION: ${{ github.event.inputs.version }}
        run: |
          VERSION_HASH="${{ github.sha }}"
-          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
+          LDFLAGS="-s -w -extldflags=-Wl,--strip-all -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"

          echo "Building for linux/amd64..."
          GOARCH=amd64 CC="zig cc -target x86_64-linux-musl" go build -trimpath -ldflags="$LDFLAGS" -o komari-linux-amd64
@@ -24,7 +24,9 @@ jobs:
          TAG: ${{ github.event.release.tag_name }}
        run: |
          frontend_ref=""
-          if [[ "$TAG" =~ ^(.+)-fix[0-9]+$ ]]; then
+          if [[ "$TAG" == "1.5.1" || "$TAG" == "1.5.1-rc1" ]]; then
+            frontend_ref="1.5.0-fix1"
+          elif [[ "$TAG" =~ ^(.+)-fix[0-9]+$ ]]; then
            frontend_ref="${BASH_REMATCH[1]}"
          fi
          echo "frontend_ref=$frontend_ref" >> "$GITHUB_OUTPUT"
@@ -121,7 +123,11 @@ jobs:
          fi
          VERSION="${{ github.event.release.tag_name }}"
          VERSION_HASH="${{ github.sha }}" # Use commit SHA for hash
-          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}" -o $BINARY_NAME
+          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
+          if [ "${{ matrix.goos }}" = "linux" ]; then
+            LDFLAGS="$LDFLAGS -extldflags=-Wl,--strip-all"
+          fi
+          go build -trimpath -ldflags="$LDFLAGS" -o "$BINARY_NAME"

      - name: Upload binary as artifact
        uses: actions/upload-artifact@v4
@@ -150,7 +150,11 @@ jobs:
          fi
          VERSION="${{ needs.prepare.outputs.version }}"
          VERSION_HASH="${{ github.sha }}" # Use commit SHA for hash
-          go build -trimpath -ldflags="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}" -o $BINARY_NAME
+          LDFLAGS="-s -w -X github.com/komari-monitor/komari/utils.CurrentVersion=${VERSION} -X github.com/komari-monitor/komari/utils.VersionHash=${VERSION_HASH}"
+          if [ "${{ matrix.goos }}" = "linux" ]; then
+            LDFLAGS="$LDFLAGS -extldflags=-Wl,--strip-all"
+          fi
+          go build -trimpath -ldflags="$LDFLAGS" -o "$BINARY_NAME"

      - name: Upload binary as artifact
        uses: actions/upload-artifact@v4
@@ -34,4 +34,7 @@ go.work.sum

 # build
 komari
+/dist/
 .codex
+
+/web/filemanager/data
@@ -8,10 +8,7 @@ ARG TARGETARCH

 RUN apk add --no-cache ca-certificates curl tzdata

-COPY komari-${TARGETOS}-${TARGETARCH} /app/komari
-
-
-RUN chmod +x /app/komari
+COPY --chmod=755 komari-${TARGETOS}-${TARGETARCH} /app/komari

 ENV GIN_MODE=release
 ENV KOMARI_LISTEN=0.0.0.0:25774
@@ -5,43 +5,63 @@

 ![komari](https://socialify.git.ci/komari-monitor/komari/image?description=1&font=Inter&forks=1&issues=1&language=1&logo=https%3A%2F%2Fraw.githubusercontent.com%2Fkomari-monitor%2Fkomari-web%2Fd54ce1288df41ead08aa19f8700186e68028a889%2Fpublic%2Ffavicon.png&name=1&owner=1&pattern=Plus&pulls=1&stargazers=1&theme=Auto)

-[简体中文](./README_zh-cn.md)
+[English](./README.md) | [简体中文](./README_zh-cn.md)

-Komari is a lightweight, self-hosted server monitoring tool designed to provide a simple and efficient solution for monitoring server performance. It supports viewing server status through a web interface and collects data through a lightweight agent.
+Komari is a lightweight, self-hosted server monitoring solution. It provides a simple and efficient way to track server performance through a web interface, with metrics collected by a lightweight agent.

 > [!WARNING]
-> Komari is a self-hosted monitoring and control program intended only for systems you own or are authorized to administer. Do not weaponize Komari, deploy it without consent, or use it for unauthorized access, persistence, command execution, or other abusive activity. For context on real-world abuse risks, see Huntress' analysis: [Komari C2 agent abuse](https://www.huntress.com/blog/komari-c2-agent-abuse).
-> Users are solely responsible for how they deploy and operate Komari. The developers do not accept responsibility for unauthorized or abusive use, or for any resulting consequences.
-> On Windows, when remote control is enabled, the client displays a Windows notification at each user login to remind the user that Komari is remote control software.
+> Komari is a self-hosted monitoring and control application. Deploy it only on systems you own or are authorized to manage. You are solely responsible for how you deploy and use Komari. The developers accept no liability for unauthorized access, persistence, command execution, other misuse, or any resulting consequences.

-[文档/Documentation](https://komari-document.pages.dev/) | [文档(镜像站 By Geekertao)](https://www.komari.wiki) | [Telegram Group](https://t.me/komari_monitor)
+[Documentation](https://www.komari.wiki/) | [Telegram Group](https://t.me/komari_monitor)

 ## Features

- **Lightweight and Efficient**: Low resource consumption, suitable for servers of all sizes.
- **Self-hosted**: Complete control over data privacy, easy to deploy.
- **Web Interface**: Intuitive monitoring dashboard, easy to use.
+- **Real-time monitoring**: Displays monitoring data at one-second intervals.
+- **Lightweight and efficient**: Uses minimal system resources and works well on servers of any size.
+- **Self-hosted**: Keeps you in control of your data and privacy.
+- **Web interface**: Provides an intuitive, easy-to-use monitoring dashboard.
+- **Extensible**: Supports custom themes and plugins.

-## One-click Deployment
+## Quick Start

- Rainyun - CNY 4.5/month
+| Platform                                                                                                                                                                                                  | Description                                                                                                                                                                                           |
+| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a href="https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_"><img src="https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg" alt="Rainyun" width="180"></a>                       | Deploy websites, databases, and hundreds of popular apps in seconds with flexible hourly billing. [Get started for just ¥5/month. Deploy now!](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_) |
+| <a href="https://apps.fit2cloud.com/1panel/komari"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/1panel-logo-blue.png" alt="1Panel App Store" width="180"></a> | A modern, open-source Linux server management panel for websites, databases, containers, files, backups, security, and AI, with one-click deployment from its app store.                              |

-[![](https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg)](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_)
+For instructions on Docker deployment, binary installation, building from source, and updates, see the [installation guide](https://www.komari.wiki/en/install/quick-start).

- 1Panel App Store
+## Screenshots

-Available on 1Panel App Store. Install via **App Store > Utilities > Komari**.
+| Page                | Screenshot                                                                                                                                                             |
+| ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Home Dashboard      | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E4%B8%BB%E9%A1%B5%E4%BB%AA%E8%A1%A8%E7%9B%98-en.webp" width="800" alt="Home Dashboard">               |
+| Admin Dashboard     | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E5%90%8E%E5%8F%B0%E4%BB%AA%E8%A1%A8%E7%9B%98-en.webp" width="800" alt="Admin Dashboard">              |
+| History Charts      | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E5%8E%86%E5%8F%B2%E5%9B%BE%E8%A1%A8-en.webp" width="800" alt="History Charts">                        |
+| Web Terminal        | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E7%BD%91%E9%A1%B5%E7%BB%88%E7%AB%AF.webp" width="800" alt="Web Terminal">                             |
+| Customizable Themes | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E4%B8%BB%E9%A2%98%E5%8F%AF%E8%87%AA%E5%AE%9A%E4%B9%89-en.webp" width="800" alt="Customizable Themes"> |
+| Theme Market        | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E4%B8%BB%E9%A2%98%E5%B8%82%E5%9C%BA-en.webp" width="800" alt="Theme Market">                          |

-For Docker, binary, source-build, and update instructions, see the [installation guide](https://komari-document.pages.dev/en/install/quick-start).
+## Sponsors

-## Contributing
+Interested in sponsoring Komari? Contact the developer via [email](mailto:komari@akz.moe) or [Telegram](https://t.me/mamomoe).

-Issues and Pull Requests are welcome!
+| Sponsor                                                                                                                                                                                          | Description                                                                                                                                                                                                                                                                   |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a href="https://axisnow.io/zh?utm=komari"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/AxisNow.jpg" alt="AxisNow" width="180"></a> | [Self-Hosted Private CDN \| Subscription-Based CDN-Like Service \| A Fully Controlled, Flexible, Modular CDN Network](https://axisnow.io/zh?utm=komari) |
+| <a href="https://whmcs.as211392.com/aff.php?aff=110"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/dreamcloud.png" alt="Dream Cloud" width="180"></a> | Cost-effective Asia-Pacific hosting with direct connectivity and robust DDoS protection, backed by transparent capacity claims.                                                                                                                                               |
+| <a href="https://sharon.io"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/sharon-networks.webp" alt="Sharon Networks" width="180"></a>                | Premium China-optimized connectivity from Asia-Pacific data centers, featuring low latency, high bandwidth, and Tbps-scale local DDoS mitigation. Join the [Telegram community](https://t.me/SharonNetwork) to participate in charitable initiatives and community giveaways. |

-## Acknowledgements
+## Contributors

-| Acknowledgement                                                                                                                                                                                  | Details                                                                                                                                                                                                             |
-| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| <a href="https://whmcs.as211392.com/aff.php?aff=110"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/dreamcloud.png" alt="Dream Cloud" width="180"></a> | 极高性价比解锁直连亚太高防，真高防，不虚标，打死退款                                                                                                                                                                |
-| <a href="https://sharon.io"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/sharon-networks.webp" alt="Sharon Networks" width="180"></a>                | 亚太数据中心提供顶级的中国优化网络接入 · 低延时&高带宽&提供Tbps级本地清洗高防服务, 为您的业务保驾护航, 为您的客户提供极致体验. 加入社区 [Telegram群组](https://t.me/SharonNetwork) 可参与公益募捐或群内抽奖免费使用 |
-| Open-source community                                                                                                                                                                            | Everyone who has submitted pull requests or created themes.                                                                                                                                                         |
+Thanks to everyone who has contributed code, themes, plugins, documentation, translations, bug reports, or feedback to Komari.
+
+<a href="https://github.com/komari-monitor/komari/graphs/contributors"><img src="https://contributors-img.web.app/image?repo=komari-monitor/komari" alt="Komari contributors" width="600"></a>
+
+## Support the Project
+
+If Komari has been useful to you, consider buying me a coffee. Thank you for your support!
+
+| WeChat Pay                                                                                                   | TRON Network                                                                                |
+| ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- |
+| ![WeChat Pay QR code](https://b2.akz.moe/awesome-pictures/%E5%BE%AE%E4%BF%A1%E8%B5%9E%E8%B5%8F%E7%A0%81.png) | ![TRON Network QR code](https://b2.akz.moe/awesome-pictures/PixPin_2026-08-07_15-16-52.png) |
@@ -5,45 +5,63 @@

 ![komari](https://socialify.git.ci/komari-monitor/komari/image?description=1&font=Inter&forks=1&issues=1&language=1&logo=https%3A%2F%2Fraw.githubusercontent.com%2Fkomari-monitor%2Fkomari-web%2Fd54ce1288df41ead08aa19f8700186e68028a889%2Fpublic%2Ffavicon.png&name=1&owner=1&pattern=Plus&pulls=1&stargazers=1&theme=Auto)

-[简体中文](./README_zh-cn.md)
+[English](./README.md) | [简体中文](./README_zh-cn.md)

 Komari 是一款轻量级的自托管服务器监控工具，旨在提供简单、高效的服务器性能监控解决方案。它支持通过 Web 界面查看服务器状态，并通过轻量级 Agent 收集数据。

 > [!WARNING]
-> Komari 是一款自托管的监控/控制程序，仅应部署在你拥有或已获得授权管理的系统上。请勿将 Komari 武器化，或在未获授权的情况下部署、访问、持久化、执行命令及从事其他滥用行为。关于现实中的滥用风险，可参考 Huntress 的分析：[Komari C2 agent abuse](https://www.huntress.com/blog/komari-c2-agent-abuse)。
-> 用户需要自行承担部署和使用 Komari 的责任。开发者不对未经授权或滥用行为及其后果承担责任。
-> 在 Windows 端开启远程控制后，客户端会在每次用户登录时通过 Windows 通知提醒用户 Komari 是一款远程控制软件。
+> Komari 是一款自托管的监控/控制程序，仅应部署在你拥有或已获得授权管理的系统上。在未获授权的情况下部署、访问、持久化、执行命令及从事其他滥用行为，用户需要自行承担部署和使用 Komari 的责任。开发者不对未经授权或滥用行为及其后果承担责任。

-[文档/Documentation](https://www.komari.wiki/) | [Telegram 群](https://t.me/komari_monitor)
+[文档](https://www.komari.wiki/) | [Telegram 群](https://t.me/komari_monitor)

 ## 特性

+- **实时监控**: 秒级实时数据展示。
 - **轻量高效**：低资源占用，适合各种规模的服务器。
 - **自托管**：完全掌控数据隐私，部署简单。
 - **Web 界面**：直观的监控仪表盘，易于使用。
+- **极强的可扩展性**: 支持自定义主题和插件。

 ## 快速开始

-### 0. 容器云一键部署
-
- 雨云云应用 - CNY 4.5/月
-
-[![](https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg)](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_)
-
- 1Panel 应用商店
-
-已上架1Panel应用商店，应用商店-实用工具-Komari 即可安装
+| 平台                                                                                                                                                                                                     | 介绍                                                                                                                                   |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| <a href="https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_"><img src="https://rainyun-apps.cn-nb1.rains3.com/materials/deploy-on-rainyun-cn.svg" alt="Rainyun" width="180"></a>                      | 秒级部署网站、数据库及数百款热门 App，并采用按小时灵活计费。[每月5元，立即部署](https://app.rainyun.com/apps/rca/store/6780/NzYxNzAz_) |
+| <a href="https://apps.fit2cloud.com/1panel/komari"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/1panel-logo-blue.png" alt="1Panel Appstore" width="180"></a> | 现代化、开源的Linux 服务器运维管理面板，提供网站、数据库、容器、文件、备份、安全与AI 管理能力，支持应用商店一键部署。                  |

 Docker、二进制文件、源码构建和更新说明，请参阅 [安装指南](https://www.komari.wiki/install/quick-start).

-## 贡献
+## 截图

-欢迎提交 Issue 或 Pull Request！
+| 页面         | 截图                                                                                                                                                         |
+| ------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 主页仪表盘   | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E4%B8%BB%E9%A1%B5%E4%BB%AA%E8%A1%A8%E7%9B%98.webp" width="800" alt="主页仪表盘">            |
+| 后台仪表盘   | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E5%90%8E%E5%8F%B0%E4%BB%AA%E8%A1%A8%E7%9B%98.webp" width="800" alt="后台仪表盘">            |
+| 历史图表     | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E5%8E%86%E5%8F%B2%E5%9B%BE%E8%A1%A8.webp" width="800" alt="历史图表">                       |
+| 网页终端     | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E7%BD%91%E9%A1%B5%E7%BB%88%E7%AB%AF.webp" width="800" alt="网页终端">                       |
+| 主题可自定义 | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E4%B8%BB%E9%A2%98%E5%8F%AF%E8%87%AA%E5%AE%9A%E4%B9%89.webp" width="800" alt="主题可自定义"> |
+| 主题市场     | <img src="https://b2.akz.moe/awesome-pictures/komari-screenshot/%E4%B8%BB%E9%A2%98%E5%B8%82%E5%9C%BA.webp" width="800" alt="主题市场">                       |

-## 鸣谢
+## 赞助商
+
+有意赞助 Komari？请通过 [电子邮箱](mailto:komari@akz.moe) 或 [Telegram](https://t.me/mamomoe) 联系开发者。

 | 赞助商                                                                                                                                                                                           | 描述                                                                                                                                                                                                                |
 | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| <a href="https://axisnow.io/zh?utm=komari"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/AxisNow.jpg" alt="AxisNow" width="180"></a> | [自建私有部署CDN \| 订阅式高仿CDN \| 自主可控、灵活组合的CDN网络](https://axisnow.io/zh?utm=komari) |
 | <a href="https://whmcs.as211392.com/aff.php?aff=110"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/dreamcloud.png" alt="Dream Cloud" width="180"></a> | 极高性价比解锁直连亚太高防，真高防，不虚标，打死退款                                                                                                                                                                |
 | <a href="https://sharon.io"><img src="https://raw.githubusercontent.com/komari-monitor/public/refs/heads/main/images/sharon-networks.webp" alt="Sharon Networks" width="180"></a>                | 亚太数据中心提供顶级的中国优化网络接入 · 低延时&高带宽&提供Tbps级本地清洗高防服务, 为您的业务保驾护航, 为您的客户提供极致体验. 加入社区 [Telegram群组](https://t.me/SharonNetwork) 可参与公益募捐或群内抽奖免费使用 |
-| 开源社区                                                                                                                                                                                         | 提交 PR、制作主题的各位开发者                                                                                                                                                                                       |
+
+## 贡献者
+
+感谢所有为 Komari 贡献代码、主题、插件、文档、翻译、问题报告或反馈的朋友。
+
+<a href="https://github.com/komari-monitor/komari/graphs/contributors"><img src="https://contributors-img.web.app/image?repo=komari-monitor/komari" alt="Komari 贡献者" width="600"></a>
+
+## 支持项目
+
+如果 Komari 对你有所帮助，欢迎请作者喝一杯奶茶。感谢你的支持！
+
+| 微信赞赏码                                                                                       | TRON Network                                                                |
+| ------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------- |
+| ![wechat](https://b2.akz.moe/awesome-pictures/%E5%BE%AE%E4%BF%A1%E8%B5%9E%E8%B5%8F%E7%A0%81.png) | ![TRON](https://b2.akz.moe/awesome-pictures/PixPin_2026-08-07_15-16-52.png) |
@@ -48,7 +48,7 @@ func CreateSession(uuid string, expires int, userAgent, ip, login_method string)
 			if ipinfo != nil && ipinfo.Name != "" {
 				loc = ipinfo.Name
 			}
-			messageSender.SendEvent(models.EventMessage{
+			_ = messageSender.SendNotification(models.EventMessage{
 				Event:   messageevent.Login,
 				Time:    time.Now().UTC(),
 				Message: fmt.Sprintf("%s: %s (%s)\n%s", login_method, ip, loc, userAgent),
@@ -6,7 +6,7 @@ import (

 	"github.com/komari-monitor/komari/database/dbcore"
 	"github.com/komari-monitor/komari/database/models"
-	v1 "github.com/komari-monitor/komari/protocol/v1"
+	v2 "github.com/komari-monitor/komari/protocol/v2"
 )

 func GetClientUUIDByToken(token string) (clientUUID string, err error) {
@@ -20,7 +20,7 @@ func GetClientUUIDByToken(token string) (clientUUID string, err error) {
 }

 // 检查数据防止异常数据导致数据库损坏
-func ReportVerify(report v1.Report) error {
+func ReportVerify(report v2.Report) error {
 	// 防止输入不合理范围
 	if report.CPU.Usage < 0 || report.CPU.Usage > 100 {
 		return fmt.Errorf("CPU.Usage must be between 0 and 100")
@@ -444,6 +444,7 @@ func doInitialize() error {
 	// 若升级时旧表仍存在，管理员可通过升级向导显式导入并清理。
 	// models.Record / models.PingRecord / models.GPURecord 结构体仍作为
 	// metric store 的读写 DTO 和旧表导入 DTO 保留在 models 包中。
+	// models.TrafficReportNotification 同样仅为旧数据库兼容保留，不再建表。

 	err = instance.AutoMigrate(
 		&models.User{},
@@ -452,11 +453,11 @@ func doInitialize() error {
 		&models.Clipboard{},
 		&models.LoadNotification{},
 		&models.OfflineNotification{},
-		&models.TrafficReportNotification{},
 		&models.PingTask{},
 		&models.OidcProvider{},
 		&models.MessageSenderProvider{},
 		&models.ThemeConfiguration{},
+		&models.PluginConfiguration{},
 	)
 	if err != nil {
 		return fmt.Errorf("failed to create tables: %w", err)
@@ -5,15 +5,6 @@ import (
 	"github.com/komari-monitor/komari/database/models"
 )

-func GetAllMessageSenderConfigs() []models.MessageSenderProvider {
-	db := dbcore.GetDBInstance()
-	var result []models.MessageSenderProvider
-	if err := db.Find(&result).Error; err != nil {
-		return nil
-	}
-	return result
-}
-
 func GetMessageSenderConfigByName(name string) (*models.MessageSenderProvider, error) {
 	db := dbcore.GetDBInstance()
 	var config models.MessageSenderProvider
@@ -1,152 +0,0 @@
-package metricstore
-
-import (
-	"context"
-	"path/filepath"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/komari-monitor/komari/pkg/metric"
-)
-
-func TestMigrateBetweenStoresCopiesPersistedRollupsAfterReopen(t *testing.T) {
-	ctx := context.Background()
-	policy := defaultRollupPolicy()
-	sourcePath := filepath.Join(t.TempDir(), "source.db")
-	source, err := metric.Open(ctx, metric.SQLite(sourcePath,
-		metric.WithMaxOpenConns(1),
-		metric.WithMaxIdleConns(1),
-		metric.WithRollupPolicy(policy),
-	))
-	if err != nil {
-		t.Fatalf("open source: %v", err)
-	}
-
-	definitions := []metric.Definition{
-		{Name: "a.metric", Description: "migrated definition", Type: metric.TypeGauge, Unit: "%", RetentionDays: 30, Metadata: map[string]string{"owner": "test"}},
-		{Name: "z.empty", Type: metric.TypeCounter, Unit: "bytes", RetentionDays: 7, Metadata: map[string]string{}},
-	}
-	for _, definition := range definitions {
-		if err := source.UpsertMetric(ctx, definition); err != nil {
-			t.Fatalf("upsert source metric %q: %v", definition.Name, err)
-		}
-	}
-
-	base := time.Date(2026, 7, 26, 12, 0, 0, 0, time.UTC)
-	digest := metric.NewTDigest(policy.Compression)
-	for _, value := range []float64{10, 20, 30} {
-		digest.Add(value, 1)
-	}
-	sourceRollups := []metric.PersistedRollup{
-		{
-			MetricName: "a.metric", EntityID: "agent-1", Tags: map[string]string{"device": "cpu0"}, Labels: map[string]string{"zone": "ap"},
-			Resolution: time.Minute, Bucket: base, Count: 3, Sum: 60, SumSq: 1400, Min: 10, Max: 30,
-			FirstValue: 10, FirstTime: base.Add(time.Second), LastValue: 30, LastTime: base.Add(40 * time.Second),
-			Digest: digest.Encode(), CreatedAt: base.Add(time.Hour),
-		},
-		{
-			MetricName: "a.metric", EntityID: "agent-2", Tags: map[string]string{}, Labels: map[string]string{"zone": "eu"},
-			Resolution: time.Hour, Bucket: base, Count: 12, Sum: 60, SumSq: 300, Min: 5, Max: 5,
-			FirstValue: 5, FirstTime: base.Add(time.Minute), LastValue: 5, LastTime: base.Add(50 * time.Minute),
-			CreatedAt: base.Add(time.Hour),
-		},
-	}
-	if err := source.ImportRollups(ctx, sourceRollups); err != nil {
-		t.Fatalf("seed source rollups: %v", err)
-	}
-	if err := source.Close(); err != nil {
-		t.Fatalf("close source: %v", err)
-	}
-
-	source, err = metric.Open(ctx, metric.SQLite(sourcePath,
-		metric.WithMaxOpenConns(1),
-		metric.WithMaxIdleConns(1),
-		metric.WithRollupPolicy(policy),
-	))
-	if err != nil {
-		t.Fatalf("reopen source: %v", err)
-	}
-	defer source.Close()
-	raw, err := source.Query(ctx, metric.Query{
-		MetricName: "a.metric", Start: base.Add(-time.Hour), End: base.Add(2 * time.Hour),
-	})
-	if err != nil {
-		t.Fatalf("query reopened raw window: %v", err)
-	}
-	if len(raw) != 0 {
-		t.Fatalf("reopened source raw points = %d, want 0", len(raw))
-	}
-
-	target, err := metric.Open(ctx, metric.SQLite(filepath.Join(t.TempDir(), "target.db"),
-		metric.WithMaxOpenConns(1),
-		metric.WithMaxIdleConns(1),
-		metric.WithRollupPolicy(policy),
-	))
-	if err != nil {
-		t.Fatalf("open target: %v", err)
-	}
-	defer target.Close()
-
-	type progressEvent struct {
-		metricName                string
-		metricIndex, totalMetrics int
-		added                     int64
-	}
-	var events []progressEvent
-	total, err := migrateBetweenStores(ctx, source, target, func(name string, index, definitions int, added int64) {
-		events = append(events, progressEvent{name, index, definitions, added})
-	})
-	if err != nil {
-		t.Fatalf("migrate stores: %v", err)
-	}
-	if total != int64(len(sourceRollups)) {
-		t.Fatalf("migrated rollups = %d, want %d", total, len(sourceRollups))
-	}
-	wantEvents := []progressEvent{
-		{metricName: "a.metric", metricIndex: 0, totalMetrics: 2},
-		{metricName: "a.metric", metricIndex: 0, totalMetrics: 2, added: 2},
-		{metricName: "z.empty", metricIndex: 1, totalMetrics: 2},
-	}
-	if !reflect.DeepEqual(events, wantEvents) {
-		t.Fatalf("migration events = %#v, want %#v", events, wantEvents)
-	}
-
-	for _, want := range definitions {
-		got, err := target.GetMetric(ctx, want.Name)
-		if err != nil {
-			t.Fatalf("get target metric %q: %v", want.Name, err)
-		}
-		if got.Name != want.Name || got.Description != want.Description || got.Type != want.Type || got.Unit != want.Unit || got.RetentionDays != want.RetentionDays || !reflect.DeepEqual(got.Metadata, want.Metadata) {
-			t.Fatalf("target definition = %#v, want mutable fields from %#v", got, want)
-		}
-	}
-
-	exported := exportMigrationTestRollups(t, target, "a.metric")
-	if !reflect.DeepEqual(exported, sourceRollups) {
-		t.Fatalf("target rollups differ:\n got: %#v\nwant: %#v", exported, sourceRollups)
-	}
-	secondTotal, err := MigrateBetweenStores(ctx, source, target)
-	if err != nil {
-		t.Fatalf("repeat migration: %v", err)
-	}
-	if secondTotal != total {
-		t.Fatalf("repeat migrated rollups = %d, want %d", secondTotal, total)
-	}
-	if got := exportMigrationTestRollups(t, target, "a.metric"); !reflect.DeepEqual(got, sourceRollups) {
-		t.Fatalf("repeat migration changed target rollups: %#v", got)
-	}
-}
-
-func exportMigrationTestRollups(t *testing.T, store *metric.Store, metricName string) []metric.PersistedRollup {
-	t.Helper()
-	var result []metric.PersistedRollup
-	_, err := store.ExportRollups(context.Background(), metricName, 1, func(batch []metric.PersistedRollup) error {
-		result = append(result, batch...)
-		return nil
-	})
-	if err != nil {
-		t.Fatalf("export %q rollups: %v", metricName, err)
-	}
-	return result
-}
@@ -8,7 +8,4 @@ const (
 	Login   = "Login"
 	Alert   = "Alert"
 	Traffic = "Traffic"
-	DReport = "DReport" // 日报
-	WReport = "WReport" // 周报
-	MReport = "MReport" // 月报
 )
@@ -8,9 +8,9 @@ type MessageSenderProvider struct {
 }

 type EventMessage struct {
-	Event   string    `json:"event"`
+	Event   any       `json:"event"`
 	Clients []Client  `json:"clients"`
 	Time    time.Time `json:"time"`
-	Message string    `json:"message"`
-	Emoji   string    `json:"emoji"`
+	Message any       `json:"message"`
+	Emoji   any       `json:"emoji"`
 }
@@ -0,0 +1,86 @@
+package models
+
+// Plugin is the manifest of an installed plugin (komari-plugin.json).
+//
+// Name, Description and Author accept either a plain string or an i18n map
+// like {"zh_CN": "...", "en": "..."}, mirroring the theme manifest. The
+// backend passes the value through and the frontend resolves it against the
+// current locale.
+type Plugin struct {
+	Name          any               `json:"name"`
+	Short         string            `json:"short"` // directory name under data/plugin
+	Description   any               `json:"description"`
+	Author        any               `json:"author"`
+	Version       string            `json:"version"`
+	URL           string            `json:"url"`
+	Icon          string            `json:"icon"`
+	Komari        string            `json:"komari"` // supported server version constraint, e.g. ">=0.0.1"
+	Entry         string            `json:"entry"`  // entry script, defaults to "script.js"
+	Permissions   PluginPermissions `json:"permissions"`
+	Configuration Configuration     `json:"configuration"`   // declared config items, same shape as themes
+	Pages         []PluginPage      `json:"pages,omitempty"` // injected admin pages
+}
+
+// PluginPermissions declares the plugin capabilities that require admin
+// approval. Every field defaults to its zero value: nothing is granted
+// unless declared.
+//
+// The following capabilities are always granted and never require approval:
+// reading the plugin's own configuration (server.getConfig), registering
+// plugin-owned RPC methods (server.registerRPC), and reading/writing files
+// inside the plugin directory.
+type PluginPermissions struct {
+	Node                bool  `json:"node"`                // Node.js compatibility modules (runtime setting, not approval-relevant)
+	AllowSystemRPC      bool  `json:"allowSystemRPC"`      // server.call: call system RPC methods with admin authority
+	AllowRoutes         bool  `json:"allowRoutes"`         // server.route: register HTTP routes on the host engine
+	AllowHooks          bool  `json:"allowHooks"`          // server.hook: modify HTTP requests/responses and intercept WebSocket connections/frames
+	AllowHTMLInject     bool  `json:"allowHTMLInject"`     // server.injectHTML: embed CSS/JS into every HTML response
+	AllowExec           bool  `json:"allowExec"`           // child_process: execute child processes
+	AllowListen         bool  `json:"allowListen"`         // net/http servers: listen on local ports
+	AllowAllFileAccess  bool  `json:"allowAllFileAccess"`  // access files outside the plugin directory
+	MaxHTTPBodyBytes    int64 `json:"maxHTTPBodyBytes"`    // runtime limit, not approval-relevant
+	MaxChildOutputBytes int   `json:"maxChildOutputBytes"` // runtime limit, not approval-relevant
+	TimeoutSeconds      int   `json:"timeout"`             // per-turn execution timeout in seconds, not approval-relevant
+}
+
+// PageVisibility controls who can reach a plugin page.
+type PageVisibility string
+
+const (
+	// PageVisibilityAdmin limits the page to the admin sidebar.
+	PageVisibilityAdmin PageVisibility = "admin"
+	// PageVisibilityPublic serves the page through the public route without
+	// navigation, mirroring the theme public behavior.
+	PageVisibilityPublic PageVisibility = "public"
+)
+
+// PageType controls how a plugin page is presented.
+type PageType string
+
+const (
+	// PageTypeIframe embeds a static file from the plugin directory.
+	PageTypeIframe PageType = "iframe"
+	// PageTypeRedirect navigates to an internal site path, mirroring the
+	// theme redirect configuration. The URL must stay on the same origin.
+	PageTypeRedirect PageType = "redirect"
+)
+
+// PluginPage declares a page provided by the plugin. An iframe page is served
+// from the plugin directory (File); a redirect page navigates to an internal
+// site path (URL). Visibility defaults to admin so existing packages keep
+// their current behavior.
+type PluginPage struct {
+	File       string         `json:"file"`
+	Title      any            `json:"title"`
+	Icon       string         `json:"icon"`
+	Type       PageType       `json:"type,omitempty"`
+	URL        string         `json:"url,omitempty"`
+	Visibility PageVisibility `json:"visibility,omitempty"`
+}
+
+// PluginConfiguration stores the saved configuration values of one plugin,
+// mirroring ThemeConfiguration.
+type PluginConfiguration struct {
+	Short string `json:"short" gorm:"primaryKey;unique;not null"`
+	Data  string `json:"data" gorm:"type:longtext" default:"{}"`
+}
@@ -15,16 +15,37 @@ const (

 // Theme represents a komari theme information
 type Theme struct {
-	Name          string        `json:"name"`          // 主题名称
+	Name          any           `json:"name"`          // 主题名称，支持字符串或多语言对象
 	Short         string        `json:"short"`         // 短名称，用作文件夹名
-	Description   string        `json:"description"`   // 主题描述
+	Description   any           `json:"description"`   // 主题描述，支持字符串或多语言对象
 	Version       string        `json:"version"`       // 版本号
-	Author        string        `json:"author"`        // 作者
+	Author        any           `json:"author"`        // 作者，支持字符串或多语言对象
 	URL           string        `json:"url"`           // 主题URL
 	Preview       string        `json:"preview"`       // 预览图片相对路径
 	Configuration Configuration `json:"configuration"` // 声明配置项
 }

+// IsLocalizedText reports whether a manifest text field has a usable value.
+func IsLocalizedText(value any) bool {
+	switch text := value.(type) {
+	case string:
+		return strings.TrimSpace(text) != ""
+	case map[string]any:
+		for _, item := range text {
+			if itemText, ok := item.(string); ok && strings.TrimSpace(itemText) != "" {
+				return true
+			}
+		}
+	case map[string]string:
+		for _, item := range text {
+			if strings.TrimSpace(item) != "" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 type Configuration struct {
 	Type string `json:"type"` // managed raw redirect
 	Icon string `json:"icon"` // 图标
@@ -36,7 +57,7 @@ type ManagedThemeConfigurationItem struct {
 	Key      string `json:"key"`
 	Name     any    `json:"name"`
 	Required bool   `json:"required"`
-	Type     string `json:"type"` // string number select switch title
+	Type     string `json:"type"` // string number select switch title textbox richtext nodes pingtasks
 	Options  string `json:"options"`
 	Default  any    `json:"default"`
 	Help     any    `json:"help"`
@@ -53,11 +53,6 @@ func GetAllLoadNotifications() ([]models.LoadNotification, error) {
 	return notifications, nil
 }

-func SaveLoadNotification(record models.LoadNotification) error {
-	db := dbcore.GetDBInstance()
-	return db.Create(&record).Error
-}
-
 func ReloadLoadNotificationSchedule() error {
 	db := dbcore.GetDBInstance()
 	var loadNotifications []models.LoadNotification
@@ -1,144 +0,0 @@
-package notification
-
-import (
-	"fmt"
-
-	"github.com/komari-monitor/komari/database/dbcore"
-	"github.com/komari-monitor/komari/database/models"
-	"gorm.io/gorm/clause"
-)
-
-func validateTrafficReportNotification(notification models.TrafficReportNotification) error {
-	if notification.Client == "" {
-		return fmt.Errorf("client UUID cannot be empty")
-	}
-	if notification.Enable && !notification.Daily && !notification.Weekly && !notification.Monthly {
-		return fmt.Errorf("at least one cadence must be selected when enabling traffic reports")
-	}
-	return nil
-}
-
-func ValidateTrafficReportNotifications(notifications []models.TrafficReportNotification) error {
-	for _, notification := range notifications {
-		if err := validateTrafficReportNotification(notification); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func buildEnabledTrafficReportNotifications(uuids []string, existing []models.TrafficReportNotification) ([]models.TrafficReportNotification, error) {
-	if len(uuids) == 0 {
-		return nil, fmt.Errorf("at least one client UUID is required")
-	}
-
-	existingByClient := make(map[string]models.TrafficReportNotification, len(existing))
-	for _, notification := range existing {
-		existingByClient[notification.Client] = notification
-	}
-
-	notifications := make([]models.TrafficReportNotification, 0, len(uuids))
-	for _, uuid := range uuids {
-		if uuid == "" {
-			return nil, fmt.Errorf("client UUID cannot be empty")
-		}
-		existingNotification, ok := existingByClient[uuid]
-		if !ok || (!existingNotification.Daily && !existingNotification.Weekly && !existingNotification.Monthly) {
-			return nil, fmt.Errorf("at least one cadence must be selected when enabling traffic reports")
-		}
-		notifications = append(notifications, models.TrafficReportNotification{
-			Client: uuid,
-			Enable: true,
-		})
-	}
-
-	return notifications, nil
-}
-
-// ListTrafficReportNotifications 获取所有流量定时报告配置（关联客户端信息）
-func ListTrafficReportNotifications() ([]models.TrafficReportNotification, error) {
-	db := dbcore.GetDBInstance()
-	var notifications []models.TrafficReportNotification
-	err := db.Model(&models.TrafficReportNotification{}).Preload("ClientInfo").Find(&notifications).Error
-	return notifications, err
-}
-
-// EditTrafficReportNotifications 批量更新流量定时报告配置
-func EditTrafficReportNotifications(notifications []models.TrafficReportNotification) error {
-	if err := ValidateTrafficReportNotifications(notifications); err != nil {
-		return err
-	}
-	db := dbcore.GetDBInstance()
-	return db.Model(&models.TrafficReportNotification{}).
-		Clauses(clause.OnConflict{
-			Columns:   []clause.Column{{Name: "client"}},
-			DoUpdates: clause.AssignmentColumns([]string{"enable", "daily", "weekly", "monthly"}),
-		}).
-		Select("client", "enable", "daily", "weekly", "monthly").
-		Create(notifications).Error
-}
-
-// EnableTrafficReportNotifications 批量启用（仅更新 enable 字段）
-func EnableTrafficReportNotifications(uuids []string) error {
-	if len(uuids) == 0 {
-		return fmt.Errorf("at least one client UUID is required")
-	}
-
-	db := dbcore.GetDBInstance()
-	var existing []models.TrafficReportNotification
-	if err := db.Where("client IN ?", uuids).Find(&existing).Error; err != nil {
-		return err
-	}
-	notifications, err := buildEnabledTrafficReportNotifications(uuids, existing)
-	if err != nil {
-		return err
-	}
-	return db.Model(&models.TrafficReportNotification{}).
-		Clauses(clause.OnConflict{
-			Columns:   []clause.Column{{Name: "client"}},
-			DoUpdates: clause.AssignmentColumns([]string{"enable"}),
-		}).
-		Select("client", "enable").
-		Create(notifications).Error
-}
-
-// DisableTrafficReportNotifications 批量禁用
-func DisableTrafficReportNotifications(uuids []string) error {
-	if len(uuids) == 0 {
-		return fmt.Errorf("at least one client UUID is required")
-	}
-	db := dbcore.GetDBInstance()
-	var notifications []models.TrafficReportNotification
-	for _, uuid := range uuids {
-		if uuid == "" {
-			return fmt.Errorf("client UUID cannot be empty")
-		}
-		notifications = append(notifications, models.TrafficReportNotification{
-			Client: uuid,
-			Enable: false,
-		})
-	}
-	return db.Model(&models.TrafficReportNotification{}).
-		Clauses(clause.OnConflict{
-			Columns:   []clause.Column{{Name: "client"}},
-			DoUpdates: clause.AssignmentColumns([]string{"enable"}),
-		}).
-		Select("client", "enable").
-		Create(notifications).Error
-}
-
-// GetEnabledTrafficReportByType 获取启用了指定类型报告的客户端配置
-func GetEnabledTrafficReportByType(daily, weekly, monthly bool) ([]models.TrafficReportNotification, error) {
-	db := dbcore.GetDBInstance()
-	var notifications []models.TrafficReportNotification
-	query := db.Model(&models.TrafficReportNotification{}).Where("enable = ?", true)
-	if daily {
-		query = query.Where("daily = ?", true)
-	} else if weekly {
-		query = query.Where("weekly = ?", true)
-	} else if monthly {
-		query = query.Where("monthly = ?", true)
-	}
-	err := query.Find(&notifications).Error
-	return notifications, err
-}
@@ -1,36 +0,0 @@
-package notification
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/komari-monitor/komari/database/models"
-)
-
-func TestValidateTrafficReportNotificationsRejectsEnabledWithoutCadence(t *testing.T) {
-	err := ValidateTrafficReportNotifications([]models.TrafficReportNotification{{
-		Client: "client-a",
-		Enable: true,
-	}})
-
-	assert.Error(t, err)
-}
-
-func TestBuildEnabledTrafficReportNotificationsRequiresExistingCadence(t *testing.T) {
-	_, err := buildEnabledTrafficReportNotifications([]string{"client-a"}, nil)
-	assert.Error(t, err)
-
-	_, err = buildEnabledTrafficReportNotifications([]string{"client-a"}, []models.TrafficReportNotification{{Client: "client-a"}})
-	assert.Error(t, err)
-
-	notifications, err := buildEnabledTrafficReportNotifications([]string{"client-a"}, []models.TrafficReportNotification{{
-		Client: "client-a",
-		Daily:  true,
-	}})
-	require.NoError(t, err)
-	require.Len(t, notifications, 1)
-	assert.Equal(t, "client-a", notifications[0].Client)
-	assert.True(t, notifications[0].Enable)
-}
@@ -5,15 +5,6 @@ import (
 	"github.com/komari-monitor/komari/database/models"
 )

-func GetAllOidcConfigs() []models.OidcProvider {
-	db := dbcore.GetDBInstance()
-	var result []models.OidcProvider
-	if err := db.Find(&result).Error; err != nil {
-		return nil
-	}
-	return result
-}
-
 func GetOidcConfigByName(name string) (*models.OidcProvider, error) {
 	db := dbcore.GetDBInstance()
 	var config models.OidcProvider
@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"

-	"github.com/komari-monitor/komari/database/metricstore"
+	"github.com/komari-monitor/komari/internal/metricstore"
 	"github.com/komari-monitor/komari/database/models"
 )

@@ -28,6 +28,11 @@ func GetRecordsByClientAndTime(uuid string, start, end time.Time) ([]models.Reco
 	return metricstore.GetRecordsByClientAndTime(context.Background(), uuid, start, end)
 }

+// GetRecordMetricMaxByClientAndTime 获取单项监控指标在各时间桶内的最大值。
+func GetRecordMetricMaxByClientAndTime(uuid, metricName string, start, end time.Time) ([]models.Record, error) {
+	return metricstore.GetRecordMetricMaxByClientAndTime(context.Background(), uuid, metricName, start, end)
+}
+
 // GetRecordsByTime 获取所有客户端在时间范围内的记录。
 func GetRecordsByTime(start, end time.Time) ([]models.Record, error) {
 	return metricstore.GetRecordsByTime(context.Background(), start, end)
@@ -2,11 +2,12 @@ package tasks

 import (
 	"context"
+	"sort"
 	"time"

 	"github.com/komari-monitor/komari/database/dbcore"
-	"github.com/komari-monitor/komari/database/metricstore"
 	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/internal/metricstore"
 	"github.com/komari-monitor/komari/utils"
 	"gorm.io/gorm"
 )
@@ -106,23 +107,42 @@ func GetAllPingTasks() ([]models.PingTask, error) {
 func GetPingTasksByClient(uuid string) []models.PingTask {
 	db := dbcore.GetDBInstance()
 	var tasks []models.PingTask
-	if err := db.Where("clients LIKE ?", `%"`+uuid+`"%`).Find(&tasks).Error; err != nil {
+	if err := db.Where("clients LIKE ?", `%"`+uuid+`"%`).Order("weight ASC").Order("id ASC").Find(&tasks).Error; err != nil {
 		return nil
 	}
 	return tasks
 }

 func UpdatePingTaskOrder(order map[uint]int) error {
+	if len(order) == 0 {
+		return nil
+	}
+
 	db := dbcore.GetDBInstance()
 	err := db.Transaction(func(tx *gorm.DB) error {
-		for id, weight := range order {
+		// Validate all ids before changing any weights. The update response is
+		// not a reliable existence check because some drivers report zero rows
+		// when the new value equals the current value.
+		ids := make([]uint, 0, len(order))
+		for id := range order {
+			ids = append(ids, id)
+		}
+		sort.Slice(ids, func(i, j int) bool { return ids[i] < ids[j] })
+
+		var existing int64
+		if err := tx.Model(&models.PingTask{}).Where("id IN ?", ids).Count(&existing).Error; err != nil {
+			return err
+		}
+		if existing != int64(len(ids)) {
+			return gorm.ErrRecordNotFound
+		}
+
+		for _, id := range ids {
+			weight := order[id]
 			result := tx.Model(&models.PingTask{}).Where("id = ?", id).Update("weight", weight)
 			if result.Error != nil {
 				return result.Error
 			}
-			if result.RowsAffected == 0 {
-				return gorm.ErrRecordNotFound
-			}
 		}
 		return nil
 	})
@@ -66,3 +66,55 @@ func TestGetAllPingTasksOrdersByWeightThenID(t *testing.T) {
 		t.Fatalf("ping task order = %#v, want ids [%d %d %d]", ordered, tasks[1].Id, tasks[2].Id, tasks[0].Id)
 	}
 }
+
+func TestUpdatePingTaskOrderAllowsUnchangedWeights(t *testing.T) {
+	flags.DatabaseType = flags.DatabaseTypeSQLite
+	flags.DatabaseFile = "file:ping_task_update_order?mode=memory&cache=shared"
+	db := dbcore.GetDBInstance()
+
+	items := []models.PingTask{
+		{Name: "first", Weight: 0, Type: "icmp", Target: "first.example", Interval: 60},
+		{Name: "second", Weight: 1, Type: "icmp", Target: "second.example", Interval: 60},
+	}
+	if err := db.Create(&items).Error; err != nil {
+		t.Fatalf("create ping tasks: %v", err)
+	}
+
+	if err := UpdatePingTaskOrder(map[uint]int{
+		items[0].Id: 0,
+		items[1].Id: 2,
+	}); err != nil {
+		t.Fatalf("update ping task order: %v", err)
+	}
+
+	var first, second models.PingTask
+	if err := db.First(&first, items[0].Id).Error; err != nil {
+		t.Fatalf("load first ping task: %v", err)
+	}
+	if err := db.First(&second, items[1].Id).Error; err != nil {
+		t.Fatalf("load second ping task: %v", err)
+	}
+	if first.Weight != 0 || second.Weight != 2 {
+		t.Fatalf("weights = [%d, %d], want [0, 2]", first.Weight, second.Weight)
+	}
+}
+
+func TestGetPingTasksByClientOrdersByWeightThenID(t *testing.T) {
+	flags.DatabaseType = flags.DatabaseTypeSQLite
+	flags.DatabaseFile = "file:ping_task_client_order?mode=memory&cache=shared"
+	db := dbcore.GetDBInstance()
+
+	items := []models.PingTask{
+		{Name: "third", Weight: 2, Clients: models.StringArray{"node-a"}, Type: "icmp", Target: "third.example", Interval: 60},
+		{Name: "first", Weight: 0, Clients: models.StringArray{"node-a"}, Type: "icmp", Target: "first.example", Interval: 60},
+		{Name: "other", Weight: 1, Clients: models.StringArray{"node-b"}, Type: "icmp", Target: "other.example", Interval: 60},
+	}
+	if err := db.Create(&items).Error; err != nil {
+		t.Fatalf("create ping tasks: %v", err)
+	}
+
+	ordered := GetPingTasksByClient("node-a")
+	if len(ordered) != 2 || ordered[0].Id != items[1].Id || ordered[1].Id != items[0].Id {
+		t.Fatalf("ping task order = %#v, want ids [%d %d]", ordered, items[1].Id, items[0].Id)
+	}
+}
@@ -3,16 +3,17 @@ package database
 import (
 	"context"
 	"encoding/json"
-	logger "github.com/komari-monitor/komari/utils/log"
 	"os"
 	"path/filepath"
-	"strings"

 	"github.com/gin-gonic/gin"
 	"github.com/komari-monitor/komari/database/dbcore"
-	"github.com/komari-monitor/komari/database/metricstore"
 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/internal/config"
+	"github.com/komari-monitor/komari/internal/managedconfig"
+	"github.com/komari-monitor/komari/internal/metricstore"
+	logger "github.com/komari-monitor/komari/utils/log"
+	"github.com/komari-monitor/komari/web/public"
 )

 func GetPublicInfo() (map[string]interface{}, error) {
@@ -69,58 +70,20 @@ func GetPublicInfo() (map[string]interface{}, error) {
 	if err != nil {
 		logger.Infof("database", "%v", err)
 	}
-	// Try to load theme declaration file and merge defaults for managed configuration
-	// Theme declarations live in ./data/theme/<short>/komari-theme.json
-	if cst.Theme != "" && cst.Theme != "default" {
-		themeConfigPath := filepath.Join("./data/theme", cst.Theme, "komari-theme.json")
-		if _, err := os.Stat(themeConfigPath); err == nil {
-			b, err := os.ReadFile(themeConfigPath)
-			if err == nil {
-				var themeDecl struct {
-					Configuration struct {
-						Type string                                 `json:"type"`
-						Data []models.ManagedThemeConfigurationItem `json:"data"`
-					} `json:"configuration"`
-				}
-				if err := json.Unmarshal(b, &themeDecl); err == nil {
-					if themeDecl.Configuration.Type == "managed" {
-						for _, item := range themeDecl.Configuration.Data {
-							if item.Key == "" {
-								continue
-							}
-							// missing
-							if _, exists := tc_data[item.Key]; !exists {
-								var def any = item.Default
-								// select
-								if item.Type == "select" {
-									if def == nil || def == "" {
-										if item.Options != "" {
-											opts := strings.Split(item.Options, ",")
-											if len(opts) > 0 {
-												def = strings.TrimSpace(opts[0])
-											}
-										}
-									}
-								}
-								// number->0, string->"", switch->false
-								if def == nil {
-									switch item.Type {
-									case "number":
-										def = 0
-									case "switch":
-										def = false
-									default:
-										def = ""
-									}
-								}
-								tc_data[item.Key] = def
-							}
-						}
-					}
-				}
+	items := themeConfigurationItems(cst.Theme)
+	if cst.Theme != "default" {
+		for _, item := range items {
+			if item.Key == "" {
+				continue
+			}
+			if _, exists := tc_data[item.Key]; !exists {
+				tc_data[item.Key] = managedconfig.DefaultValue(item)
 			}
 		}
 	}
+	if err := managedconfig.ResolveForOutput(tc_data, items); err != nil {
+		return nil, err
+	}

 	return gin.H{
 		"sitename":                  cst.Sitename,
@@ -140,3 +103,19 @@ func GetPublicInfo() (map[string]interface{}, error) {
 		"theme_settings":            tc_data,
 	}, nil
 }
+
+func themeConfigurationItems(short string) []models.ManagedThemeConfigurationItem {
+	var manifest models.Theme
+	if short == "default" {
+		data, err := public.PublicFS.ReadFile("defaultTheme/komari-theme.json")
+		if err != nil || json.Unmarshal(data, &manifest) != nil {
+			return nil
+		}
+	} else {
+		data, err := os.ReadFile(filepath.Join("./data/theme", short, "komari-theme.json"))
+		if err != nil || json.Unmarshal(data, &manifest) != nil {
+			return nil
+		}
+	}
+	return managedconfig.Items(manifest.Configuration)
+}
@@ -10,22 +10,23 @@ require (
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/websocket v1.5.3
 	github.com/jackc/pgx/v5 v5.10.0
+	github.com/klauspost/compress v1.17.11
 	github.com/mattn/go-sqlite3 v1.14.27
 	github.com/oschwald/maxminddb-golang v1.13.1
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/pquerna/otp v1.5.0
 	github.com/spf13/cobra v1.9.1
 	github.com/stretchr/testify v1.11.1
-	golang.org/x/image v0.35.0
+	golang.org/x/sys v0.33.0
 	gorm.io/driver/sqlite v1.5.7
 	gorm.io/gorm v1.26.1
 )

-require golang.org/x/sys v0.33.0 // indirect
+require github.com/dop251/base64dec v0.0.0-20231022112746-c6c9f9a96217 // indirect

 // Misuse of ServerConfig.PublicKeyCallback may cause authorization bypass in golang.org/x/crypto #1
 // golang.org/x/crypto Vulnerable to Denial of Service (DoS) via Slow or Incomplete Key Exchange #3
-require golang.org/x/crypto v0.39.0 // indirect
+require golang.org/x/crypto v0.39.0

 // HTTP Proxy bypass using IPv6 Zone IDs in golang.org/x/net #2
 // golang.org/x/net vulnerable to Cross-site Scripting #4
@@ -69,7 +70,7 @@ require (
 	github.com/ugorji/go/codec v1.2.12 // indirect
 	golang.org/x/arch v0.15.0 // indirect
 	golang.org/x/sync v0.19.0
-	golang.org/x/text v0.33.0 // indirect
+	golang.org/x/text v0.33.0
 	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
@@ -19,6 +19,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo=
 github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8=
+github.com/dop251/base64dec v0.0.0-20231022112746-c6c9f9a96217 h1:16iT9CBDOniJwFGPI41MbUDfEk74hFaKTqudrX8kenY=
+github.com/dop251/base64dec v0.0.0-20231022112746-c6c9f9a96217/go.mod h1:eIb+f24U+eWQCIsj9D/ah+MD9UP+wdxuqzsdLD+mhGM=
 github.com/dop251/goja v0.0.0-20251008123653-cf18d89f3cf6 h1:6dE1TmjqkY6tehR4A67gDNhvDtuZ54ocu7ab4K9o540=
 github.com/dop251/goja v0.0.0-20251008123653-cf18d89f3cf6/go.mod h1:MxLav0peU43GgvwVgNbLAj1s/bSGboKkhuULvq/7hx4=
 github.com/dop251/goja_nodejs v0.0.0-20251015164255-5e94316bedaf h1:gbmvliZnCut4NjaPSNOQlfqBoZ9C5Dpf72mHMMYhgVE=
@@ -68,6 +70,8 @@ github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
 github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
 github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
 github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
@@ -125,12 +129,12 @@ github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS
 github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
 github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
 github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/arch v0.15.0 h1:QtOrQd0bTUnhNVNndMpLHNWrDmYzZ2KDqSrEymqInZw=
 golang.org/x/arch v0.15.0/go.mod h1:JmwW7aLIoRUKgaTzhkiEFxvcEiQGyOg9BMonBJUS7EE=
 golang.org/x/crypto v0.39.0 h1:SHs+kF4LP+f+p14esP5jAoDpHU8Gu/v9lFRK6IT5imM=
 golang.org/x/crypto v0.39.0/go.mod h1:L+Xg3Wf6HoL4Bn4238Z6ft6KfEpN0tJGo53AAPC632U=
-golang.org/x/image v0.35.0 h1:LKjiHdgMtO8z7Fh18nGY6KDcoEtVfsgLDPeLyguqb7I=
-golang.org/x/image v0.35.0/go.mod h1:MwPLTVgvxSASsxdLzKrl8BRFuyqMyGhLwmC+TO1Sybk=
 golang.org/x/net v0.41.0 h1:vBTly1HeNPEn3wtREYfy4GZ/NECgw2Cnl+nK6Nz3uvw=
 golang.org/x/net v0.41.0/go.mod h1:B/K4NNqkfmg07DQYrbwvSluqCJOOXwUjeb/5lOisjbA=
 golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4=
@@ -17,6 +17,7 @@ type Settings struct {
 	ScriptDomain           string `json:"script_domain" default:""`                            // 自定义脚本域名
 	SendIpAddrToGuest      bool   `json:"send_ip_addr_to_guest" default:"false"`               // 是否向访客页面发送 IP 地址，默认 false
 	VisitorAuditEnabled    bool   `json:"visitor_audit_enabled" default:"false"`               // 是否允许公开访客事件写入审计日志，默认 false
+	SSRFProtectionEnabled  bool   `json:"ssrf_protection_enabled" default:"false"`             // 是否启用 SSRF 防护，默认关闭
 	EulaAccepted           bool   `json:"eula_accepted" default:"false"`
 	BaseScriptsURLKey      string `json:"base_scripts_url" default:""`
 	// GeoIP 配置
@@ -55,6 +56,7 @@ const (
 	ScriptDomainKey           = "script_domain"
 	SendIpAddrToGuestKey      = "send_ip_addr_to_guest"
 	VisitorAuditEnabledKey    = "visitor_audit_enabled"
+	SSRFProtectionEnabledKey  = "ssrf_protection_enabled"
 	EulaAcceptedKey           = "eula_accepted"
 	BaseScriptsURLKey         = "base_scripts_url"
 	GeoIpEnabledKey           = "geo_ip_enabled"
@@ -75,4 +77,5 @@ const (
 	UpdatedAtKey                  = "updated_at"
 	XtermjsSettingsKey            = "xtermjs_settings"
 	ThemeMarketSourcesKey         = "theme_market_sources"
+	PluginMarketSourcesKey        = "plugin_market_sources"
 )
@@ -0,0 +1,144 @@
+// Package managedconfig implements the shared managed-configuration behavior
+// used by themes and plugins.
+package managedconfig
+
+import (
+	"encoding/json"
+	"strings"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+)
+
+const (
+	TypeNodes     = "nodes"
+	TypePingTasks = "pingtasks"
+)
+
+// Items returns the declared managed configuration items. An omitted type is
+// managed, matching the theme configuration default.
+func Items(configuration models.Configuration) []models.ManagedThemeConfigurationItem {
+	if configuration.Type != "" && !strings.EqualFold(configuration.Type, models.ThemeConfigurationManaged) {
+		return nil
+	}
+	raw, err := json.Marshal(configuration.Data)
+	if err != nil {
+		return nil
+	}
+	var items []models.ManagedThemeConfigurationItem
+	if err := json.Unmarshal(raw, &items); err != nil {
+		return nil
+	}
+	return items
+}
+
+func DefaultValue(item models.ManagedThemeConfigurationItem) any {
+	value := item.Default
+	if item.Type == "select" && (value == nil || value == "") && item.Options != "" {
+		options := strings.Split(item.Options, ",")
+		if len(options) > 0 {
+			return strings.TrimSpace(options[0])
+		}
+	}
+	if value != nil {
+		return value
+	}
+	switch item.Type {
+	case "number":
+		return float64(0)
+	case "switch":
+		return false
+	case TypeNodes, TypePingTasks:
+		return "[]"
+	default:
+		return ""
+	}
+}
+
+// ResolveForOutput decodes declared selectors, drops deleted references, and
+// returns typed arrays suitable for public theme settings and plugin config.
+func ResolveForOutput(values map[string]any, items []models.ManagedThemeConfigurationItem) error {
+	hasNodes := false
+	hasPingTasks := false
+	for _, item := range items {
+		switch item.Type {
+		case TypeNodes:
+			hasNodes = true
+		case TypePingTasks:
+			hasPingTasks = true
+		}
+	}
+
+	db := dbcore.GetDBInstance()
+	liveNodes := map[string]struct{}{}
+	if hasNodes {
+		var nodes []models.Client
+		if err := db.Select("uuid").Find(&nodes).Error; err != nil {
+			return err
+		}
+		for _, node := range nodes {
+			liveNodes[node.UUID] = struct{}{}
+		}
+	}
+	livePingTasks := map[uint]struct{}{}
+	if hasPingTasks {
+		var tasks []models.PingTask
+		if err := db.Select("id").Find(&tasks).Error; err != nil {
+			return err
+		}
+		for _, task := range tasks {
+			livePingTasks[task.Id] = struct{}{}
+		}
+	}
+
+	for _, item := range items {
+		if item.Key == "" {
+			continue
+		}
+		switch item.Type {
+		case TypeNodes:
+			selected := NodeIDs(values[item.Key])
+			filtered := make([]string, 0, len(selected))
+			for _, id := range selected {
+				if _, ok := liveNodes[id]; ok {
+					filtered = append(filtered, id)
+				}
+			}
+			values[item.Key] = filtered
+		case TypePingTasks:
+			selected := PingTaskIDs(values[item.Key])
+			filtered := make([]uint, 0, len(selected))
+			for _, id := range selected {
+				if _, ok := livePingTasks[id]; ok {
+					filtered = append(filtered, id)
+				}
+			}
+			values[item.Key] = filtered
+		}
+	}
+	return nil
+}
+
+func NodeIDs(value any) []string {
+	raw, ok := value.(string)
+	if !ok {
+		return nil
+	}
+	var ids []string
+	if json.Unmarshal([]byte(raw), &ids) != nil {
+		return nil
+	}
+	return ids
+}
+
+func PingTaskIDs(value any) []uint {
+	raw, ok := value.(string)
+	if !ok {
+		return nil
+	}
+	var ids []uint
+	if json.Unmarshal([]byte(raw), &ids) != nil {
+		return nil
+	}
+	return ids
+}
@@ -0,0 +1,60 @@
+package metricstore
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+func Compact(ctx context.Context, now time.Time) (int, error) {
+	if !compactOperations.TryAcquire() {
+		return 0, ErrCompactInProgress
+	}
+	defer compactOperations.Release()
+	if err := storeOperations.AcquireShared(ctx); err != nil {
+		return 0, fmt.Errorf("wait for metric store operation before compaction: %w", err)
+	}
+	defer storeOperations.ReleaseShared()
+
+	storeMu.RLock()
+	defer storeMu.RUnlock()
+	activeStore := store
+	if activeStore == nil {
+		return 0, fmt.Errorf("metric store not initialized")
+	}
+	total, err := activeStore.Flush(ctx, now)
+	if err != nil {
+		return 0, fmt.Errorf("flush closed metric minutes: %w", err)
+	}
+	coarse, err := activeStore.FlushCoarse(ctx, now)
+	if err != nil {
+		return total, fmt.Errorf("seal closed metric rollups: %w", err)
+	}
+	return total + coarse, nil
+}
+
+// CleanupExpired applies retention in a separate, low-frequency operation.
+// It intentionally shares Compact's gate so delete-heavy maintenance never
+// overlaps minute or coarse-rollup persistence.
+func CleanupExpired(ctx context.Context, now time.Time) (int64, error) {
+	if !compactOperations.TryAcquire() {
+		return 0, ErrCompactInProgress
+	}
+	defer compactOperations.Release()
+	if err := storeOperations.AcquireShared(ctx); err != nil {
+		return 0, fmt.Errorf("wait for metric store operation before retention cleanup: %w", err)
+	}
+	defer storeOperations.ReleaseShared()
+
+	storeMu.RLock()
+	defer storeMu.RUnlock()
+	activeStore := store
+	if activeStore == nil {
+		return 0, fmt.Errorf("metric store not initialized")
+	}
+	deleted, err := activeStore.CleanupExpired(ctx, now)
+	if err != nil {
+		return deleted, fmt.Errorf("clean up expired metric data: %w", err)
+	}
+	return deleted, nil
+}
@@ -0,0 +1,323 @@
+package metricstore
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+const (
+	// DefaultRollupRawRetention documents the fixed in-memory exact-sample
+	// window. Samples older than one minute are losslessly byte-encoded;
+	// older history is served by the persisted rollup ladder.
+	DefaultRollupRawRetention = 10 * time.Minute
+	DefaultRollupFinestTier   = time.Minute
+	defaultRollupPointLimit   = 600
+
+	defaultRollupMinuteRetentionMinutes     = defaultRollupPointLimit
+	defaultRollupFiveMinuteRetentionMinutes = 5 * defaultRollupPointLimit
+	defaultRollupHourRetentionHours         = defaultRollupPointLimit
+	defaultRollupDayRetentionDays           = 100 * 365
+)
+
+// MetricStoreConfig 保存 metric store 配置。
+//
+// 注意：metric store 现在始终启用（旧的 metric_store_enabled 开关已废弃）。
+// 未显式配置时默认使用 SQLite（./data/metrics.db）。
+type MetricStoreConfig struct {
+	Driver       string `json:"metric_db_driver" default:"sqlite"`         // 数据库类型: sqlite, mysql, postgresql
+	DSN          string `json:"metric_db_dsn" default:"./data/metrics.db"` // 数据库连接串
+	TablePrefix  string `json:"metric_table_prefix" default:"metric_"`     // 表名前缀
+	MaxOpenConns int    `json:"metric_max_open_conns" default:"25"`        // 最大连接数
+	MaxIdleConns int    `json:"metric_max_idle_conns" default:"5"`         // 最大空闲连接数
+	// RollupMinuteRetentionMinutes controls the persisted 1-minute bucket window.
+	RollupMinuteRetentionMinutes int `json:"metric_rollup_minute_retention_minutes" default:"600"`
+	// RollupFiveMinuteRetentionMinutes controls the persisted 5-minute bucket window.
+	RollupFiveMinuteRetentionMinutes int `json:"metric_rollup_five_minute_retention_minutes" default:"3000"`
+	// RollupHourRetentionHours controls the persisted 1-hour bucket window.
+	RollupHourRetentionHours int `json:"metric_rollup_hour_retention_hours" default:"600"`
+}
+
+// MetricStoreConfigKeys 配置键
+const (
+	MetricDBDriverKey                         = "metric_db_driver"
+	MetricDBDSNKey                            = "metric_db_dsn"
+	MetricTablePrefixKey                      = "metric_table_prefix"
+	MetricMaxOpenConnsKey                     = "metric_max_open_conns"
+	MetricMaxIdleConnsKey                     = "metric_max_idle_conns"
+	MetricRollupMinuteRetentionMinutesKey     = "metric_rollup_minute_retention_minutes"
+	MetricRollupFiveMinuteRetentionMinutesKey = "metric_rollup_five_minute_retention_minutes"
+	MetricRollupHourRetentionHoursKey         = "metric_rollup_hour_retention_hours"
+	// MigrationTargetKey 记录上一次成功完成手动迁移的目标指纹（driver+dsn），
+	// 用于在下一次管理员手动迁移时推断默认源库。
+	MigrationTargetKey = "metric_migration_target"
+)
+
+func targetFingerprint(cfg *MetricStoreConfig) string {
+	driver := ResolveDriverFromConfig(cfg.Driver, cfg.DSN)
+	dsn := strings.TrimSpace(cfg.DSN)
+	return fmt.Sprintf("%s|%s", driver, dsn)
+}
+
+// buildMetricConfig 根据 MetricStoreConfig 构造底层 metric.Config。
+// autoMigrate 控制是否在 Open 时自动建表：正式初始化/热加载时为 true，
+// 仅做连接测试时为 false（不写入 schema，避免对目标库产生副作用）。
+func buildMetricConfig(cfg *MetricStoreConfig, autoMigrate bool) (metric.Config, error) {
+	if cfg == nil {
+		return metric.Config{}, fmt.Errorf("metric store config is nil")
+	}
+	driver := ResolveDriverFromConfig(cfg.Driver, cfg.DSN)
+
+	tablePrefix := cfg.TablePrefix
+	if tablePrefix == "" {
+		tablePrefix = "metric_"
+	}
+	opts := []metric.Option{
+		metric.WithTablePrefix(tablePrefix),
+		metric.WithAutoMigrate(autoMigrate),
+	}
+	policy, err := rollupPolicyFromConfig(cfg)
+	if err != nil {
+		return metric.Config{}, err
+	}
+	opts = append(opts, metric.WithRollupPolicy(policy))
+
+	switch driver {
+	case metric.DriverSQLite:
+		dsn := cfg.DSN
+		if dsn == "" || dsn == "./data/metrics.db" {
+			// 注意：刻意不使用 cache=shared。SQLite 共享缓存模式使用表级锁，
+			// 当一个连接持有读锁、另一个连接尝试写入时会立即返回
+			// SQLITE_LOCKED（"database table is locked"），且 busy_timeout
+			// 对共享缓存的表级锁无效，迁移期间与前台查询/实时写入并发时必然报错。
+			// _txlock=immediate 让写事务开始即获取写锁，避免锁升级死锁。
+			dsn = "file:./data/metrics.db?mode=rwc&_txlock=immediate"
+		} else {
+			// 用户自定义 DSN 时，剥离 cache=shared，避免上述表级锁问题。
+			dsn = stripSharedCache(dsn)
+		}
+		// SQLite 串行化写入：固定单写连接以避免 "database is locked" 竞争，
+		// 同时启用独立的 WAL 只读连接池提升前台查询并发（写仍走单主连接）。
+		// 这里刻意忽略 cfg.MaxOpenConns/MaxIdleConns —— 对 SQLite 而言多写连接
+		// 只会引入锁竞争而非提升吞吐。
+		opts = append(opts, metric.WithMaxOpenConns(1), metric.WithMaxIdleConns(1))
+		opts = append(opts, metric.WithSQLiteReadPool(2))
+		return metric.SQLite(dsn, opts...), nil
+	case metric.DriverMySQL:
+		opts = append(opts,
+			metric.WithMaxOpenConns(cfg.MaxOpenConns),
+			metric.WithMaxIdleConns(cfg.MaxIdleConns),
+		)
+		return metric.MySQL(cfg.DSN, opts...), nil
+	case metric.DriverPostgreSQL:
+		opts = append(opts,
+			metric.WithMaxOpenConns(cfg.MaxOpenConns),
+			metric.WithMaxIdleConns(cfg.MaxIdleConns),
+		)
+		return metric.PostgreSQL(cfg.DSN, opts...), nil
+	default:
+		return metric.Config{}, fmt.Errorf("unsupported metric database driver: %s", cfg.Driver)
+	}
+}
+
+func defaultRollupPolicy() metric.RollupPolicy {
+	return rollupPolicyFromValues(
+		defaultRollupMinuteRetentionMinutes,
+		defaultRollupFiveMinuteRetentionMinutes,
+		defaultRollupHourRetentionHours,
+	)
+}
+
+func rollupPolicyFromConfig(cfg *MetricStoreConfig) (metric.RollupPolicy, error) {
+	if cfg == nil {
+		return metric.RollupPolicy{}, fmt.Errorf("metric store config is nil")
+	}
+
+	minuteRetention := cfg.RollupMinuteRetentionMinutes
+	fiveMinuteRetention := cfg.RollupFiveMinuteRetentionMinutes
+	hourRetention := cfg.RollupHourRetentionHours
+	// Configs constructed by older callers do not have the new fields. Treat
+	// their zero values as omitted so recovery and migration remain compatible.
+	if minuteRetention == 0 {
+		minuteRetention = defaultRollupMinuteRetentionMinutes
+	}
+	if fiveMinuteRetention == 0 {
+		fiveMinuteRetention = defaultRollupFiveMinuteRetentionMinutes
+	}
+	if hourRetention == 0 {
+		hourRetention = defaultRollupHourRetentionHours
+	}
+	if minuteRetention < 0 || fiveMinuteRetention < 0 || hourRetention < 0 {
+		return metric.RollupPolicy{}, fmt.Errorf("metric rollup retention values must be positive integers")
+	}
+
+	minuteDuration, err := rollupDuration(minuteRetention, time.Minute)
+	if err != nil {
+		return metric.RollupPolicy{}, err
+	}
+	fiveMinuteDuration, err := rollupDuration(fiveMinuteRetention, time.Minute)
+	if err != nil {
+		return metric.RollupPolicy{}, err
+	}
+	hourDuration, err := rollupDuration(hourRetention, time.Hour)
+	if err != nil {
+		return metric.RollupPolicy{}, err
+	}
+
+	policy := rollupPolicyFromDurations(minuteDuration, fiveMinuteDuration, hourDuration)
+	if err := policy.Validate(); err != nil {
+		return metric.RollupPolicy{}, fmt.Errorf("invalid metric rollup retention policy: %w", err)
+	}
+	return policy, nil
+}
+
+func rollupPolicyFromValues(minuteRetentionMinutes, fiveMinuteRetentionMinutes, hourRetentionHours int) metric.RollupPolicy {
+	return rollupPolicyFromDurations(
+		time.Duration(minuteRetentionMinutes)*time.Minute,
+		time.Duration(fiveMinuteRetentionMinutes)*time.Minute,
+		time.Duration(hourRetentionHours)*time.Hour,
+	)
+}
+
+func rollupPolicyFromDurations(minuteRetention, fiveMinuteRetention, hourRetention time.Duration) metric.RollupPolicy {
+	return metric.RollupPolicy{
+		RawRetention: DefaultRollupRawRetention,
+		Tiers: []metric.RollupTier{
+			{Interval: time.Minute, Retention: minuteRetention},
+			{Interval: 5 * time.Minute, Retention: fiveMinuteRetention},
+			{Interval: time.Hour, Retention: hourRetention},
+			// Daily buckets form the terminal tier. They remain available until
+			// the metric's own retention policy removes them.
+			{Interval: 24 * time.Hour, Retention: time.Duration(defaultRollupDayRetentionDays) * 24 * time.Hour},
+		},
+		Compression: 30,
+	}
+}
+
+func rollupDuration(value int, unit time.Duration) (time.Duration, error) {
+	maxDurationValue := int64((time.Duration(1<<63 - 1)) / unit)
+	if value <= 0 || int64(value) > maxDurationValue {
+		return 0, fmt.Errorf("metric rollup retention value must be a positive duration")
+	}
+	return time.Duration(value) * unit, nil
+}
+
+// ResolveDriverFromConfig 根据 DSN 自动推断 metrics 数据库类型；当 DSN 不能可靠
+// 识别时回退到旧配置中的 driver，以兼容已有配置和非常规 DSN。
+func ResolveDriverFromConfig(configuredDriver, dsn string) metric.Driver {
+	if driver, ok := InferDriverFromDSN(dsn); ok {
+		return driver
+	}
+
+	switch driver := metric.Driver(strings.ToLower(strings.TrimSpace(configuredDriver))); driver {
+	case metric.DriverSQLite, metric.DriverMySQL, metric.DriverPostgreSQL:
+		return driver
+	default:
+		return metric.DriverSQLite
+	}
+}
+
+// InferDriverFromDSN 尽量根据常见 DSN 格式推断数据库类型。
+// 返回 ok=false 表示格式不够明确，调用方应使用已有配置作为兜底。
+func InferDriverFromDSN(dsn string) (metric.Driver, bool) {
+	raw := strings.TrimSpace(dsn)
+	if raw == "" {
+		return metric.DriverSQLite, true
+	}
+	lower := strings.ToLower(raw)
+
+	// PostgreSQL URL DSN: postgres://... 或 postgresql://...
+	if strings.HasPrefix(lower, "postgres://") || strings.HasPrefix(lower, "postgresql://") {
+		return metric.DriverPostgreSQL, true
+	}
+
+	// SQLite 常见文件/内存 DSN。
+	if raw == ":memory:" || strings.HasPrefix(lower, "file:") || strings.HasPrefix(lower, "sqlite://") || strings.HasPrefix(lower, "sqlite3://") {
+		return metric.DriverSQLite, true
+	}
+
+	// MySQL URL（虽然 go-sql-driver/mysql 原生 DSN 通常不是 URL，但这里用于给出
+	// 类型推断；连接测试仍会校验 DSN 是否可被驱动接受）。
+	if strings.HasPrefix(lower, "mysql://") {
+		return metric.DriverMySQL, true
+	}
+
+	// PostgreSQL 关键字/值 DSN: host=... user=... dbname=...
+	if looksLikePostgreSQLKeyValueDSN(lower) {
+		return metric.DriverPostgreSQL, true
+	}
+
+	// go-sql-driver/mysql DSN: user:pass@tcp(host:3306)/db、user@unix(...)/db、user:pass@/db 等。
+	if looksLikeMySQLDSN(lower) {
+		return metric.DriverMySQL, true
+	}
+
+	// SQLite 路径：./data/metrics.db、/var/lib/metrics.sqlite3、metrics.sqlite 等。
+	if looksLikeSQLitePath(lower) {
+		return metric.DriverSQLite, true
+	}
+
+	return "", false
+}
+
+func looksLikePostgreSQLKeyValueDSN(lower string) bool {
+	if !strings.Contains(lower, "=") || strings.Contains(lower, "://") {
+		return false
+	}
+	keys := []string{"host=", "user=", "password=", "dbname=", "port=", "sslmode="}
+	matched := 0
+	for _, key := range keys {
+		if strings.Contains(lower, key) {
+			matched++
+		}
+	}
+	// dbname= 基本是 PostgreSQL libpq DSN 的强特征；否则至少匹配两个常见键。
+	return strings.Contains(lower, "dbname=") || matched >= 2
+}
+
+func looksLikeMySQLDSN(lower string) bool {
+	if strings.Contains(lower, "://") || strings.Contains(lower, " ") {
+		return false
+	}
+	if strings.Contains(lower, "@tcp(") || strings.Contains(lower, "@unix(") || strings.Contains(lower, "@/") {
+		return true
+	}
+	// user:pass@host/db、user@host/db 这类虽然不是推荐格式，但也明显偏 MySQL。
+	return strings.Contains(lower, "@") && strings.Contains(lower, "/")
+}
+
+func looksLikeSQLitePath(lower string) bool {
+	path := lower
+	if idx := strings.IndexAny(path, "?"); idx >= 0 {
+		path = path[:idx]
+	}
+	return strings.HasSuffix(path, ".db") || strings.HasSuffix(path, ".sqlite") || strings.HasSuffix(path, ".sqlite3")
+}
+
+// stripSharedCache 从 SQLite DSN 中移除 cache=shared 参数，避免共享缓存模式下的
+// 表级锁（SQLITE_LOCKED "database table is locked"）。其它参数保持不变。
+func stripSharedCache(dsn string) string {
+	if !strings.Contains(dsn, "cache=shared") {
+		return dsn
+	}
+	idx := strings.Index(dsn, "?")
+	if idx < 0 {
+		return dsn
+	}
+	base := dsn[:idx]
+	query := dsn[idx+1:]
+	parts := strings.Split(query, "&")
+	kept := parts[:0]
+	for _, p := range parts {
+		if p == "cache=shared" {
+			continue
+		}
+		kept = append(kept, p)
+	}
+	if len(kept) == 0 {
+		return base
+	}
+	return base + "?" + strings.Join(kept, "&")
+}
@@ -0,0 +1,104 @@
+package metricstore
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+const defaultBuiltinMetricRetentionDays = 1
+
+// RetentionSummary is the compatibility view of all persisted metric policies.
+type RetentionSummary struct {
+	AllPositive bool
+	MaxDays     int
+}
+
+// GetRetentionSummary aggregates the active store's metric definitions. An
+// empty definition set is not considered record-enabled.
+func GetRetentionSummary(ctx context.Context) (RetentionSummary, error) {
+	s := GetStore()
+	if s == nil {
+		return RetentionSummary{}, fmt.Errorf("metric store not initialized")
+	}
+	defs, err := s.ListMetrics(ctx)
+	if err != nil {
+		return RetentionSummary{}, err
+	}
+	return summarizeRetentionDefinitions(defs), nil
+}
+
+func summarizeRetentionDefinitions(defs []metric.Definition) RetentionSummary {
+	if len(defs) == 0 {
+		return RetentionSummary{}
+	}
+	summary := RetentionSummary{AllPositive: true}
+	for _, def := range defs {
+		if def.RetentionDays <= 0 {
+			summary.AllPositive = false
+		}
+		if def.RetentionDays > summary.MaxDays {
+			summary.MaxDays = def.RetentionDays
+		}
+	}
+	return summary
+}
+
+// createMetricDefinitions creates built-in definitions with explicit policies.
+func createMetricDefinitions(ctx context.Context, s *metric.Store) error {
+	return createMetricDefinitionsWithDefaultRetention(ctx, s, defaultBuiltinMetricRetentionDays)
+}
+
+// EnsureBuiltinMetricDefinitions registers definitions for the server's
+// built-in report and ping writers before a standalone Store receives points.
+func EnsureBuiltinMetricDefinitions(ctx context.Context, s *metric.Store) error {
+	return createMetricDefinitions(ctx, s)
+}
+
+func createMetricDefinitionsWithDefaultRetention(ctx context.Context, s *metric.Store, defaultRetentionDays int) error {
+	if defaultRetentionDays < defaultBuiltinMetricRetentionDays {
+		defaultRetentionDays = defaultBuiltinMetricRetentionDays
+	}
+	definitions := []metric.Definition{
+		{Name: MetricCPU, Type: metric.TypeGauge, Unit: "%", Description: "CPU usage percentage", RetentionDays: defaultRetentionDays},
+		{Name: MetricGPU, Type: metric.TypeGauge, Unit: "%", Description: "GPU usage percentage", RetentionDays: defaultRetentionDays},
+		{Name: MetricGPUDeviceUsage, Type: metric.TypeGauge, Unit: "%", Description: "Per-device GPU utilization", RetentionDays: defaultRetentionDays},
+		{Name: MetricGPUMem, Type: metric.TypeGauge, Unit: "bytes", Description: "GPU memory used", RetentionDays: defaultRetentionDays},
+		{Name: MetricGPUMemTotal, Type: metric.TypeGauge, Unit: "bytes", Description: "GPU memory total", RetentionDays: defaultRetentionDays},
+		{Name: MetricGPUTemp, Type: metric.TypeGauge, Unit: "°C", Description: "GPU temperature", RetentionDays: defaultRetentionDays},
+		{Name: MetricRAM, Type: metric.TypeGauge, Unit: "bytes", Description: "RAM used", RetentionDays: defaultRetentionDays},
+		{Name: MetricSwap, Type: metric.TypeGauge, Unit: "bytes", Description: "Swap used", RetentionDays: defaultRetentionDays},
+		{Name: MetricLoad, Type: metric.TypeGauge, Unit: "", Description: "System load average", RetentionDays: defaultRetentionDays},
+		{Name: MetricDisk, Type: metric.TypeGauge, Unit: "bytes", Description: "Disk used", RetentionDays: defaultRetentionDays},
+		{Name: MetricNetIn, Type: metric.TypeGauge, Unit: "bytes/s", Description: "Network in rate", RetentionDays: defaultRetentionDays},
+		{Name: MetricNetOut, Type: metric.TypeGauge, Unit: "bytes/s", Description: "Network out rate", RetentionDays: defaultRetentionDays},
+		{Name: MetricNetTotalUp, Type: metric.TypeCounter, Unit: "bytes", Description: "Network total upload", RetentionDays: defaultRetentionDays},
+		{Name: MetricNetTotalDown, Type: metric.TypeCounter, Unit: "bytes", Description: "Network total download", RetentionDays: defaultRetentionDays},
+		{Name: MetricTrafficUp, Type: metric.TypeGauge, Unit: "bytes", Description: "Traffic upload delta", RetentionDays: defaultRetentionDays},
+		{Name: MetricTrafficDown, Type: metric.TypeGauge, Unit: "bytes", Description: "Traffic download delta", RetentionDays: defaultRetentionDays},
+		{Name: MetricProcess, Type: metric.TypeGauge, Unit: "count", Description: "Process count", RetentionDays: defaultRetentionDays},
+		{Name: MetricConnections, Type: metric.TypeGauge, Unit: "count", Description: "TCP connections", RetentionDays: defaultRetentionDays},
+		{Name: MetricConnectionsUDP, Type: metric.TypeGauge, Unit: "count", Description: "UDP connections", RetentionDays: defaultRetentionDays},
+		{Name: MetricPingLatency, Type: metric.TypeGauge, Unit: "ms", Description: "Ping latency", RetentionDays: defaultRetentionDays},
+		{Name: MetricPingLoss, Type: metric.TypeGauge, Unit: "ratio", Description: "Ping packet loss indicator", RetentionDays: defaultRetentionDays},
+	}
+
+	for _, def := range definitions {
+		existing, err := s.GetMetric(ctx, def.Name)
+		if err != nil && !errors.Is(err, metric.ErrNotFound) {
+			return fmt.Errorf("failed to get metric %s: %w", def.Name, err)
+		}
+		if err == nil {
+			if existing.RetentionDays == 0 {
+				continue
+			}
+			def.RetentionDays = existing.RetentionDays
+		}
+		if err := s.UpsertMetric(ctx, def); err != nil {
+			return fmt.Errorf("failed to create metric %s: %w", def.Name, err)
+		}
+	}
+	return nil
+}
@@ -0,0 +1,104 @@
+package metricstore
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	logger "github.com/komari-monitor/komari/utils/log"
+
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+// farFuture 返回一个足够远的未来时间，用于以 DeleteBefore 语义清空某指标的全部数据。
+func farFuture() time.Time {
+	return time.Now().UTC().Add(24 * 365 * time.Hour)
+}
+
+// DeleteAllRecords 删除所有负载/系统类记录（保留指标定义，不含 ping）。
+func DeleteAllRecords(ctx context.Context) error {
+	s := GetStore()
+	if s == nil {
+		return fmt.Errorf("metric store not enabled")
+	}
+
+	for _, metricName := range recordMetricNames {
+		if _, err := s.DeleteBefore(ctx, metricName, farFuture()); err != nil {
+			logger.Errorf("metricstore", "Failed to delete metric %s: %v", metricName, err)
+		}
+	}
+	clearReportTrafficStates()
+
+	return nil
+}
+
+// DeleteAllPingRecords 删除全部 ping 记录（保留指标定义）。
+func DeleteAllPingRecords(ctx context.Context) error {
+	s := GetStore()
+	if s == nil {
+		return fmt.Errorf("metric store not enabled")
+	}
+	for _, metricName := range pingMetricNames {
+		if _, err := s.DeleteBefore(ctx, metricName, farFuture()); err != nil {
+			return fmt.Errorf("failed to delete ping records: %w", err)
+		}
+	}
+	return nil
+}
+
+// DeletePingRecordsByTask 删除指定任务（task_id）的全部 ping 记录。
+func DeletePingRecordsByTask(ctx context.Context, taskIDs []uint) error {
+	s := GetStore()
+	if s == nil {
+		return fmt.Errorf("metric store not enabled")
+	}
+	for _, id := range taskIDs {
+		for _, metricName := range pingMetricNames {
+			if _, err := s.DeleteSeries(ctx, metric.Query{
+				MetricName: metricName,
+				Tags:       map[string]string{"task_id": fmt.Sprintf("%d", id)},
+			}); err != nil {
+				return fmt.Errorf("failed to delete ping records for task %d: %w", id, err)
+			}
+		}
+	}
+	return nil
+}
+
+// DeleteEntity 删除指定 agent 在所有指标下的历史数据。
+func DeleteEntity(ctx context.Context, entityID string) error {
+	s := GetStore()
+	if s == nil {
+		return fmt.Errorf("metric store not enabled")
+	}
+	if _, err := s.DeleteEntity(ctx, entityID); err != nil {
+		return fmt.Errorf("failed to delete metric records for entity %s: %w", entityID, err)
+	}
+	deleteReportTrafficState(entityID)
+	return nil
+}
+
+// DeleteEntityAsync clears one agent's metric history without delaying the
+// client deletion response.
+func DeleteEntityAsync(entityID string) {
+	go func() {
+		if err := DeleteEntity(context.Background(), entityID); err != nil {
+			logger.Errorf("metricstore", "Failed to delete metric records for entity %s: %v", entityID, err)
+		}
+	}()
+}
+
+// DeleteMetricDataAsync clears disabled metric history without delaying an
+// admin retention-policy update response.
+func DeleteMetricDataAsync(metricName string) {
+	go func() {
+		s := GetStore()
+		if s == nil {
+			logger.Errorf("metricstore", "Failed to delete disabled metric %s: metric store not enabled", metricName)
+			return
+		}
+		if _, err := s.DeleteMetricDataIfDisabled(context.Background(), metricName); err != nil {
+			logger.Errorf("metricstore", "Failed to delete disabled metric %s: %v", metricName, err)
+		}
+	}()
+}
@@ -0,0 +1,313 @@
+package metricstore
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+// GetRecordsByClientAndTime 从 metric store 查询记录并重构为 models.Record
+func GetRecordsByClientAndTime(ctx context.Context, clientUUID string, start, end time.Time) ([]models.Record, error) {
+	s := GetStore()
+	if s == nil {
+		return nil, fmt.Errorf("metric store not enabled")
+	}
+
+	return getRecordsByClientAndTimeFromSeries(ctx, s, clientUUID, start, end)
+}
+
+// GetRecordMetricMaxByClientAndTime 查询单项监控指标在各时间桶内的最大值。
+func GetRecordMetricMaxByClientAndTime(ctx context.Context, clientUUID, recordMetric string, start, end time.Time) ([]models.Record, error) {
+	s := GetStore()
+	if s == nil {
+		return nil, fmt.Errorf("metric store not enabled")
+	}
+
+	return getRecordMetricMaxByClientAndTimeFromSeries(ctx, s, clientUUID, recordMetric, start, end)
+}
+
+// GetRecordsByTime 从 metric store 查询所有客户端在时间范围内的记录
+func GetRecordsByTime(ctx context.Context, start, end time.Time) ([]models.Record, error) {
+	s := GetStore()
+	if s == nil {
+		return nil, fmt.Errorf("metric store not enabled")
+	}
+
+	interval := recordSeriesInterval(s, start, end, time.Now().UTC())
+	entityIDs, err := listRecordEntityIDs(ctx, s, start, end, interval)
+	if err != nil {
+		return nil, err
+	}
+	var records []models.Record
+	for _, entityID := range entityIDs {
+		items, err := getRecordsByClientAndTimeFromSeries(ctx, s, entityID, start, end)
+		if err != nil {
+			return nil, err
+		}
+		records = append(records, items...)
+	}
+	sortRecords(records)
+	return records, nil
+}
+
+type recordSeriesKey struct {
+	client string
+	ts     int64
+}
+
+func getRecordsByClientAndTimeFromSeries(ctx context.Context, s *metric.Store, clientUUID string, start, end time.Time) ([]models.Record, error) {
+	now := time.Now().UTC()
+	interval := recordSeriesInterval(s, start, end, now)
+	recordMap := make(map[recordSeriesKey]*models.Record)
+
+	for _, metricName := range loadRecordMetricNames {
+		points, err := s.Series(ctx, metric.AggregateQuery{
+			Query: metric.Query{
+				MetricName: metricName,
+				EntityID:   clientUUID,
+				Start:      start,
+				End:        end,
+				Order:      metric.OrderAsc,
+			},
+			Aggregation: recordMetricAggregation(metricName),
+			Interval:    interval,
+		}, now)
+		if err != nil {
+			return nil, fmt.Errorf("failed to query metric %s: %w", metricName, err)
+		}
+		for _, point := range points {
+			entityID := point.EntityID
+			if entityID == "" {
+				entityID = clientUUID
+			}
+			key := recordSeriesKey{client: entityID, ts: point.Bucket.Unix()}
+			if recordMap[key] == nil {
+				recordMap[key] = &models.Record{
+					Client: entityID,
+					Time:   point.Bucket.UTC(),
+				}
+			}
+			applyRecordMetricValue(recordMap[key], metricName, point.Value)
+		}
+	}
+
+	records := make([]models.Record, 0, len(recordMap))
+	for _, rec := range recordMap {
+		records = append(records, *rec)
+	}
+	sortRecords(records)
+	return records, nil
+}
+
+func getRecordMetricMaxByClientAndTimeFromSeries(ctx context.Context, s *metric.Store, clientUUID, recordMetric string, start, end time.Time) ([]models.Record, error) {
+	metricName, ok := metricNameForRecordField(recordMetric)
+	if !ok {
+		return nil, fmt.Errorf("unsupported record metric %q", recordMetric)
+	}
+
+	now := time.Now().UTC()
+	points, err := s.Series(ctx, metric.AggregateQuery{
+		Query: metric.Query{
+			MetricName: metricName,
+			EntityID:   clientUUID,
+			Start:      start,
+			End:        end,
+			Order:      metric.OrderAsc,
+		},
+		Aggregation: metric.AggMax,
+		Interval:    recordSeriesInterval(s, start, end, now),
+	}, now)
+	if err != nil {
+		return nil, fmt.Errorf("failed to query metric %s: %w", metricName, err)
+	}
+
+	records := make([]models.Record, 0, len(points))
+	for _, point := range points {
+		entityID := point.EntityID
+		if entityID == "" {
+			entityID = clientUUID
+		}
+		record := models.Record{Client: entityID, Time: point.Bucket.UTC()}
+		applyRecordMetricValue(&record, metricName, point.Value)
+		records = append(records, record)
+	}
+	return records, nil
+}
+
+func recordMetricAggregation(metricName string) metric.Aggregation {
+	switch metricName {
+	case MetricTrafficUp, MetricTrafficDown:
+		return metric.AggSum
+	case MetricNetTotalUp, MetricNetTotalDown:
+		return metric.AggLast
+	default:
+		return metric.AggAvg
+	}
+}
+
+func recordSeriesInterval(s *metric.Store, start, end, now time.Time) time.Duration {
+	interval := recordDownsampleInterval(end.Sub(start), 500)
+	return s.CompatibleSeriesInterval(start, now, interval)
+}
+
+func recordDownsampleInterval(rangeDuration time.Duration, maxPoints int) time.Duration {
+	if maxPoints <= 0 {
+		maxPoints = 500
+	}
+	nanos := rangeDuration.Nanoseconds()
+	if nanos <= 0 {
+		return time.Second
+	}
+	interval := time.Duration((nanos + int64(maxPoints) - 1) / int64(maxPoints))
+	if interval < time.Second {
+		return time.Second
+	}
+	return metric.FloorStandardInterval(interval)
+}
+
+func listRecordEntityIDs(ctx context.Context, s *metric.Store, start, end time.Time, interval time.Duration) ([]string, error) {
+	seen := make(map[string]struct{})
+	for _, metricName := range loadRecordMetricNames {
+		ids, err := s.EntityIDs(ctx, metric.Query{
+			MetricName: metricName,
+			Start:      start.Add(-interval),
+			End:        end,
+		})
+		if err != nil {
+			return nil, err
+		}
+		for _, id := range ids {
+			seen[id] = struct{}{}
+		}
+	}
+	out := make([]string, 0, len(seen))
+	for id := range seen {
+		out = append(out, id)
+	}
+	sort.Strings(out)
+	return out, nil
+}
+
+func applyRecordMetricValue(rec *models.Record, metricName string, value float64) {
+	switch metricName {
+	case MetricCPU:
+		rec.Cpu = float32(value)
+	case MetricGPU:
+		rec.Gpu = float32(value)
+	case MetricRAM:
+		rec.Ram = int64(value)
+	case MetricSwap:
+		rec.Swap = int64(value)
+	case MetricLoad:
+		rec.Load = float32(value)
+	case MetricDisk:
+		rec.Disk = int64(value)
+	case MetricNetIn:
+		rec.NetIn = int64(value)
+	case MetricNetOut:
+		rec.NetOut = int64(value)
+	case MetricNetTotalUp:
+		rec.NetTotalUp = int64(value)
+	case MetricNetTotalDown:
+		rec.NetTotalDown = int64(value)
+	case MetricTrafficUp:
+		rec.TrafficUp = int64(value)
+	case MetricTrafficDown:
+		rec.TrafficDown = int64(value)
+	case MetricProcess:
+		rec.Process = int(value)
+	case MetricConnections:
+		rec.Connections = int(value)
+	case MetricConnectionsUDP:
+		rec.ConnectionsUdp = int(value)
+	}
+}
+
+func sortRecords(records []models.Record) {
+	sort.Slice(records, func(i, j int) bool {
+		if records[i].Client != records[j].Client {
+			return records[i].Client < records[j].Client
+		}
+		return records[i].Time.Before(records[j].Time)
+	})
+}
+
+// GetGPURecordsByClientAndTime 从 metric store 查询 GPU 记录
+func GetGPURecordsByClientAndTime(ctx context.Context, clientUUID string, start, end time.Time) ([]models.GPURecord, error) {
+	s := GetStore()
+	if s == nil {
+		return nil, fmt.Errorf("metric store not enabled")
+	}
+
+	// 查询 GPU 相关指标（每设备利用率使用独立指标 gpu.device.usage）
+	gpuMetrics := []string{MetricGPUDeviceUsage, MetricGPUMem, MetricGPUMemTotal, MetricGPUTemp}
+
+	// 按设备索引和时间组织数据
+	type gpuKey struct {
+		deviceIndex int
+		timestamp   int64
+	}
+	recordMap := make(map[gpuKey]*models.GPURecord)
+
+	for _, metricName := range gpuMetrics {
+		points, err := s.Query(ctx, metric.Query{
+			MetricName: metricName,
+			EntityID:   clientUUID,
+			Start:      start,
+			End:        end,
+			Order:      metric.OrderAsc,
+		})
+		if err != nil {
+			continue // GPU 数据可能不存在
+		}
+
+		for _, p := range points {
+			deviceIndex := 0
+			deviceName := ""
+			if idx, ok := p.Tags["device_index"]; ok {
+				fmt.Sscanf(idx, "%d", &deviceIndex)
+			}
+			if name, ok := p.Tags["device_name"]; ok {
+				deviceName = name
+			}
+
+			key := gpuKey{deviceIndex: deviceIndex, timestamp: p.Timestamp.Unix()}
+			if recordMap[key] == nil {
+				recordMap[key] = &models.GPURecord{
+					Client:      clientUUID,
+					Time:        p.Timestamp.UTC(),
+					DeviceIndex: deviceIndex,
+					DeviceName:  deviceName,
+				}
+			}
+			rec := recordMap[key]
+
+			switch metricName {
+			case MetricGPUDeviceUsage:
+				rec.Utilization = float32(p.Value)
+			case MetricGPUMem:
+				rec.MemUsed = int64(p.Value)
+			case MetricGPUMemTotal:
+				rec.MemTotal = int64(p.Value)
+			case MetricGPUTemp:
+				rec.Temperature = int(p.Value)
+			}
+		}
+	}
+
+	// 转换为切片
+	records := make([]models.GPURecord, 0, len(recordMap))
+	for _, rec := range recordMap {
+		records = append(records, *rec)
+	}
+
+	return records, nil
+}
+
+// GetPingRecords 从 metric store 查询兼容旧接口的 ping 记录。
+//
+// 旧接口过去直接读取 ping_records。这里使用与 queryMetrics 相同的 Series
@@ -62,18 +62,12 @@ func InspectStorage(ctx context.Context) (StorageInfo, error) {
 // It takes the exclusive operation lock, so a table/file rewrite cannot run
 // concurrently with report writes or compaction.
 func ReclaimSpace(ctx context.Context) (MaintenanceResult, error) {
-	if !storeOperations.TryAcquire() {
-		storeMu.RLock()
-		defer storeMu.RUnlock()
-		if store == nil {
-			return MaintenanceResult{}, ErrStoreNotInitialized
-		}
-		return MaintenanceResult{
-			Driver:          store.Driver(),
-			Action:          store.MaintenanceAction(),
-			BeforeSizeError: ErrStoreBusy,
-			AfterSizeError:  ErrStoreBusy,
-		}, ErrStoreBusy
+	// Reclamation is intentionally non-cancellable. It waits for all active
+	// operations, then keeps the store gate until digest conversion, VACUUM,
+	// and the final checkpoint have completed.
+	_ = ctx
+	if err := storeOperations.Acquire(context.Background()); err != nil {
+		return MaintenanceResult{}, err
 	}
 	defer storeOperations.Release()

@@ -88,8 +82,33 @@ func ReclaimSpace(ctx context.Context) (MaintenanceResult, error) {
 		Driver: activeStore.Driver(),
 		Action: activeStore.MaintenanceAction(),
 	}
-	result.Before, result.BeforeSizeError = activeStore.StorageSize(ctx)
-	maintenanceErr := activeStore.ReclaimSpace(ctx)
-	result.After, result.AfterSizeError = activeStore.StorageSize(ctx)
+	maintenanceCtx := context.Background()
+	result.Before, result.BeforeSizeError = activeStore.StorageSize(maintenanceCtx)
+	maintenanceErr := deleteUndefinedMetrics(maintenanceCtx, activeStore)
+	if maintenanceErr == nil {
+		maintenanceErr = activeStore.ReclaimSpace(maintenanceCtx)
+	}
+	result.After, result.AfterSizeError = activeStore.StorageSize(maintenanceCtx)
 	return result, maintenanceErr
 }
+
+func deleteUndefinedMetrics(ctx context.Context, s *metric.Store) error {
+	definitions, err := s.ListMetrics(ctx)
+	if err != nil {
+		return fmt.Errorf("list metric definitions before reclaim: %w", err)
+	}
+
+	builtin := make(map[string]struct{}, len(builtinMetricNames))
+	for _, name := range builtinMetricNames {
+		builtin[name] = struct{}{}
+	}
+	for _, definition := range definitions {
+		if _, ok := builtin[definition.Name]; ok {
+			continue
+		}
+		if err := s.DeleteMetric(ctx, definition.Name); err != nil {
+			return fmt.Errorf("delete undefined metric %q before reclaim: %w", definition.Name, err)
+		}
+	}
+	return nil
+}
@@ -2,9 +2,7 @@ package metricstore

 import (
 	"context"
-	"database/sql"
 	"errors"
-	"path/filepath"
 	"testing"
 	"time"

@@ -42,55 +40,7 @@ func TestInspectAndReclaimStorage(t *testing.T) {
 	}
 }

-func TestRetryMetricWALCheckpointDefersBusyReader(t *testing.T) {
-	ctx := context.Background()
-	path := filepath.Join(t.TempDir(), "checkpoint.db")
-	s, err := metric.Open(ctx, metric.SQLite(path, metric.WithSQLiteWALAutoCheckpoint(1_000_000)))
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = s.Close() })
-	if err := s.CreateMetric(ctx, metric.Definition{Name: "before", Type: metric.TypeGauge, RetentionDays: 1}); err != nil {
-		t.Fatal(err)
-	}
-
-	reader, err := sql.Open("sqlite3", path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = reader.Close() })
-	tx, err := reader.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
-	if err != nil {
-		t.Fatal(err)
-	}
-	var definitions int
-	if err := tx.QueryRowContext(ctx, `SELECT COUNT(*) FROM metric_definitions`).Scan(&definitions); err != nil {
-		_ = tx.Rollback()
-		t.Fatal(err)
-	}
-	if err := s.CreateMetric(ctx, metric.Definition{Name: "after", Type: metric.TypeGauge, RetentionDays: 1}); err != nil {
-		_ = tx.Rollback()
-		t.Fatal(err)
-	}
-
-	previousPending := checkpointPending
-	checkpointPending = true
-	t.Cleanup(func() { checkpointPending = previousPending })
-	retryMetricWALCheckpoint(ctx, s)
-	if !checkpointPending {
-		_ = tx.Rollback()
-		t.Fatal("busy reader unexpectedly cleared pending checkpoint")
-	}
-	if err := tx.Rollback(); err != nil {
-		t.Fatal(err)
-	}
-	retryMetricWALCheckpoint(ctx, s)
-	if checkpointPending {
-		t.Fatal("checkpoint remained pending after reader released")
-	}
-}
-
-func TestReclaimSpaceReportsBusyStore(t *testing.T) {
+func TestReclaimSpaceWaitsForStore(t *testing.T) {
 	s, err := metric.Open(context.Background(), metric.SQLite(":memory:"))
 	if err != nil {
 		t.Fatalf("open metric store: %v", err)
@@ -100,17 +50,34 @@ func TestReclaimSpaceReportsBusyStore(t *testing.T) {
 	if err := storeOperations.AcquireShared(context.Background()); err != nil {
 		t.Fatalf("acquire shared store operation gate: %v", err)
 	}
-	defer storeOperations.ReleaseShared()
-
-	result, err := ReclaimSpace(context.Background())
-	if !errors.Is(err, ErrStoreBusy) {
-		t.Fatalf("reclaim error = %v, want %v", err, ErrStoreBusy)
+	done := make(chan struct{})
+	var result MaintenanceResult
+	var reclaimErr error
+	canceledCtx, cancel := context.WithCancel(context.Background())
+	cancel()
+	go func() {
+		result, reclaimErr = ReclaimSpace(canceledCtx)
+		close(done)
+	}()
+	select {
+	case <-done:
+		t.Fatal("reclaim returned while another operation held the gate")
+	case <-time.After(25 * time.Millisecond):
+	}
+	storeOperations.ReleaseShared()
+	select {
+	case <-done:
+	case <-time.After(time.Second):
+		t.Fatal("reclaim did not resume after the gate was released")
+	}
+	if reclaimErr != nil {
+		t.Fatalf("reclaim error: %v", reclaimErr)
 	}
 	if result.Driver != metric.DriverSQLite || result.Action != metric.MaintenanceVacuum {
-		t.Fatalf("busy result lost store metadata: %#v", result)
+		t.Fatalf("reclaim result lost store metadata: %#v", result)
 	}
-	if !errors.Is(result.BeforeSizeError, ErrStoreBusy) || !errors.Is(result.AfterSizeError, ErrStoreBusy) {
-		t.Fatalf("busy result should mark both measurements unavailable: %#v", result)
+	if result.BeforeSizeError != nil || result.AfterSizeError != nil {
+		t.Fatalf("unexpected size errors: before=%v after=%v", result.BeforeSizeError, result.AfterSizeError)
 	}
 	compactCtx, cancel := context.WithTimeout(context.Background(), time.Second)
 	defer cancel()
@@ -124,6 +91,9 @@ func TestReclaimSpaceReportsBusyStore(t *testing.T) {
 	if _, err := Compact(context.Background(), time.Now()); !errors.Is(err, ErrCompactInProgress) {
 		t.Fatalf("overlapping compact error = %v, want %v", err, ErrCompactInProgress)
 	}
+	if _, err := CleanupExpired(context.Background(), time.Now()); !errors.Is(err, ErrCompactInProgress) {
+		t.Fatalf("overlapping retention cleanup error = %v, want %v", err, ErrCompactInProgress)
+	}
 }

 func TestInspectStorageRequiresInitializedStore(t *testing.T) {
@@ -32,13 +32,6 @@ var loadRecordMetricNames = []string{
 	MetricProcess, MetricConnections, MetricConnectionsUDP,
 }

-var obsoleteBuiltinMetricNames = []string{
-	"memory.total",
-	"swap.total",
-	"temperature",
-	"disk.total",
-}
-
 // gpuDeviceRecordMetricNames are stored separately from the entity-level GPU
 // average and are included when deleting all system records.
 var gpuDeviceRecordMetricNames = []string{
@@ -50,6 +43,45 @@ var recordMetricNames = joinMetricNames(loadRecordMetricNames, gpuDeviceRecordMe
 // Ping has an independent retention and cleanup boundary.
 var pingMetricNames = []string{MetricPingLatency, MetricPingLoss}

+var builtinMetricNames = joinMetricNames(recordMetricNames, pingMetricNames)
+
+func metricNameForRecordField(name string) (string, bool) {
+	switch name {
+	case "cpu":
+		return MetricCPU, true
+	case "gpu":
+		return MetricGPU, true
+	case "ram":
+		return MetricRAM, true
+	case "swap":
+		return MetricSwap, true
+	case "load":
+		return MetricLoad, true
+	case "disk":
+		return MetricDisk, true
+	case "net_in", "netin":
+		return MetricNetIn, true
+	case "net_out", "netout":
+		return MetricNetOut, true
+	case "net_total_up":
+		return MetricNetTotalUp, true
+	case "net_total_down":
+		return MetricNetTotalDown, true
+	case "traffic_up":
+		return MetricTrafficUp, true
+	case "traffic_down":
+		return MetricTrafficDown, true
+	case "process":
+		return MetricProcess, true
+	case "connections":
+		return MetricConnections, true
+	case "connections_udp":
+		return MetricConnectionsUDP, true
+	default:
+		return "", false
+	}
+}
+
 func joinMetricNames(groups ...[]string) []string {
 	total := 0
 	for _, group := range groups {
@@ -3,14 +3,13 @@ package metricstore
 import (
 	"context"
 	"database/sql"
-	"errors"
 	"path/filepath"
 	"testing"
 	"time"

 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/pkg/metric"
-	v1 "github.com/komari-monitor/komari/protocol/v1"
+	v2 "github.com/komari-monitor/komari/protocol/v2"
 )

 func TestDefaultRollupPolicy(t *testing.T) {
@@ -72,6 +71,92 @@ func TestBuildMetricConfigLeavesFinalRetentionToMetricDefinition(t *testing.T) {
 	}
 }

+func TestBuildMetricConfigUsesCustomRollupRetention(t *testing.T) {
+	cfg, err := buildMetricConfig(&MetricStoreConfig{
+		Driver:                           "sqlite",
+		DSN:                              ":memory:",
+		RollupMinuteRetentionMinutes:     30,
+		RollupFiveMinuteRetentionMinutes: 150,
+		RollupHourRetentionHours:         300,
+	}, false)
+	if err != nil {
+		t.Fatalf("build metric config: %v", err)
+	}
+
+	want := []time.Duration{30 * time.Minute, 150 * time.Minute, 300 * time.Hour}
+	if len(cfg.RollupPolicy.Tiers) != 4 {
+		t.Fatalf("tier count = %d, want 4", len(cfg.RollupPolicy.Tiers))
+	}
+	for i, retention := range want {
+		if cfg.RollupPolicy.Tiers[i].Retention != retention {
+			t.Fatalf("tier %d retention = %s, want %s", i, cfg.RollupPolicy.Tiers[i].Retention, retention)
+		}
+	}
+}
+
+func TestBuildMetricConfigRejectsInvalidRollupRetention(t *testing.T) {
+	tests := []MetricStoreConfig{
+		{
+			Driver:                       "sqlite",
+			DSN:                          ":memory:",
+			RollupMinuteRetentionMinutes: -1,
+		},
+		{
+			Driver:                           "sqlite",
+			DSN:                              ":memory:",
+			RollupMinuteRetentionMinutes:     120,
+			RollupFiveMinuteRetentionMinutes: 60,
+			RollupHourRetentionHours:         600,
+		},
+		{
+			Driver:                           "sqlite",
+			DSN:                              ":memory:",
+			RollupMinuteRetentionMinutes:     30,
+			RollupFiveMinuteRetentionMinutes: 150,
+			RollupHourRetentionHours:         1,
+		},
+	}
+	for i, cfg := range tests {
+		if _, err := buildMetricConfig(&cfg, false); err == nil {
+			t.Fatalf("case %d: expected invalid rollup retention error", i)
+		}
+	}
+}
+
+func TestBuildMetricConfigDefaultsOmittedRollupRetention(t *testing.T) {
+	cfg, err := buildMetricConfig(&MetricStoreConfig{Driver: "sqlite", DSN: ":memory:"}, false)
+	if err != nil {
+		t.Fatalf("build metric config: %v", err)
+	}
+	if got, want := cfg.RollupPolicy.Tiers[0].Retention, 600*time.Minute; got != want {
+		t.Fatalf("minute retention = %s, want %s", got, want)
+	}
+	if got, want := cfg.RollupPolicy.Tiers[1].Retention, 3000*time.Minute; got != want {
+		t.Fatalf("five-minute retention = %s, want %s", got, want)
+	}
+}
+
+func TestConfigFromFingerprintPreservesRollupRetention(t *testing.T) {
+	base := &MetricStoreConfig{
+		TablePrefix:                      "metrics_",
+		MaxOpenConns:                     11,
+		MaxIdleConns:                     4,
+		RollupMinuteRetentionMinutes:     30,
+		RollupFiveMinuteRetentionMinutes: 150,
+		RollupHourRetentionHours:         300,
+	}
+
+	got, err := configFromFingerprint("mysql|user:password@tcp(host:3306)/metrics", base)
+	if err != nil {
+		t.Fatalf("config from fingerprint: %v", err)
+	}
+	if got.RollupMinuteRetentionMinutes != base.RollupMinuteRetentionMinutes ||
+		got.RollupFiveMinuteRetentionMinutes != base.RollupFiveMinuteRetentionMinutes ||
+		got.RollupHourRetentionHours != base.RollupHourRetentionHours {
+		t.Fatalf("rollup retention was not preserved: %#v", got)
+	}
+}
+
 func TestBuildMetricConfigAlwaysEnablesDownsampling(t *testing.T) {
 	cfg, err := buildMetricConfig(&MetricStoreConfig{
 		Driver: "sqlite",
@@ -197,7 +282,7 @@ func TestCreateMetricDefinitionsUsesExplicitRetentionAndPreservesOverrides(t *te
 	}
 }

-func TestCreateMetricDefinitionsRemovesObsoleteMetrics(t *testing.T) {
+func TestCreateMetricDefinitionsKeepsExistingMetrics(t *testing.T) {
 	ctx := context.Background()
 	s, err := metric.Open(ctx, metric.SQLite(":memory:", metric.WithMaxOpenConns(1)))
 	if err != nil {
@@ -213,15 +298,19 @@ func TestCreateMetricDefinitionsRemovesObsoleteMetrics(t *testing.T) {
 	if err := createMetricDefinitions(ctx, s); err != nil {
 		t.Fatalf("refresh built-in definitions: %v", err)
 	}
-	if _, err := s.GetMetric(ctx, "memory.total"); !errors.Is(err, metric.ErrNotFound) {
-		t.Fatalf("obsolete definition error = %v, want ErrNotFound", err)
+	definition, err := s.GetMetric(ctx, "memory.total")
+	if err != nil {
+		t.Fatalf("existing definition was removed: %v", err)
+	}
+	if definition.RetentionDays != 1 {
+		t.Fatalf("existing retention = %d, want 1", definition.RetentionDays)
 	}
 	points, err := s.Query(ctx, metric.Query{MetricName: "memory.total", EntityID: "node-a", Start: time.Now().UTC().Add(-time.Hour), End: time.Now().UTC().Add(time.Hour)})
 	if err != nil {
-		t.Fatalf("query obsolete points: %v", err)
+		t.Fatalf("query existing points: %v", err)
 	}
-	if len(points) != 0 {
-		t.Fatalf("obsolete points remain: %#v", points)
+	if len(points) != 1 || points[0].Value != 1024 {
+		t.Fatalf("existing points were removed: %#v", points)
 	}
 }

@@ -353,14 +442,11 @@ func TestCompactCleansPointsOutsideFixedRawWindow(t *testing.T) {

 	storeMu.Lock()
 	oldStore := store
-	oldCompactAt := compactAt
 	store = s
-	compactAt = 0
 	storeMu.Unlock()
 	defer func() {
 		storeMu.Lock()
 		store = oldStore
-		compactAt = oldCompactAt
 		storeMu.Unlock()
 		_ = s.Close()
 	}()
@@ -382,7 +468,7 @@ func TestCompactCleansPointsOutsideFixedRawWindow(t *testing.T) {
 	}
 }

-func TestCompactContinuesAfterOneMetricFails(t *testing.T) {
+func TestRetentionCleanupReportsDeleteFailure(t *testing.T) {
 	ctx := context.Background()
 	dsn := filepath.Join(t.TempDir(), "compact.db")
 	s, err := metric.Open(ctx, metric.SQLite(dsn,
@@ -423,19 +509,16 @@ func TestCompactContinuesAfterOneMetricFails(t *testing.T) {

 	storeMu.Lock()
 	previousStore := store
-	previousCompactAt := compactAt
 	store = s
-	compactAt = 0
 	storeMu.Unlock()
 	t.Cleanup(func() {
 		storeMu.Lock()
 		store = previousStore
-		compactAt = previousCompactAt
 		storeMu.Unlock()
 	})

-	if _, err := Compact(ctx, now); err == nil {
-		t.Fatal("expected malformed metric to fail compaction")
+	if _, err := CleanupExpired(ctx, now); err == nil {
+		t.Fatal("expected retention cleanup to report the forced delete failure")
 	}
 	points, err := s.Query(ctx, metric.Query{
 		MetricName: "b.healthy",
@@ -447,44 +530,7 @@ func TestCompactContinuesAfterOneMetricFails(t *testing.T) {
 		t.Fatalf("query healthy rollups: %v", err)
 	}
 	if len(points) != 0 {
-		t.Fatalf("healthy metric was blocked by another metric failure: %#v", points)
-	}
-}
-
-func TestCompactKeepsRotatingCursorAfterFullCycle(t *testing.T) {
-	ctx := context.Background()
-	s, err := metric.Open(ctx, metric.SQLite(":memory:",
-		metric.WithMaxOpenConns(1),
-		metric.WithRollupPolicy(defaultRollupPolicy()),
-	))
-	if err != nil {
-		t.Fatalf("open metric store: %v", err)
-	}
-	for _, name := range []string{"a.metric", "b.metric", "c.metric"} {
-		if err := s.UpsertMetric(ctx, metric.Definition{Name: name, Type: metric.TypeGauge}); err != nil {
-			t.Fatalf("upsert metric %s: %v", name, err)
-		}
-	}
-
-	storeMu.Lock()
-	oldStore := store
-	oldCompactAt := compactAt
-	store = s
-	compactAt = 1
-	storeMu.Unlock()
-	defer func() {
-		storeMu.Lock()
-		store = oldStore
-		compactAt = oldCompactAt
-		storeMu.Unlock()
-		_ = s.Close()
-	}()
-
-	if _, err := Compact(ctx, time.Date(2026, 7, 11, 12, 0, 0, 0, time.UTC)); err != nil {
-		t.Fatalf("compact: %v", err)
-	}
-	if compactAt != 1 {
-		t.Fatalf("compact cursor = %d, want 1 after a complete rotated cycle", compactAt)
+		t.Fatalf("retention cleanup unexpectedly changed healthy metric data: %#v", points)
 	}
 }

@@ -503,14 +549,11 @@ func TestGetRecordsByClientAndTimeReadsRollupsAfterRawCompaction(t *testing.T) {

 	storeMu.Lock()
 	oldStore := store
-	oldCompactAt := compactAt
 	store = s
-	compactAt = 0
 	storeMu.Unlock()
 	defer func() {
 		storeMu.Lock()
 		store = oldStore
-		compactAt = oldCompactAt
 		storeMu.Unlock()
 		_ = s.Close()
 	}()
@@ -529,15 +572,15 @@ func TestGetRecordsByClientAndTimeReadsRollupsAfterRawCompaction(t *testing.T) {
 		Connections:    321,
 		ConnectionsUdp: 12,
 	}
-	if _, err := WriteReport(ctx, v1.Report{
+	if _, err := WriteReport(ctx, v2.Report{
 		UUID:      rec.Client,
 		UpdatedAt: ts,
-		CPU:       v1.CPUReport{Usage: float64(rec.Cpu)},
-		Ram:       v1.RamReport{Used: rec.Ram, Total: rec.RamTotal},
-		Load:      v1.LoadReport{Load1: float64(rec.Load)},
-		Disk:      v1.DiskReport{Used: rec.Disk, Total: rec.DiskTotal},
+		CPU:       v2.CPUReport{Usage: float64(rec.Cpu)},
+		Ram:       v2.RamReport{Used: rec.Ram, Total: rec.RamTotal},
+		Load:      v2.LoadReport{Load1: float64(rec.Load)},
+		Disk:      v2.DiskReport{Used: rec.Disk, Total: rec.DiskTotal},
 		Process:   rec.Process,
-		Connections: v1.ConnectionsReport{
+		Connections: v2.ConnectionsReport{
 			TCP: rec.Connections,
 			UDP: rec.ConnectionsUdp,
 		},
@@ -566,3 +609,41 @@ func TestGetRecordsByClientAndTimeReadsRollupsAfterRawCompaction(t *testing.T) {
 		t.Fatalf("all-client records were not reconstructed from rollup: %#v", all)
 	}
 }
+
+func TestGetRecordMetricMaxByClientAndTimeQueriesOnlySelectedMetric(t *testing.T) {
+	ctx := context.Background()
+	s, err := metric.Open(ctx, metric.SQLite(":memory:",
+		metric.WithMaxOpenConns(1),
+		metric.WithRollupPolicy(defaultRollupPolicy()),
+	))
+	if err != nil {
+		t.Fatalf("open metric store: %v", err)
+	}
+	defer s.Close()
+	if err := createMetricDefinitions(ctx, s); err != nil {
+		t.Fatalf("create metric definitions: %v", err)
+	}
+
+	base := time.Now().UTC().Truncate(time.Minute).Add(-time.Minute)
+	if err := s.WriteBatch(ctx, []metric.Point{
+		{MetricName: MetricCPU, EntityID: "node-a", Timestamp: base.Add(10 * time.Second), Value: 10},
+		{MetricName: MetricCPU, EntityID: "node-a", Timestamp: base.Add(20 * time.Second), Value: 90},
+		{MetricName: MetricRAM, EntityID: "node-a", Timestamp: base.Add(20 * time.Second), Value: 123456},
+	}); err != nil {
+		t.Fatalf("write metric points: %v", err)
+	}
+
+	got, err := getRecordMetricMaxByClientAndTimeFromSeries(ctx, s, "node-a", "cpu", base, base.Add(time.Minute))
+	if err != nil {
+		t.Fatalf("get CPU max records: %v", err)
+	}
+	if len(got) != 1 {
+		t.Fatalf("record count = %d, want 1: %#v", len(got), got)
+	}
+	if got[0].Cpu != 90 {
+		t.Fatalf("CPU max = %v, want 90", got[0].Cpu)
+	}
+	if got[0].Ram != 0 {
+		t.Fatalf("unselected RAM value = %d, want 0", got[0].Ram)
+	}
+}
@@ -25,11 +25,14 @@ func configFromFingerprint(fingerprint string, base *MetricStoreConfig) (*Metric
 		return nil, fmt.Errorf("empty driver in target fingerprint: %q", fingerprint)
 	}
 	return &MetricStoreConfig{
-		Driver:       driver,
-		DSN:          dsn,
-		TablePrefix:  base.TablePrefix,
-		MaxOpenConns: base.MaxOpenConns,
-		MaxIdleConns: base.MaxIdleConns,
+		Driver:                           driver,
+		DSN:                              dsn,
+		TablePrefix:                      base.TablePrefix,
+		MaxOpenConns:                     base.MaxOpenConns,
+		MaxIdleConns:                     base.MaxIdleConns,
+		RollupMinuteRetentionMinutes:     base.RollupMinuteRetentionMinutes,
+		RollupFiveMinuteRetentionMinutes: base.RollupFiveMinuteRetentionMinutes,
+		RollupHourRetentionHours:         base.RollupHourRetentionHours,
 	}, nil
 }

@@ -52,33 +55,6 @@ func defaultSQLiteFingerprint() string {
 	return targetFingerprint(&MetricStoreConfig{Driver: "sqlite", DSN: "./data/metrics.db"})
 }

-// migrateFromPreviousStore 打开由 prevFingerprint 指定的上一个 metrics 目标库作为源，
-// 把其中的全部指标定义和持久化 rollup 搬运到当前目标 dst（例如 SQLite
-// metrics.db → MySQL/PostgreSQL）。
-//
-// 该过程幂等：dst 以 (series, resolution, labels, bucket) upsert 写入，中断后重启可安全重跑。
-func migrateFromPreviousStore(prevFingerprint string, cfg *MetricStoreConfig, dst *metric.Store) error {
-	prevCfg, err := configFromFingerprint(prevFingerprint, cfg)
-	if err != nil {
-		return fmt.Errorf("parse previous metrics target %q: %w", prevFingerprint, err)
-	}
-
-	ctx := context.Background()
-	src, err := openSourceStore(ctx, prevCfg)
-	if err != nil {
-		return fmt.Errorf("open previous metrics store (%s): %w", prevFingerprint, err)
-	}
-	defer src.Close()
-
-	logger.Infof("metricstore", "Migrating metrics from previous store %s to current target...", prevFingerprint)
-	total, err := MigrateBetweenStores(ctx, src, dst)
-	if err != nil {
-		return fmt.Errorf("store-to-store metrics migration failed: %w", err)
-	}
-	logger.Infof("metricstore", "Store-to-store metrics migration completed (%d rollups)", total)
-	return nil
-}
-
 // storeMigrationObserver 在 store-to-store 迁移过程中接收进度回调。
 //   - currentMetric：当前正在搬运的指标名。
 //   - metricIndex：该指标在全部指标中的序号（0 起），即已完成的指标数。
@@ -86,19 +62,6 @@ func migrateFromPreviousStore(prevFingerprint string, cfg *MetricStoreConfig, ds
 //   - addedPoints：本次新写入目标库的 rollup 行数（用于外部累计）。
 type storeMigrationObserver func(currentMetric string, metricIndex, totalMetrics int, addedPoints int64)

-// MigrateBetweenStores 把 src metric store 的全部指标定义与持久化 rollup 搬运到 dst。
-//
-// 用于 metrics 后端切换（例如默认 SQLite metrics.db → MySQL/PostgreSQL）：
-//   - 先在 dst 建立/更新全部指标定义；
-//   - 再按指标流式读取源库 rollup 并分批写入 dst。
-//
-// rollup 在 dst 以 (series, resolution, labels, bucket) upsert 写入，因此整个
-// 过程可安全重试。返回搬运的 rollup 行数。
-func MigrateBetweenStores(ctx context.Context, src, dst *metric.Store) (int64, error) {
-	return migrateBetweenStores(ctx, src, dst, nil)
-}
-
-// migrateBetweenStores 是 MigrateBetweenStores 的内部实现，额外接受一个可选的进度
 // 观察者 observe（为 nil 时行为与旧版本完全一致）。WebUI/API 手动触发的迁移传入
 // 回调以实时更新进度。
 func migrateBetweenStores(ctx context.Context, src, dst *metric.Store, observe storeMigrationObserver) (int64, error) {
@@ -0,0 +1,133 @@
+package metricstore
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"time"
+
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+// WritePingRecord 将 ping 记录写入 metric store
+func WritePingRecord(ctx context.Context, rec models.PingRecord) error {
+	s := GetStore()
+	if s == nil {
+		return fmt.Errorf("metric store not enabled")
+	}
+
+	reportBatcherMu.Lock()
+	worker := reportBatcher
+	reportBatcherMu.Unlock()
+	if worker != nil {
+		return worker.enqueuePing(ctx, rec)
+	}
+	return writePingRecords(ctx, []models.PingRecord{rec})
+}
+
+func writePingRecords(ctx context.Context, records []models.PingRecord) error {
+	s := GetStore()
+	if s == nil {
+		return fmt.Errorf("metric store not enabled")
+	}
+	if len(records) == 0 {
+		return nil
+	}
+
+	points := make([]metric.Point, 0, len(records)*2)
+	for _, rec := range records {
+		tags := map[string]string{"task_id": fmt.Sprintf("%d", rec.TaskId)}
+		loss := 0.0
+		if rec.Value < 0 {
+			loss = 1
+		}
+		points = append(points,
+			metric.Point{
+				MetricName: MetricPingLatency,
+				EntityID:   rec.Client,
+				Timestamp:  rec.Time,
+				Value:      float64(rec.Value),
+				Tags:       tags,
+			},
+			metric.Point{
+				MetricName: MetricPingLoss,
+				EntityID:   rec.Client,
+				Timestamp:  rec.Time,
+				Value:      loss,
+				Tags:       tags,
+			},
+		)
+	}
+	return s.WriteBatch(ctx, points)
+}
+
+func GetPingRecords(ctx context.Context, clientUUID string, taskID int, start, end time.Time) ([]models.PingRecord, error) {
+	s := GetStore()
+	if s == nil {
+		return nil, fmt.Errorf("metric store not enabled")
+	}
+
+	query := metric.Query{
+		MetricName: MetricPingLatency,
+		Start:      start,
+		End:        end,
+		Order:      metric.OrderAsc,
+	}
+
+	if clientUUID != "" {
+		query.EntityID = clientUUID
+	}
+
+	if taskID >= 0 {
+		query.Tags = map[string]string{"task_id": fmt.Sprintf("%d", taskID)}
+	}
+
+	interval := pingQueryInterval(end.Sub(start), 4000)
+	interval = s.CompatibleSeriesInterval(start, time.Now().UTC(), interval)
+	points, err := s.Series(ctx, metric.AggregateQuery{
+		Query:          query,
+		Aggregation:    metric.AggLast,
+		Interval:       interval,
+		PreserveSeries: true,
+	}, time.Now().UTC())
+	if err != nil {
+		return nil, err
+	}
+
+	records := make([]models.PingRecord, 0, len(points))
+	for _, p := range points {
+		taskIDVal := uint(0)
+		if tid, ok := p.Tags["task_id"]; ok {
+			var t uint64
+			fmt.Sscanf(tid, "%d", &t)
+			taskIDVal = uint(t)
+		}
+
+		records = append(records, models.PingRecord{
+			Client: p.EntityID,
+			TaskId: taskIDVal,
+			Time:   p.Bucket.UTC(),
+			Value:  int(p.Value),
+		})
+	}
+	sort.Slice(records, func(i, j int) bool {
+		return records[i].Time.After(records[j].Time)
+	})
+
+	return records, nil
+}
+
+func pingQueryInterval(rangeDuration time.Duration, maxPoints int) time.Duration {
+	if maxPoints <= 0 {
+		maxPoints = 4000
+	}
+	if rangeDuration <= 0 {
+		return time.Second
+	}
+	interval := time.Duration((rangeDuration.Nanoseconds() + int64(maxPoints) - 1) / int64(maxPoints))
+	if interval < time.Second {
+		return time.Second
+	}
+	return metric.FloorStandardInterval(interval)
+}
@@ -0,0 +1,63 @@
+package metricstore
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+// QueryContext runs a raw read query against the active metric store. The
+// caller must invoke the returned release function after closing rows.
+func QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, metric.Driver, func(), error) {
+	return QueryForDriver(ctx, func(metric.Driver) (string, error) {
+		return query, nil
+	}, args...)
+}
+
+// QueryForDriver runs a raw read query whose SQL depends on the active store's
+// driver. The caller must invoke the returned release function after closing rows.
+func QueryForDriver(ctx context.Context, query func(metric.Driver) (string, error), args ...any) (*sql.Rows, metric.Driver, func(), error) {
+	if err := storeOperations.AcquireShared(ctx); err != nil {
+		return nil, "", nil, fmt.Errorf("wait for metric store operations before query: %w", err)
+	}
+
+	storeMu.RLock()
+	activeStore := store
+	storeMu.RUnlock()
+	if activeStore == nil {
+		storeOperations.ReleaseShared()
+		return nil, "", nil, ErrStoreNotInitialized
+	}
+
+	statement, err := query(activeStore.Driver())
+	if err != nil {
+		storeOperations.ReleaseShared()
+		return nil, "", nil, err
+	}
+	rows, err := activeStore.QueryContext(ctx, statement, args...)
+	if err != nil {
+		storeOperations.ReleaseShared()
+		return nil, "", nil, err
+	}
+	return rows, activeStore.Driver(), storeOperations.ReleaseShared, nil
+}
+
+// ExecContext runs a raw statement against the active metric store.
+func ExecContext(ctx context.Context, query string, args ...any) (sql.Result, metric.Driver, error) {
+	if err := storeOperations.Acquire(ctx); err != nil {
+		return nil, "", fmt.Errorf("wait for metric store operations before execution: %w", err)
+	}
+	defer storeOperations.Release()
+
+	storeMu.RLock()
+	activeStore := store
+	storeMu.RUnlock()
+	if activeStore == nil {
+		return nil, "", ErrStoreNotInitialized
+	}
+
+	result, err := activeStore.ExecContext(ctx, query, args...)
+	return result, activeStore.Driver(), err
+}
@@ -4,14 +4,14 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	logger "github.com/komari-monitor/komari/utils/log"
-	"strconv"
 	"sync"
 	"time"

+	logger "github.com/komari-monitor/komari/utils/log"
+
 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/pkg/metric"
-	v1 "github.com/komari-monitor/komari/protocol/v1"
+	v2 "github.com/komari-monitor/komari/protocol/v2"
 )

 type reportTrafficState struct {
@@ -57,7 +57,7 @@ type reportBatchRequest struct {

 type reportBatchWorker struct {
 	mu        sync.Mutex
-	queue     chan v1.Report
+	queue     chan v2.Report
 	pingQueue chan models.PingRecord
 	requests  chan reportBatchRequest
 	done      chan struct{}
@@ -73,7 +73,7 @@ func StartReportBatcher() {
 		return
 	}
 	worker := &reportBatchWorker{
-		queue:     make(chan v1.Report, reportBatchQueueSize),
+		queue:     make(chan v2.Report, reportBatchQueueSize),
 		pingQueue: make(chan models.PingRecord, reportBatchQueueSize),
 		requests:  make(chan reportBatchRequest, 1),
 		done:      make(chan struct{}),
@@ -150,16 +150,16 @@ func FlushReportBatch(ctx context.Context) error {
 // WriteReport persists one agent report and adds it to in-memory minute
 // summaries using the same server receive time. Traffic deltas remain summable
 // after rollup.
-func WriteReport(ctx context.Context, report v1.Report) (v1.Report, error) {
+func WriteReport(ctx context.Context, report v2.Report) (v2.Report, error) {
 	if report.UUID == "" {
-		return v1.Report{}, fmt.Errorf("report UUID is required")
+		return v2.Report{}, fmt.Errorf("report UUID is required")
 	}
 	if report.UpdatedAt.IsZero() {
-		return v1.Report{}, fmt.Errorf("report receive time is required")
+		return v2.Report{}, fmt.Errorf("report receive time is required")
 	}
 	report.UpdatedAt = report.UpdatedAt.UTC()
 	if GetStore() == nil {
-		return v1.Report{}, fmt.Errorf("metric store not enabled")
+		return v2.Report{}, fmt.Errorf("metric store not enabled")
 	}

 	reportBatcherMu.Lock()
@@ -167,19 +167,19 @@ func WriteReport(ctx context.Context, report v1.Report) (v1.Report, error) {
 	reportBatcherMu.Unlock()
 	if worker != nil {
 		if err := worker.enqueue(ctx, report); err != nil {
-			return v1.Report{}, err
+			return v2.Report{}, err
 		}
 		return report, nil
 	}

-	saved, err := writeReportBatch(ctx, []v1.Report{report})
+	saved, err := writeReportBatch(ctx, []v2.Report{report})
 	if err != nil {
-		return v1.Report{}, err
+		return v2.Report{}, err
 	}
 	return saved[0], nil
 }

-func (w *reportBatchWorker) enqueue(ctx context.Context, report v1.Report) error {
+func (w *reportBatchWorker) enqueue(ctx context.Context, report v2.Report) error {
 	w.mu.Lock()
 	defer w.mu.Unlock()
 	if w.stopping {
@@ -200,7 +200,7 @@ func (w *reportBatchWorker) run() {
 	ticker := time.NewTicker(reportBatchInterval)
 	defer ticker.Stop()

-	var pending []v1.Report
+	var pending []v2.Report
 	var pendingPings []models.PingRecord
 	for {
 		select {
@@ -250,11 +250,18 @@ func (w *reportBatchWorker) enqueuePing(ctx context.Context, record models.PingR
 	}
 }

-func drainReportQueue(queue <-chan v1.Report, limit int) []v1.Report {
+func drainReportQueue(queue <-chan v2.Report, limit int) []v2.Report {
 	if limit <= 0 {
 		return nil
 	}
-	reports := make([]v1.Report, 0, limit)
+	capacity := len(queue)
+	if capacity > limit {
+		capacity = limit
+	}
+	if capacity == 0 {
+		return nil
+	}
+	reports := make([]v2.Report, 0, capacity)
 	for len(reports) < limit {
 		select {
 		case report := <-queue:
@@ -270,7 +277,14 @@ func drainPingQueue(queue <-chan models.PingRecord, limit int) []models.PingReco
 	if limit <= 0 {
 		return nil
 	}
-	records := make([]models.PingRecord, 0, limit)
+	capacity := len(queue)
+	if capacity > limit {
+		capacity = limit
+	}
+	if capacity == 0 {
+		return nil
+	}
+	records := make([]models.PingRecord, 0, capacity)
 	for len(records) < limit {
 		select {
 		case record := <-queue:
@@ -282,7 +296,7 @@ func drainPingQueue(queue <-chan models.PingRecord, limit int) []models.PingReco
 	return records
 }

-func writePendingReports(ctx context.Context, pending *[]v1.Report) error {
+func writePendingReports(ctx context.Context, pending *[]v2.Report) error {
 	if len(*pending) == 0 {
 		return nil
 	}
@@ -319,7 +333,7 @@ func writePendingPingRecords(ctx context.Context, pending *[]models.PingRecord)
 	return nil
 }

-func writeReportBatch(ctx context.Context, reports []v1.Report) ([]v1.Report, error) {
+func writeReportBatch(ctx context.Context, reports []v2.Report) ([]v2.Report, error) {
 	if len(reports) == 0 {
 		return nil, nil
 	}
@@ -333,7 +347,7 @@ func writeReportBatch(ctx context.Context, reports []v1.Report) ([]v1.Report, er
 		return nil, fmt.Errorf("metric store not enabled")
 	}

-	prepared := make([]v1.Report, len(reports))
+	prepared := make([]v2.Report, len(reports))
 	copy(prepared, reports)
 	points := make([]metric.Point, 0, len(reports)*20)
 	pendingStates := make(map[*reportTrafficState]reportTrafficValues)
@@ -348,21 +362,18 @@ func writeReportBatch(ctx context.Context, reports []v1.Report) ([]v1.Report, er
 		}
 		if !values.initialized {
 			totalUp, hasUp, err := latestReportCounter(ctx, s, MetricNetTotalUp, report.UUID, report.UpdatedAt)
-			if err == nil {
+			if err != nil {
+				logger.Errorf("metricstore", "failed to restore previous upload counter for %s: %v", report.UUID, err)
+			} else {
 				values.totalUp = totalUp
 				values.hasUp = hasUp
-			} else if ctx.Err() == nil {
-				logger.Errorf("metricstore", "failed to restore previous upload counter for %s: %v", report.UUID, err)
 			}
 			totalDown, hasDown, err := latestReportCounter(ctx, s, MetricNetTotalDown, report.UUID, report.UpdatedAt)
-			if err == nil {
+			if err != nil {
+				logger.Errorf("metricstore", "failed to restore previous download counter for %s: %v", report.UUID, err)
+			} else {
 				values.totalDown = totalDown
 				values.hasDown = hasDown
-			} else if ctx.Err() == nil {
-				logger.Errorf("metricstore", "failed to restore previous download counter for %s: %v", report.UUID, err)
-			}
-			if err := ctx.Err(); err != nil {
-				return nil, err
 			}
 			values.initialized = true
 		}
@@ -388,118 +399,17 @@ func writeReportBatch(ctx context.Context, reports []v1.Report) ([]v1.Report, er
 		prepared[i] = report
 	}

-	if err := s.WriteBatch(ctx, points); err != nil {
-		return nil, err
-	}
+	// Persist the restored per-report traffic state even if the write below
+	// fails, so a slow or failing database does not re-issue the previous-
+	// counter queries on every batch.
 	for state, values := range pendingStates {
 		state.mu.Lock()
 		state.reportTrafficValues = values
 		state.mu.Unlock()
 	}
+
+	if err := s.WriteBatch(ctx, points); err != nil {
+		return nil, err
+	}
 	return prepared, nil
 }
-
-func reportMetricPoints(report v1.Report, trafficUp, trafficDown int64) []metric.Point {
-	entityID := report.UUID
-	ts := report.UpdatedAt
-	points := []metric.Point{
-		{MetricName: MetricCPU, EntityID: entityID, Timestamp: ts, Value: report.CPU.Usage},
-		{MetricName: MetricRAM, EntityID: entityID, Timestamp: ts, Value: float64(report.Ram.Used)},
-		{MetricName: MetricSwap, EntityID: entityID, Timestamp: ts, Value: float64(report.Swap.Used)},
-		{MetricName: MetricLoad, EntityID: entityID, Timestamp: ts, Value: report.Load.Load1},
-		{MetricName: MetricDisk, EntityID: entityID, Timestamp: ts, Value: float64(report.Disk.Used)},
-		{MetricName: MetricNetIn, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.Down)},
-		{MetricName: MetricNetOut, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.Up)},
-		{MetricName: MetricNetTotalUp, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.TotalUp)},
-		{MetricName: MetricNetTotalDown, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.TotalDown)},
-		{MetricName: MetricTrafficUp, EntityID: entityID, Timestamp: ts, Value: float64(trafficUp)},
-		{MetricName: MetricTrafficDown, EntityID: entityID, Timestamp: ts, Value: float64(trafficDown)},
-		{MetricName: MetricProcess, EntityID: entityID, Timestamp: ts, Value: float64(report.Process)},
-		{MetricName: MetricConnections, EntityID: entityID, Timestamp: ts, Value: float64(report.Connections.TCP)},
-		{MetricName: MetricConnectionsUDP, EntityID: entityID, Timestamp: ts, Value: float64(report.Connections.UDP)},
-	}
-	if report.GPU == nil {
-		return points
-	}
-	points = append(points, metric.Point{MetricName: MetricGPU, EntityID: entityID, Timestamp: ts, Value: report.GPU.AverageUsage})
-	for deviceIndex, gpu := range report.GPU.DetailedInfo {
-		tags := map[string]string{
-			"device_index": strconv.Itoa(deviceIndex),
-			"device_name":  gpu.Name,
-		}
-		points = append(points,
-			metric.Point{MetricName: MetricGPUMem, EntityID: entityID, Timestamp: ts, Value: float64(gpu.MemoryUsed), Tags: tags},
-			metric.Point{MetricName: MetricGPUMemTotal, EntityID: entityID, Timestamp: ts, Value: float64(gpu.MemoryTotal), Tags: tags},
-			metric.Point{MetricName: MetricGPUDeviceUsage, EntityID: entityID, Timestamp: ts, Value: gpu.Utilization, Tags: tags},
-			metric.Point{MetricName: MetricGPUTemp, EntityID: entityID, Timestamp: ts, Value: float64(gpu.Temperature), Tags: tags},
-		)
-	}
-	return points
-}
-
-func latestReportCounter(ctx context.Context, s *metric.Store, metricName, entityID string, before time.Time) (int64, bool, error) {
-	point, ok, err := s.LatestBefore(ctx, metricName, entityID, before)
-	if err != nil {
-		return 0, false, err
-	}
-	if !ok {
-		return 0, false, nil
-	}
-	return int64(point.Value), true, nil
-}
-
-// GetLatestTrafficBefore returns the latest retained upload/download counters
-// before a boundary, transparently reading raw points or rollup summaries.
-func GetLatestTrafficBefore(ctx context.Context, entityIDs []string, before time.Time) (map[string]models.Record, error) {
-	s := GetStore()
-	if s == nil {
-		return nil, fmt.Errorf("metric store not enabled")
-	}
-	result := make(map[string]models.Record, len(entityIDs))
-	for _, entityID := range entityIDs {
-		if entityID == "" {
-			continue
-		}
-		up, hasUp, err := latestReportCounter(ctx, s, MetricNetTotalUp, entityID, before)
-		if err != nil {
-			return nil, err
-		}
-		down, hasDown, err := latestReportCounter(ctx, s, MetricNetTotalDown, entityID, before)
-		if err != nil {
-			return nil, err
-		}
-		if !hasUp && !hasDown {
-			continue
-		}
-		result[entityID] = models.Record{
-			Client:       entityID,
-			Time:         before.UTC().Add(-time.Nanosecond),
-			NetTotalUp:   up,
-			NetTotalDown: down,
-		}
-	}
-	return result, nil
-}
-
-// TrafficCounterDelta returns a reset-aware increase between two cumulative
-// traffic counters. After a reset, the current counter is the new increase.
-func TrafficCounterDelta(current, previous int64) int64 {
-	if current < 0 || previous < 0 {
-		return 0
-	}
-	if current >= previous {
-		return current - previous
-	}
-	return current
-}
-
-func deleteReportTrafficState(entityID string) {
-	reportTrafficStates.Delete(entityID)
-}
-
-func clearReportTrafficStates() {
-	reportTrafficStates.Range(func(key, _ any) bool {
-		reportTrafficStates.Delete(key)
-		return true
-	})
-}
@@ -0,0 +1,127 @@
+package metricstore
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+	"time"
+
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/metric"
+	v2 "github.com/komari-monitor/komari/protocol/v2"
+)
+
+func reportMetricPoints(report v2.Report, trafficUp, trafficDown int64) []metric.Point {
+	entityID := report.UUID
+	ts := report.UpdatedAt
+	points := []metric.Point{
+		{MetricName: MetricCPU, EntityID: entityID, Timestamp: ts, Value: report.CPU.Usage},
+		{MetricName: MetricRAM, EntityID: entityID, Timestamp: ts, Value: float64(report.Ram.Used)},
+		{MetricName: MetricSwap, EntityID: entityID, Timestamp: ts, Value: float64(report.Swap.Used)},
+		{MetricName: MetricLoad, EntityID: entityID, Timestamp: ts, Value: report.Load.Load1},
+		{MetricName: MetricDisk, EntityID: entityID, Timestamp: ts, Value: float64(report.Disk.Used)},
+		{MetricName: MetricNetIn, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.Down)},
+		{MetricName: MetricNetOut, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.Up)},
+		{MetricName: MetricNetTotalUp, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.TotalUp)},
+		{MetricName: MetricNetTotalDown, EntityID: entityID, Timestamp: ts, Value: float64(report.Network.TotalDown)},
+		{MetricName: MetricTrafficUp, EntityID: entityID, Timestamp: ts, Value: float64(trafficUp)},
+		{MetricName: MetricTrafficDown, EntityID: entityID, Timestamp: ts, Value: float64(trafficDown)},
+		{MetricName: MetricProcess, EntityID: entityID, Timestamp: ts, Value: float64(report.Process)},
+		{MetricName: MetricConnections, EntityID: entityID, Timestamp: ts, Value: float64(report.Connections.TCP)},
+		{MetricName: MetricConnectionsUDP, EntityID: entityID, Timestamp: ts, Value: float64(report.Connections.UDP)},
+	}
+	if report.GPU == nil {
+		return points
+	}
+	points = append(points, metric.Point{MetricName: MetricGPU, EntityID: entityID, Timestamp: ts, Value: report.GPU.AverageUsage})
+	for deviceIndex, gpu := range report.GPU.DetailedInfo {
+		tags := map[string]string{
+			"device_index": strconv.Itoa(deviceIndex),
+			"device_name":  gpu.Name,
+		}
+		points = append(points,
+			metric.Point{MetricName: MetricGPUMem, EntityID: entityID, Timestamp: ts, Value: float64(gpu.MemoryUsed), Tags: tags},
+			metric.Point{MetricName: MetricGPUMemTotal, EntityID: entityID, Timestamp: ts, Value: float64(gpu.MemoryTotal), Tags: tags},
+			metric.Point{MetricName: MetricGPUDeviceUsage, EntityID: entityID, Timestamp: ts, Value: gpu.Utilization, Tags: tags},
+			metric.Point{MetricName: MetricGPUTemp, EntityID: entityID, Timestamp: ts, Value: float64(gpu.Temperature), Tags: tags},
+		)
+	}
+	return points
+}
+
+func latestReportCounter(ctx context.Context, s *metric.Store, metricName, entityID string, before time.Time) (int64, bool, error) {
+	point, ok, err := s.LatestBefore(ctx, metricName, entityID, before)
+	if err != nil {
+		return 0, false, err
+	}
+	if !ok {
+		return 0, false, nil
+	}
+	return int64(point.Value), true, nil
+}
+
+// GetLatestTrafficBefore returns the latest retained upload/download counters
+// before a boundary, transparently reading raw points or rollup summaries.
+func GetLatestTrafficBefore(ctx context.Context, entityIDs []string, before time.Time) (map[string]models.Record, error) {
+	s := GetStore()
+	if s == nil {
+		return nil, fmt.Errorf("metric store not enabled")
+	}
+	result := make(map[string]models.Record, len(entityIDs))
+	for _, entityID := range entityIDs {
+		if entityID == "" {
+			continue
+		}
+		up, hasUp, err := latestReportCounter(ctx, s, MetricNetTotalUp, entityID, before)
+		if err != nil {
+			return nil, err
+		}
+		down, hasDown, err := latestReportCounter(ctx, s, MetricNetTotalDown, entityID, before)
+		if err != nil {
+			return nil, err
+		}
+		if !hasUp && !hasDown {
+			continue
+		}
+		result[entityID] = models.Record{
+			Client:       entityID,
+			Time:         before.UTC().Add(-time.Nanosecond),
+			NetTotalUp:   up,
+			NetTotalDown: down,
+		}
+	}
+	return result, nil
+}
+
+// maxResetAwareDelta is the largest per-sample increase accepted when a
+// counter appears to reset. A "reset" whose current value is larger than this
+// is treated as jitter of a still-huge counter, not a wrap or reboot leftover.
+const maxResetAwareDelta int64 = 64 << 30
+
+// TrafficCounterDelta returns a reset-aware increase between two cumulative
+// traffic counters. After a wrap or reboot, the current counter is the new
+// increase. A tiny dip of a TB-scale counter is not a reset: counting the
+// still-huge current value would inject a multi-terabyte spike.
+func TrafficCounterDelta(current, previous int64) int64 {
+	if current < 0 || previous < 0 {
+		return 0
+	}
+	if current >= previous {
+		return current - previous
+	}
+	if current > maxResetAwareDelta {
+		return 0
+	}
+	return current
+}
+
+func deleteReportTrafficState(entityID string) {
+	reportTrafficStates.Delete(entityID)
+}
+
+func clearReportTrafficStates() {
+	reportTrafficStates.Range(func(key, _ any) bool {
+		reportTrafficStates.Delete(key)
+		return true
+	})
+}
@@ -2,14 +2,18 @@ package metricstore

 import (
 	"context"
+	"database/sql"
+	"database/sql/driver"
 	"errors"
 	"fmt"
+	"sync/atomic"
 	"testing"
 	"time"

 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/pkg/metric"
-	v1 "github.com/komari-monitor/komari/protocol/v1"
+	v2 "github.com/komari-monitor/komari/protocol/v2"
+	sqlite3 "github.com/mattn/go-sqlite3"
 )

 func useReportTestStore(t *testing.T, policy *metric.RollupPolicy) *metric.Store {
@@ -44,6 +48,124 @@ func useReportTestStore(t *testing.T, policy *metric.RollupPolicy) *metric.Store
 	return s
 }

+type reportCounterFault struct {
+	remaining atomic.Int32
+	denied    atomic.Int32
+}
+
+func (f *reportCounterFault) denyRollupRead() bool {
+	for {
+		remaining := f.remaining.Load()
+		if remaining <= 0 {
+			return false
+		}
+		if f.remaining.CompareAndSwap(remaining, remaining-1) {
+			f.denied.Add(1)
+			return true
+		}
+	}
+}
+
+type reportSQLiteConnector struct {
+	driver *sqlite3.SQLiteDriver
+	dsn    string
+}
+
+func (c *reportSQLiteConnector) Connect(context.Context) (driver.Conn, error) {
+	return c.driver.Open(c.dsn)
+}
+
+func (c *reportSQLiteConnector) Driver() driver.Driver {
+	return c.driver
+}
+
+// useReportCounterFailureStore denies exactly two rollup reads after schema
+// setup, exercising failed counter restoration while leaving writes usable.
+func useReportCounterFailureStore(t *testing.T) (*metric.Store, *reportCounterFault) {
+	t.Helper()
+	fault := &reportCounterFault{}
+	dsn := fmt.Sprintf("file:report-counter-fault-%d?mode=memory&cache=shared", time.Now().UnixNano())
+	driver := &sqlite3.SQLiteDriver{
+		ConnectHook: func(conn *sqlite3.SQLiteConn) error {
+			conn.RegisterAuthorizer(func(op int, arg1, _, _ string) int {
+				if op == sqlite3.SQLITE_READ && arg1 == "metric_rollups" && fault.denyRollupRead() {
+					return sqlite3.SQLITE_DENY
+				}
+				return sqlite3.SQLITE_OK
+			})
+			return nil
+		},
+	}
+	db := sql.OpenDB(&reportSQLiteConnector{driver: driver, dsn: dsn})
+	s, err := metric.Open(context.Background(), metric.SQLite("", metric.WithDB(db), metric.WithMaxOpenConns(1)))
+	if err != nil {
+		_ = db.Close()
+		t.Fatalf("open metric store: %v", err)
+	}
+	if err := createMetricDefinitions(context.Background(), s); err != nil {
+		_ = s.Close()
+		_ = db.Close()
+		t.Fatalf("create metric definitions: %v", err)
+	}
+	fault.remaining.Store(2)
+	storeMu.Lock()
+	previous := store
+	store = s
+	storeMu.Unlock()
+	t.Cleanup(func() {
+		clearReportTrafficStates()
+		storeMu.Lock()
+		store = previous
+		storeMu.Unlock()
+		_ = s.Close()
+		_ = db.Close()
+	})
+	return s, fault
+}
+
+func TestReportBatchCounterRestoreFailureInitializesStateOnce(t *testing.T) {
+	s, fault := useReportCounterFailureStore(t)
+	ctx := context.Background()
+	base := time.Now().UTC().Truncate(time.Second)
+	first := v2.Report{
+		UUID:      "counter-restore-failure",
+		UpdatedAt: base,
+		CPU:       v2.CPUReport{Usage: 10},
+		Network:   v2.NetworkReport{TotalUp: 100, TotalDown: 200},
+	}
+
+	if _, err := writeReportBatch(ctx, []v2.Report{first}); err != nil {
+		t.Fatalf("write first report after counter restore failure: %v", err)
+	}
+	if fault.denied.Load() != 2 {
+		t.Fatalf("counter restore queries = %d, want 2", fault.denied.Load())
+	}
+	stateValue, ok := reportTrafficStates.Load(first.UUID)
+	if !ok {
+		t.Fatal("report traffic state was not persisted")
+	}
+	state := stateValue.(*reportTrafficState)
+	state.mu.Lock()
+	initialized := state.initialized
+	state.mu.Unlock()
+	if !initialized {
+		t.Fatal("report traffic state was not initialized after restore failure")
+	}
+
+	second := first
+	second.UpdatedAt = base.Add(time.Second)
+	second.Network.TotalUp = 150
+	second.Network.TotalDown = 260
+	if _, err := writeReportBatch(ctx, []v2.Report{second}); err != nil {
+		t.Fatalf("write second report: %v", err)
+	}
+	if fault.denied.Load() != 2 {
+		t.Fatalf("counter restore queries after second batch = %d, want no repeat", fault.denied.Load())
+	}
+	assertMetricValues(t, s, MetricTrafficUp, first.UUID, base.Add(-time.Second), base.Add(2*time.Second), []float64{0, 50})
+	assertMetricValues(t, s, MetricTrafficDown, first.UUID, base.Add(-time.Second), base.Add(2*time.Second), []float64{0, 60})
+}
+
 func TestWriteReportStoresMinuteMetricsAndResetAwareTraffic(t *testing.T) {
 	ctx := context.Background()
 	policy := defaultRollupPolicy()
@@ -51,20 +173,20 @@ func TestWriteReportStoresMinuteMetricsAndResetAwareTraffic(t *testing.T) {
 	base := time.Now().UTC().Truncate(time.Minute).Add(5 * time.Second)
 	now := base.Add(45 * time.Second)

-	report := v1.Report{
+	report := v2.Report{
 		UUID:        "node-a",
 		UpdatedAt:   base,
-		CPU:         v1.CPUReport{Usage: 12.5},
-		Ram:         v1.RamReport{Used: 100, Total: 1000},
-		Swap:        v1.RamReport{Used: 20, Total: 200},
-		Load:        v1.LoadReport{Load1: 0.5},
-		Disk:        v1.DiskReport{Used: 300, Total: 3000},
-		Network:     v1.NetworkReport{Up: 3, Down: 4, TotalUp: 100, TotalDown: 200},
+		CPU:         v2.CPUReport{Usage: 12.5},
+		Ram:         v2.RamReport{Used: 100, Total: 1000},
+		Swap:        v2.RamReport{Used: 20, Total: 200},
+		Load:        v2.LoadReport{Load1: 0.5},
+		Disk:        v2.DiskReport{Used: 300, Total: 3000},
+		Network:     v2.NetworkReport{Up: 3, Down: 4, TotalUp: 100, TotalDown: 200},
 		Process:     7,
-		Connections: v1.ConnectionsReport{TCP: 8, UDP: 9},
-		GPU: &v1.GPUDetailReport{
+		Connections: v2.ConnectionsReport{TCP: 8, UDP: 9},
+		GPU: &v2.GPUDetailReport{
 			AverageUsage: 25,
-			DetailedInfo: []v1.GPUDeviceInfo{{
+			DetailedInfo: []v2.GPUDeviceInfo{{
 				Name: "GPU 0", MemoryUsed: 400, MemoryTotal: 800, Utilization: 30, Temperature: 55,
 			}},
 		},
@@ -126,7 +248,7 @@ func TestWriteReportSkipsMetricsWithoutAgentData(t *testing.T) {
 	ctx := context.Background()
 	s := useReportTestStore(t, nil)
 	timestamp := time.Now().UTC()
-	if _, err := WriteReport(ctx, v1.Report{
+	if _, err := WriteReport(ctx, v2.Report{
 		UUID: "node-without-gpu", UpdatedAt: timestamp,
 	}); err != nil {
 		t.Fatalf("write report: %v", err)
@@ -154,11 +276,11 @@ func TestReportBatcherFlushesQueuedReports(t *testing.T) {
 	})

 	base := time.Now().UTC().Truncate(time.Minute).Add(10 * time.Second)
-	first := v1.Report{
+	first := v2.Report{
 		UUID:      "batched-node",
 		UpdatedAt: base,
-		CPU:       v1.CPUReport{Usage: 10},
-		Network:   v1.NetworkReport{TotalUp: 100, TotalDown: 200},
+		CPU:       v2.CPUReport{Usage: 10},
+		Network:   v2.NetworkReport{TotalUp: 100, TotalDown: 200},
 	}
 	second := first
 	second.UpdatedAt = base.Add(3 * time.Second)
@@ -271,11 +393,11 @@ func TestReportBatchKeepsEverySample(t *testing.T) {
 	ctx := context.Background()
 	s := useReportTestStore(t, nil)
 	base := time.Now().UTC().Truncate(time.Second)
-	pending := []v1.Report{
-		{UUID: "node-a", UpdatedAt: base, CPU: v1.CPUReport{Usage: 10}, Network: v1.NetworkReport{TotalUp: 100}},
-		{UUID: "node-a", UpdatedAt: base, CPU: v1.CPUReport{Usage: 20}, Network: v1.NetworkReport{TotalUp: 150}},
-		{UUID: "node-b", UpdatedAt: base, CPU: v1.CPUReport{Usage: 30}, Network: v1.NetworkReport{TotalUp: 200}},
-		{UUID: "node-b", UpdatedAt: base.Add(time.Second), CPU: v1.CPUReport{Usage: 40}, Network: v1.NetworkReport{TotalUp: 260}},
+	pending := []v2.Report{
+		{UUID: "node-a", UpdatedAt: base, CPU: v2.CPUReport{Usage: 10}, Network: v2.NetworkReport{TotalUp: 100}},
+		{UUID: "node-a", UpdatedAt: base, CPU: v2.CPUReport{Usage: 20}, Network: v2.NetworkReport{TotalUp: 150}},
+		{UUID: "node-b", UpdatedAt: base, CPU: v2.CPUReport{Usage: 30}, Network: v2.NetworkReport{TotalUp: 200}},
+		{UUID: "node-b", UpdatedAt: base.Add(time.Second), CPU: v2.CPUReport{Usage: 40}, Network: v2.NetworkReport{TotalUp: 260}},
 	}

 	if err := writePendingReports(ctx, &pending); err != nil {
@@ -292,11 +414,11 @@ func TestReportQueueFullReturnsError(t *testing.T) {
 	ctx := context.Background()
 	useReportTestStore(t, nil)
 	worker := &reportBatchWorker{
-		queue:    make(chan v1.Report, 1),
+		queue:    make(chan v2.Report, 1),
 		requests: make(chan reportBatchRequest, 1),
 		done:     make(chan struct{}),
 	}
-	worker.queue <- v1.Report{UUID: "already-queued"}
+	worker.queue <- v2.Report{UUID: "already-queued"}
 	reportBatcherMu.Lock()
 	reportBatcher = worker
 	reportBatcherMu.Unlock()
@@ -308,7 +430,7 @@ func TestReportQueueFullReturnsError(t *testing.T) {
 		reportBatcherMu.Unlock()
 	})

-	report := v1.Report{
+	report := v2.Report{
 		UUID:      "realtime-node",
 		UpdatedAt: time.Now().UTC(),
 	}
@@ -348,6 +470,10 @@ func TestRecordReconstructionUsesMetricSpecificAggregation(t *testing.T) {
 }

 func TestTrafficCounterDelta(t *testing.T) {
+	const (
+		oneGB = int64(1_000_000_000)
+		oneTB = int64(1_000_000_000_000)
+	)
 	tests := []struct {
 		name     string
 		current  int64
@@ -360,6 +486,11 @@ func TestTrafficCounterDelta(t *testing.T) {
 		{name: "counter reset", current: 15, previous: 250, want: 15},
 		{name: "negative current", current: -1, previous: 100, want: 0},
 		{name: "negative previous", current: 15, previous: -1, want: 0},
+		{name: "tb-scale monotonic", current: 2*oneTB + 5*oneGB, previous: 2 * oneTB, want: 5 * oneGB},
+		{name: "32-bit wrap leftover", current: 800_000_000, previous: 3*oneGB + 900_000_000, want: 800_000_000},
+		{name: "reboot leftover below cap", current: 8 * oneGB, previous: 2 * oneTB, want: 8 * oneGB},
+		{name: "tb-scale tiny dip", current: 2*oneTB - 100, previous: 2 * oneTB, want: 0},
+		{name: "tb-scale false reset", current: 2*oneTB + 5*oneGB - 1000, previous: 2*oneTB + 5*oneGB, want: 0},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
@@ -370,16 +501,211 @@ func TestTrafficCounterDelta(t *testing.T) {
 	}
 }

+func TestWriteReportRebasesTrafficAfterAgentRestart(t *testing.T) {
+	ctx := context.Background()
+	s := useReportTestStore(t, nil)
+	base := time.Now().UTC().Truncate(time.Minute).Add(5 * time.Second)
+	report := v2.Report{
+		UUID:      "restarted-node",
+		UpdatedAt: base,
+		Uptime:    1000,
+		Network:   v2.NetworkReport{TotalUp: 100, TotalDown: 200},
+	}
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write first report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(3 * time.Second)
+	report.Uptime = 1003
+	report.Network.TotalUp = 150
+	report.Network.TotalDown = 260
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write continuous report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(6 * time.Second)
+	report.Uptime = 1
+	report.Network.TotalUp = 155
+	report.Network.TotalDown = 265
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write report after agent restart: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(9 * time.Second)
+	report.Uptime = 4
+	report.Network.TotalUp = 180
+	report.Network.TotalDown = 300
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write report after new baseline: %v", err)
+	}
+
+	assertMetricValues(t, s, MetricTrafficUp, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, 50, 5, 25})
+	assertMetricValues(t, s, MetricTrafficDown, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, 60, 5, 35})
+}
+
+func TestWriteReportCountsTBScaleTrafficDeltas(t *testing.T) {
+	const (
+		oneGB = int64(1_000_000_000)
+		oneTB = int64(1_000_000_000_000)
+	)
+	ctx := context.Background()
+	s := useReportTestStore(t, nil)
+	base := time.Now().UTC().Truncate(time.Minute).Add(5 * time.Second)
+	report := v2.Report{
+		UUID:      "tb-node",
+		UpdatedAt: base,
+		Uptime:    10_000,
+		Network:   v2.NetworkReport{TotalUp: 2 * oneTB, TotalDown: 3 * oneTB},
+	}
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write first report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(3 * time.Second)
+	report.Uptime = 10_003
+	report.Network.TotalUp = 2*oneTB + 5*oneGB
+	report.Network.TotalDown = 3*oneTB + 7*oneGB
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write growing report: %v", err)
+	}
+
+	assertMetricValues(t, s, MetricTrafficUp, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, float64(5 * oneGB)})
+	assertMetricValues(t, s, MetricTrafficDown, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, float64(7 * oneGB)})
+}
+
+func TestWriteReportRestoresTBScaleCountersFromStore(t *testing.T) {
+	const (
+		oneGB = int64(1_000_000_000)
+		oneTB = int64(1_000_000_000_000)
+	)
+	ctx := context.Background()
+	policy := defaultRollupPolicy()
+	s := useReportTestStore(t, &policy)
+	base := time.Now().UTC().Truncate(time.Minute).Add(5 * time.Second)
+	now := base.Add(45 * time.Second)
+	report := v2.Report{
+		UUID:      "tb-restore-node",
+		UpdatedAt: base,
+		Uptime:    10_000,
+		Network:   v2.NetworkReport{TotalUp: 2*oneTB + 123, TotalDown: 4*oneTB + 456},
+	}
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write first report: %v", err)
+	}
+
+	restoredUp, hasUp, err := latestReportCounter(ctx, s, MetricNetTotalUp, report.UUID, now)
+	if err != nil {
+		t.Fatalf("restore upload counter: %v", err)
+	}
+	if !hasUp || restoredUp != report.Network.TotalUp {
+		t.Fatalf("restored upload counter = %d (has=%v), want %d", restoredUp, hasUp, report.Network.TotalUp)
+	}
+	restoredDown, hasDown, err := latestReportCounter(ctx, s, MetricNetTotalDown, report.UUID, now)
+	if err != nil {
+		t.Fatalf("restore download counter: %v", err)
+	}
+	if !hasDown || restoredDown != report.Network.TotalDown {
+		t.Fatalf("restored download counter = %d (has=%v), want %d", restoredDown, hasDown, report.Network.TotalDown)
+	}
+
+	if _, err := s.Compact(ctx, now); err != nil {
+		t.Fatalf("compact reports: %v", err)
+	}
+	deleteReportTrafficState(report.UUID)
+	report.UpdatedAt = now
+	report.Uptime = 10_045
+	report.Network.TotalUp = 2*oneTB + 123 + 5*oneGB
+	report.Network.TotalDown = 4*oneTB + 456 + 7*oneGB
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write after restoring tb-scale baseline: %v", err)
+	}
+	assertMetricValues(t, s, MetricTrafficUp, report.UUID, now.Add(-time.Second), now.Add(time.Second), []float64{float64(5 * oneGB)})
+	assertMetricValues(t, s, MetricTrafficDown, report.UUID, now.Add(-time.Second), now.Add(time.Second), []float64{float64(7 * oneGB)})
+}
+
+func TestWriteReportCountsTrafficAfterHighRateCounterWrap(t *testing.T) {
+	const oneGB = int64(1_000_000_000)
+	ctx := context.Background()
+	s := useReportTestStore(t, nil)
+	base := time.Now().UTC().Truncate(time.Minute).Add(5 * time.Second)
+	report := v2.Report{
+		UUID:      "wrap-node",
+		UpdatedAt: base,
+		Uptime:    10_000,
+		Network:   v2.NetworkReport{TotalUp: 3*oneGB + 900_000_000, TotalDown: 3*oneGB + 800_000_000},
+	}
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write first report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(3 * time.Second)
+	report.Uptime = 10_003
+	report.Network.TotalUp = 800_000_000
+	report.Network.TotalDown = 900_000_000
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write wrapped report: %v", err)
+	}
+
+	assertMetricValues(t, s, MetricTrafficUp, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, 800_000_000})
+	assertMetricValues(t, s, MetricTrafficDown, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, 900_000_000})
+}
+
+func TestWriteReportIgnoresTinyDipOfTBScaleCounter(t *testing.T) {
+	const (
+		oneGB = int64(1_000_000_000)
+		oneTB = int64(1_000_000_000_000)
+	)
+	ctx := context.Background()
+	s := useReportTestStore(t, nil)
+	base := time.Now().UTC().Truncate(time.Minute).Add(5 * time.Second)
+	report := v2.Report{
+		UUID:      "tb-jitter-node",
+		UpdatedAt: base,
+		Uptime:    10_000,
+		Network:   v2.NetworkReport{TotalUp: 2 * oneTB, TotalDown: 3 * oneTB},
+	}
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write first report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(3 * time.Second)
+	report.Uptime = 10_003
+	report.Network.TotalUp = 2*oneTB + 5*oneGB
+	report.Network.TotalDown = 3*oneTB + 7*oneGB
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write growing report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(6 * time.Second)
+	report.Uptime = 10_006
+	report.Network.TotalUp = 2*oneTB + 5*oneGB - 1000
+	report.Network.TotalDown = 3*oneTB + 7*oneGB - 2000
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write jitter report: %v", err)
+	}
+
+	report.UpdatedAt = base.Add(9 * time.Second)
+	report.Uptime = 10_009
+	report.Network.TotalUp = 2*oneTB + 6*oneGB
+	report.Network.TotalDown = 3*oneTB + 8*oneGB
+	if _, err := WriteReport(ctx, report); err != nil {
+		t.Fatalf("write recovered report: %v", err)
+	}
+
+	assertMetricValues(t, s, MetricTrafficUp, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, float64(5 * oneGB), 0, float64(oneGB + 1000)})
+	assertMetricValues(t, s, MetricTrafficDown, report.UUID, base.Add(-time.Second), base.Add(time.Minute), []float64{0, float64(7 * oneGB), 0, float64(oneGB + 2000)})
+}
+
 func TestWriteReportNormalizesReceiveTimeToUTC(t *testing.T) {
 	ctx := context.Background()
 	s := useReportTestStore(t, nil)
 	local := time.FixedZone("UTC+8", 8*60*60)
 	receiveTime := time.Now().In(local).Add(-10 * time.Second)
-	report := v1.Report{
+	report := v2.Report{
 		UUID:      "utc-report",
 		UpdatedAt: receiveTime,
-		CPU:       v1.CPUReport{Usage: 10},
-		Network:   v1.NetworkReport{TotalUp: 1, TotalDown: 2},
+		CPU:       v2.CPUReport{Usage: 10},
+		Network:   v2.NetworkReport{TotalUp: 1, TotalDown: 2},
 	}

 	saved, err := WriteReport(ctx, report)
@@ -0,0 +1,290 @@
+package metricstore
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	logger "github.com/komari-monitor/komari/utils/log"
+
+	"github.com/komari-monitor/komari/internal/config"
+	"github.com/komari-monitor/komari/pkg/metric"
+)
+
+var (
+	store             *metric.Store
+	storeFingerprint  string
+	storeMu           sync.RWMutex
+	storeInitMu       sync.Mutex
+	storeOperations   = newStoreOperationGate()
+	compactOperations = newStoreOperationGate()
+)
+
+var ErrCompactInProgress = errors.New("metric store compact already in progress")
+
+// ErrStructureUpgradeRequired reports that the configured store must be
+// migrated by the restricted startup guide before it can be opened normally.
+var ErrStructureUpgradeRequired = errors.New("metric store structure upgrade is required")
+
+// openStore 按配置打开 metric store 并创建指标定义。
+func openStore(ctx context.Context, cfg *MetricStoreConfig) (*metric.Store, error) {
+	return openStoreWithDefaultRetention(ctx, cfg, defaultBuiltinMetricRetentionDays)
+}
+
+func openStoreWithDefaultRetention(ctx context.Context, cfg *MetricStoreConfig, defaultRetentionDays int) (*metric.Store, error) {
+	metricCfg, err := buildMetricConfig(cfg, true)
+	if err != nil {
+		return nil, err
+	}
+
+	s, err := metric.Open(ctx, metricCfg)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open metric store: %w", err)
+	}
+
+	if err := createMetricDefinitionsWithDefaultRetention(ctx, s, defaultRetentionDays); err != nil {
+		s.Close()
+		return nil, fmt.Errorf("failed to create metric definitions: %w", err)
+	}
+
+	return s, nil
+}
+
+// OpenStore opens an isolated metric store using the supplied configuration.
+// It is used by the pre-start upgrade flow before the process-wide store is
+// initialized. The caller owns the returned store and must close it.
+// func OpenStore(ctx context.Context, cfg *MetricStoreConfig) (*metric.Store, error) {
+// 	return openStore(ctx, cfg)
+// }
+
+// OpenStoreForMigration opens an isolated target and uses the legacy data span
+// as the initial retention for definitions that do not exist yet. Existing
+// definitions keep their configured retention, including an explicit zero.
+func OpenStoreForMigration(ctx context.Context, cfg *MetricStoreConfig, legacyRetentionDays int) (*metric.Store, error) {
+	if legacyRetentionDays < defaultBuiltinMetricRetentionDays {
+		legacyRetentionDays = defaultBuiltinMetricRetentionDays
+	}
+	return openStoreWithDefaultRetention(ctx, cfg, legacyRetentionDays)
+}
+
+// TestConnection 使用给定配置尝试连接 metrics 数据库（不影响当前运行的 store）。
+// 仅打开连接并 Ping，不执行自动建表，连接成功后立即关闭。失败时返回可读错误。
+func TestConnection(ctx context.Context, cfg *MetricStoreConfig) error {
+	metricCfg, err := buildMetricConfig(cfg, false)
+	if err != nil {
+		return err
+	}
+
+	s, err := metric.Open(ctx, metricCfg)
+	if err != nil {
+		return err
+	}
+	defer s.Close()
+
+	return s.Ping(ctx)
+}
+
+// InitializeStore 初始化 metric store（启动时调用，可在失败后重试）。
+func InitializeStore() error {
+	storeInitMu.Lock()
+	defer storeInitMu.Unlock()
+
+	// A previous failed connection must remain retryable. The old sync.Once
+	// implementation consumed the one-time call on failure and returned nil on
+	// every later call while the store was still nil.
+	storeMu.RLock()
+	initialized := store != nil
+	storeMu.RUnlock()
+	if initialized {
+		return nil
+	}
+
+	cfg, err := config.GetManyAs[MetricStoreConfig]()
+	if err != nil {
+		return fmt.Errorf("failed to load metric store config: %w", err)
+	}
+
+	// metric store 始终启用；未配置时默认 SQLite（./data/metrics.db）。
+	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+
+	s, err := openStore(ctx, cfg)
+	if err != nil {
+		return err
+	}
+
+	storeMu.Lock()
+	store = s
+	storeFingerprint = targetFingerprint(cfg)
+	storeMu.Unlock()
+	clearStoreClosing()
+
+	logger.Infof("metricstore", "Metric store initialized successfully (driver=%s)", ResolveDriverFromConfig(cfg.Driver, cfg.DSN))
+	return nil
+}
+
+// RecoverStore opens, persists, and activates a replacement store selected
+// from the restricted recovery page. It records that target as the current
+// manual-migration source, but does not copy data from the unavailable store.
+func RecoverStore(ctx context.Context, cfg *MetricStoreConfig) error {
+	if cfg == nil {
+		return fmt.Errorf("metric store recovery config is nil")
+	}
+
+	storeInitMu.Lock()
+	defer storeInitMu.Unlock()
+	if err := storeOperations.Acquire(ctx); err != nil {
+		return fmt.Errorf("wait for metric store operations before recovery: %w", err)
+	}
+	defer storeOperations.Release()
+	if isStoreClosing() {
+		return ErrStoreBusy
+	}
+
+	recovered := *cfg
+	recovered.DSN = strings.TrimSpace(recovered.DSN)
+	recovered.Driver = string(ResolveDriverFromConfig(recovered.Driver, recovered.DSN))
+	restructureRequired, err := structureUpgradeRequiredForConfig(ctx, &recovered)
+	if err != nil {
+		return err
+	}
+	if restructureRequired {
+		target := targetFingerprint(&recovered)
+		if err := config.SetMany(map[string]any{
+			MetricDBDriverKey:  recovered.Driver,
+			MetricDBDSNKey:     recovered.DSN,
+			MigrationTargetKey: target,
+		}); err != nil {
+			return fmt.Errorf("save recovered metric store config: %w", err)
+		}
+		logger.Infof("metricstore", "Metric store connection recovered; structure upgrade is required (driver=%s)", recovered.Driver)
+		return nil
+	}
+	s, err := openStore(ctx, &recovered)
+	if err != nil {
+		return err
+	}
+
+	target := targetFingerprint(&recovered)
+	if err := config.SetMany(map[string]any{
+		MetricDBDriverKey:  recovered.Driver,
+		MetricDBDSNKey:     recovered.DSN,
+		MigrationTargetKey: target,
+	}); err != nil {
+		_ = s.Close()
+		return fmt.Errorf("save recovered metric store config: %w", err)
+	}
+
+	storeMu.Lock()
+	old := store
+	store = s
+	storeFingerprint = target
+	storeMu.Unlock()
+	clearStoreClosing()
+
+	if old != nil {
+		if closeErr := old.Close(); closeErr != nil {
+			logger.Errorf("metricstore", "Failed to close previous metric store during recovery: %v", closeErr)
+		}
+	}
+	logger.Infof("metricstore", "Metric store recovered successfully (driver=%s)", recovered.Driver)
+	return nil
+}
+
+// Reload 根据最新配置热重载 metric store，无需重启进程。
+// metric store 始终启用：用新配置打开并建表（内部已 Ping 校验连接），
+// 成功后再替换运行中的 store，最后关闭旧实例。任何失败都会保留旧 store 不变。
+//
+// 注意：Reload 只切换运行中的连接，不会把旧目标（如 SQLite）中的历史数据
+// 搬运到新目标（如 MySQL/PostgreSQL）。跨库数据迁移必须由管理员手动启动。
+func Reload(ctx context.Context) error {
+	if err := storeOperations.Acquire(ctx); err != nil {
+		return fmt.Errorf("wait for metric store operations before reload: %w", err)
+	}
+	defer storeOperations.Release()
+	if isStoreClosing() {
+		return ErrStoreBusy
+	}
+
+	cfg, err := config.GetManyAs[MetricStoreConfig]()
+	if err != nil {
+		return fmt.Errorf("failed to load metric store config: %w", err)
+	}
+
+	// Do not let the normal hot-reload path run AutoMigrate against an old
+	// point-backed schema. That schema must go through the authenticated
+	// structure-upgrade guide first; otherwise index creation can reference
+	// columns such as resolution_id that do not exist yet.
+	checkCfg, err := buildMetricConfig(cfg, false)
+	if err != nil {
+		return err
+	}
+	checkStore, err := metric.Open(ctx, checkCfg)
+	if err != nil {
+		return err
+	}
+	needsRestructure, err := checkStore.NeedsRestructure(ctx)
+	_ = checkStore.Close()
+	if err != nil {
+		return fmt.Errorf("inspect metric store structure: %w", err)
+	}
+	if needsRestructure {
+		return fmt.Errorf("%w before hot reload", ErrStructureUpgradeRequired)
+	}
+
+	// 用新配置打开并建表（内部已 Ping 校验连接）。
+	s, err := openStore(ctx, cfg)
+	if err != nil {
+		return err
+	}
+
+	storeMu.Lock()
+	old := store
+	store = s
+	storeFingerprint = targetFingerprint(cfg)
+	storeMu.Unlock()
+	if old != nil {
+		if cerr := old.Close(); cerr != nil {
+			logger.Errorf("metricstore", "Failed to close previous metric store on reload: %v", cerr)
+		}
+	}
+
+	logger.Infof("metricstore", "Metric store reloaded successfully (driver=%s)", ResolveDriverFromConfig(cfg.Driver, cfg.DSN))
+	return nil
+}
+
+// GetStore 获取 metric store 实例（如果未启用返回 nil）
+func GetStore() *metric.Store {
+	storeMu.RLock()
+	defer storeMu.RUnlock()
+	return store
+}
+
+// CloseStoreContext stops the asynchronous store migration before taking the
+// store write lock, so shutdown cannot wait forever on the migration's lease.
+func CloseStoreContext(ctx context.Context) error {
+	if err := stopStoreMigrationForClose(ctx); err != nil {
+		clearStoreClosing()
+		return err
+	}
+	if err := storeOperations.Acquire(ctx); err != nil {
+		clearStoreClosing()
+		return fmt.Errorf("wait for metric store operations before close: %w", err)
+	}
+	defer storeOperations.Release()
+
+	storeMu.Lock()
+	defer storeMu.Unlock()
+
+	if store != nil {
+		err := store.Close()
+		store = nil
+		storeFingerprint = ""
+		return err
+	}
+	storeFingerprint = ""
+	return nil
+}
@@ -3,11 +3,12 @@ package metricstore
 import (
 	"context"
 	"fmt"
-	logger "github.com/komari-monitor/komari/utils/log"
 	"strings"
 	"sync"
 	"time"

+	logger "github.com/komari-monitor/komari/utils/log"
+
 	"github.com/komari-monitor/komari/internal/config"
 	"github.com/komari-monitor/komari/pkg/metric"
 )
@@ -11,7 +11,7 @@ import (
 	"strings"
 	"time"

-	"github.com/komari-monitor/komari/database/metricstore"
+	"github.com/komari-monitor/komari/internal/metricstore"
 	"github.com/komari-monitor/komari/database/models"
 	appconfig "github.com/komari-monitor/komari/internal/config"
 	"github.com/komari-monitor/komari/pkg/metric"
@@ -9,7 +9,7 @@ import (
 	"testing"
 	"time"

-	"github.com/komari-monitor/komari/database/metricstore"
+	"github.com/komari-monitor/komari/internal/metricstore"
 	"github.com/komari-monitor/komari/database/models"
 	appconfig "github.com/komari-monitor/komari/internal/config"
 	"github.com/komari-monitor/komari/pkg/metric"
@@ -0,0 +1,83 @@
+package plugin
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/internal/managedconfig"
+	"gorm.io/gorm"
+)
+
+// GetConfiguration returns the saved configuration values of one plugin,
+// merged with the manifest-declared defaults for keys that were never saved.
+// This mirrors the theme configuration behavior so plugins and the admin UI
+// always see a complete value set. Missing rows yield only defaults; a
+// missing manifest yields only the saved values.
+func GetConfiguration(short string) (map[string]any, error) {
+	values, err := savedConfiguration(short)
+	if err != nil {
+		return nil, err
+	}
+	info, err := readManifest(filepath.Join(DataDir, short))
+	if err != nil {
+		return values, nil // not installed (or unreadable): keep saved values
+	}
+	items := managedconfig.Items(info.Configuration)
+	mergeConfigurationDefaults(values, items)
+	if err := managedconfig.ResolveForOutput(values, items); err != nil {
+		return nil, fmt.Errorf("resolve plugin configuration: %w", err)
+	}
+	return values, nil
+}
+
+func savedConfiguration(short string) (map[string]any, error) {
+	db := dbcore.GetDBInstance()
+	var cfg models.PluginConfiguration
+	if err := db.Where("short = ?", short).First(&cfg).Error; err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return map[string]any{}, nil
+		}
+		return nil, fmt.Errorf("read plugin configuration: %w", err)
+	}
+	var data map[string]any
+	if err := json.Unmarshal([]byte(cfg.Data), &data); err != nil || data == nil {
+		return map[string]any{}, nil
+	}
+	return data, nil
+}
+
+// mergeConfigurationDefaults fills manifest-declared defaults for keys that
+// are missing from the saved values, following the theme merge rules.
+func mergeConfigurationDefaults(values map[string]any, items []models.ManagedThemeConfigurationItem) {
+	for _, item := range items {
+		if item.Key == "" {
+			continue
+		}
+		if _, exists := values[item.Key]; exists {
+			continue
+		}
+		values[item.Key] = managedconfig.DefaultValue(item)
+	}
+}
+
+// SaveConfiguration upserts the configuration values of one plugin.
+func SaveConfiguration(short string, data map[string]any) error {
+	if data == nil {
+		data = map[string]any{}
+	}
+	raw, err := json.Marshal(data)
+	if err != nil {
+		return fmt.Errorf("marshal plugin configuration: %w", err)
+	}
+	db := dbcore.GetDBInstance()
+	if err := db.Where("short = ?", short).
+		Assign(models.PluginConfiguration{Short: short, Data: string(raw)}).
+		FirstOrCreate(&models.PluginConfiguration{}).Error; err != nil {
+		return fmt.Errorf("save plugin configuration: %w", err)
+	}
+	return nil
+}
@@ -0,0 +1,97 @@
+package plugin
+
+import (
+	"net"
+	"net/http"
+	"strings"
+
+	"github.com/dop251/goja"
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/pkg/rpc"
+)
+
+// principalContextKey stays in sync with web/api/principal.go:
+// IdentityMiddleware stores the resolved principal under this gin key.
+const principalContextKey = "principal"
+
+// routeRequestContext builds the JS request context with the caller identity
+// resolved by IdentityMiddleware. Raw credentials (session/client tokens) are
+// intentionally not exposed.
+func routeRequestContext(vm *goja.Runtime, c *gin.Context) *goja.Object {
+	ctx := vm.NewObject()
+	principal := rpcPrincipalFromGin(c)
+	p := vm.NewObject()
+	if principal != nil {
+		_ = p.Set("type", principalTypeString(principal.Type))
+		_ = p.Set("roles", principal.Roles)
+		_ = p.Set("user_uuid", principal.UserUUID)
+		_ = p.Set("client_uuid", principal.ClientUUID)
+		_ = p.Set("is_api_key", principal.IsAPIKey)
+	}
+	_ = ctx.Set("principal", p)
+	if role, ok := c.Get("role"); ok {
+		if s, ok := role.(string); ok {
+			_ = ctx.Set("role", s)
+		}
+	}
+	if uuid, ok := c.Get("uuid"); ok {
+		_ = ctx.Set("user_uuid", uuid)
+	}
+	if clientUUID, ok := c.Get("client_uuid"); ok {
+		_ = ctx.Set("client_uuid", clientUUID)
+	}
+	_ = ctx.Set("remote_ip", c.ClientIP())
+	_ = ctx.Set("user_agent", c.GetHeader("User-Agent"))
+	return ctx
+}
+
+// hookRequestContext builds the JS request context at the raw HTTP layer
+// (before the gin identity middleware runs): only network metadata is
+// available there.
+func hookRequestContext(vm *goja.Runtime, r *http.Request) *goja.Object {
+	ctx := vm.NewObject()
+	_ = ctx.Set("remote_ip", remoteIP(r))
+	_ = ctx.Set("user_agent", r.Header.Get("User-Agent"))
+	return ctx
+}
+
+func rpcPrincipalFromGin(c *gin.Context) *rpc.Principal {
+	value, ok := c.Get(principalContextKey)
+	if !ok {
+		return nil
+	}
+	principal, _ := value.(*rpc.Principal)
+	return principal
+}
+
+func principalTypeString(t rpc.PrincipalType) string {
+	switch t {
+	case rpc.PrincipalAgent:
+		return "agent"
+	case rpc.PrincipalUser:
+		return "user"
+	case rpc.PrincipalAPIKey:
+		return "api_key"
+	default:
+		return "anonymous"
+	}
+}
+
+// remoteIP mirrors gin's ClientIP for the raw request layer: first
+// X-Forwarded-For entry, then X-Real-IP, then the RemoteAddr host.
+func remoteIP(r *http.Request) string {
+	if forwarded := r.Header.Get("X-Forwarded-For"); forwarded != "" {
+		if first, _, ok := strings.Cut(forwarded, ","); ok {
+			return strings.TrimSpace(first)
+		}
+		return strings.TrimSpace(forwarded)
+	}
+	if real := r.Header.Get("X-Real-IP"); real != "" {
+		return strings.TrimSpace(real)
+	}
+	host, _, err := net.SplitHostPort(r.RemoteAddr)
+	if err != nil {
+		return r.RemoteAddr
+	}
+	return host
+}
@@ -0,0 +1,72 @@
+package plugin
+
+import (
+	"context"
+	"fmt"
+	"sync/atomic"
+
+	"github.com/dop251/goja"
+	"github.com/komari-monitor/komari/internal/scheduler"
+)
+
+// cronJobSeq gives every registered cron job a process-unique id. Job names
+// stay unique across plugin reloads because unload cancels every job of the
+// plugin before a new load registers replacements.
+var cronJobSeq atomic.Uint64
+
+// registerCron registers one cron job for a plugin. The handler is a
+// JavaScript function that runs on the plugin's own event loop each time the
+// schedule fires. It is called from the plugin's own event loop during script
+// evaluation and takes the manager lock itself; the critical section is short
+// and never waits on the event loop, so no lock cycle is possible. The job is
+// removed automatically when the plugin is unloaded or fails to load.
+func (m *Manager) registerCron(short, spec string, fn goja.Callable) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	inst, ok := m.instances[short]
+	if !ok {
+		return fmt.Errorf("plugin %q is not loaded", short)
+	}
+	inst.mu.RLock()
+	host := inst.host
+	alive := inst.runtime != nil
+	inst.mu.RUnlock()
+	if !alive || host == nil {
+		return fmt.Errorf("plugin %q runtime is not ready", short)
+	}
+
+	name := fmt.Sprintf("plugin:%s:%d", short, cronJobSeq.Add(1))
+	if err := scheduler.AddContextFunc(name, spec, false, func(ctx context.Context) {
+		m.runCronJob(short, name, fn)
+	}); err != nil {
+		return err
+	}
+	inst.mu.Lock()
+	inst.cronJobs = append(inst.cronJobs, name)
+	inst.mu.Unlock()
+	return nil
+}
+
+// runCronJob bridges one scheduled fire into the plugin event loop. It runs
+// on a scheduler goroutine and drops the fire when the plugin was unloaded
+// (the job is cancelled with the instance, but a fire may already be queued).
+// Errors thrown by the handler are reported to the plugin log by RunJob.
+func (m *Manager) runCronJob(short, name string, fn goja.Callable) {
+	inst := m.instanceFor(short)
+	if inst == nil {
+		return
+	}
+	inst.mu.RLock()
+	host := inst.host
+	alive := inst.runtime != nil
+	inst.mu.RUnlock()
+	if !alive || host == nil {
+		return
+	}
+	host.RunOnLoop(func(vm *goja.Runtime) {
+		_ = host.RunJob(vm, "plugin cron "+name, func() error {
+			_, err := fn(goja.Undefined())
+			return err
+		})
+	})
+}
@@ -0,0 +1,896 @@
+package plugin
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/database/dbcore"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/rpc"
+)
+
+const featureManifest = `{"name":"Feat","short":"feat","version":"1.0.0","permissions":{"timeout":5,"allowRoutes":true,"allowHooks":true}}`
+
+func TestHookRequestAndResponse(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	engine.GET("/ping", func(c *gin.Context) {
+		if c.GetHeader("x-hooked") != "yes" {
+			c.String(http.StatusBadRequest, "missing x-hooked")
+			return
+		}
+		c.String(http.StatusOK, "pong")
+	})
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("request", (req) => {
+					req.headers["x-hooked"] = "yes";
+				});
+				server.hook("response", (req, res) => {
+					res.statusCode = 201;
+					res.headers["x-res"] = "1";
+					res.body = res.body + "|hooked";
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+
+	// 用 WrapHandler 包裹（对应 internal/server 的接入点）
+	wrapped := WrapHandler(engine)
+
+	rec := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/ping", nil))
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+	if rec.Body.String() != "pong|hooked" {
+		t.Fatalf("body = %q", rec.Body.String())
+	}
+	if rec.Header().Get("x-res") != "1" {
+		t.Fatalf("headers = %v", rec.Header())
+	}
+
+	// 卸载后 hook 移除：请求不再带 x-hooked，handler 返回 400
+	if err := SetEnabled("feat", false, false); err != nil {
+		t.Fatal(err)
+	}
+	rec2 := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec2, httptest.NewRequest(http.MethodGet, "/ping", nil))
+	if rec2.Code != http.StatusBadRequest || !strings.Contains(rec2.Body.String(), "missing x-hooked") {
+		t.Fatalf("after unload status = %d, body = %q", rec2.Code, rec2.Body.String())
+	}
+}
+
+func TestHookUpgradePassesThrough(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	engine.GET("/ws", func(c *gin.Context) {
+		c.String(http.StatusOK, "direct")
+	})
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("request", (req) => { req.headers["x"] = "y"; });
+				server.hook("response", (req, res) => { res.body = "changed"; });
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/ws", nil)
+	req.Header.Set("Connection", "upgrade")
+	req.Header.Set("Upgrade", "websocket")
+	WrapHandler(engine).ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK || rec.Body.String() != "direct" {
+		t.Fatalf("upgrade passthrough failed: status = %d, body = %q", rec.Code, rec.Body.String())
+	}
+}
+
+func TestRegisterRPCCallableThroughRegistry(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.registerRPC("plugin:featEcho", (params) => {
+					return { echo: params, from: "feat" };
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+
+	resp := rpc.CallWithContext(context.Background(), nil, "plugin:featEcho", map[string]any{"x": 1})
+	if resp.Error != nil {
+		t.Fatalf("rpc error: %v", resp.Error)
+	}
+	result, ok := resp.Result.(map[string]any)
+	if !ok || result["from"] != "feat" {
+		t.Fatalf("result = %v", resp.Result)
+	}
+	echo, ok := result["echo"].(map[string]any)
+	if !ok || fmt.Sprint(echo["x"]) != "1" {
+		t.Fatalf("echo = %v", result["echo"])
+	}
+
+	// 卸载后方法注销
+	if err := SetEnabled("feat", false, false); err != nil {
+		t.Fatal(err)
+	}
+	resp2 := rpc.CallWithContext(context.Background(), nil, "plugin:featEcho", nil)
+	if resp2.Error == nil || resp2.Error.Code != rpc.MethodNotFound {
+		t.Fatalf("expected MethodNotFound after unload, got %v", resp2.Error)
+	}
+}
+
+func TestRegisterRPCErrorCarriesCode(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.registerRPC("plugin:featFail", () => {
+					const err = new Error("boom");
+					err.code = -32045;
+					err.data = { detail: "x" };
+					throw err;
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+
+	resp := rpc.CallWithContext(context.Background(), nil, "plugin:featFail", nil)
+	if resp.Error == nil {
+		t.Fatal("expected error")
+	}
+	if resp.Error.Code != -32045 || resp.Error.Message != "boom" {
+		t.Fatalf("error = %+v", resp.Error)
+	}
+	data, ok := resp.Error.Data.(map[string]any)
+	if !ok || data["detail"] != "x" {
+		t.Fatalf("error data = %v", resp.Error.Data)
+	}
+}
+
+func TestDeleteRemovesPlugin(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js":          `function load() { console.log("hi"); }`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	if err := Delete("feat"); err != nil {
+		t.Fatal(err)
+	}
+	if infos := List(); len(infos) != 0 {
+		t.Fatalf("List = %+v", infos)
+	}
+	if _, err := Manifest("feat"); err == nil {
+		t.Fatal("manifest should be gone")
+	}
+	if err := Delete("feat"); err == nil {
+		t.Fatal("second delete should fail")
+	}
+}
+
+// TestCronRunsOnScheduleAndStopsOnUnload 验证 server.cron 按表达式在插件事件
+// 循环上执行 handler，且卸载后任务被移除、不再触发。
+func TestCronRunsOnScheduleAndStopsOnUnload(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Cron","short":"cron","version":"1.0.0","permissions":{"node":true,"timeout":5}}`,
+		"script.js": `
+			const fs = require("fs");
+			const server = require("server");
+			function load() {
+				server.cron("@every 100ms", () => {
+					fs.appendFileSync("tick.txt", "x");
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("cron", true, true); err != nil {
+		t.Fatal(err)
+	}
+
+	tickFile := filepath.Join(DataDir, "cron", "tick.txt")
+	waitFor := func(minTicks int) int {
+		deadline := time.Now().Add(5 * time.Second)
+		for time.Now().Before(deadline) {
+			if data, err := os.ReadFile(tickFile); err == nil && len(data) >= minTicks {
+				return len(data)
+			}
+			time.Sleep(20 * time.Millisecond)
+		}
+		t.Fatalf("cron did not fire within 5s (need at least %d ticks)", minTicks)
+		return 0
+	}
+	if ticks := waitFor(3); ticks == 0 {
+		t.Fatal("cron fired but wrote no ticks")
+	}
+
+	// 卸载后任务被移除：两个采样窗口之间的计数不得再增长。
+	if err := SetEnabled("cron", false, false); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(300 * time.Millisecond)
+	first, _ := os.ReadFile(tickFile)
+	time.Sleep(300 * time.Millisecond)
+	second, _ := os.ReadFile(tickFile)
+	if len(second) != len(first) {
+		t.Fatalf("cron kept firing after unload: %d -> %d", len(first), len(second))
+	}
+}
+
+// TestCronInvalidSpecFailsLoad 验证非法 cron 表达式使插件加载失败并自动禁用。
+func TestCronInvalidSpecFailsLoad(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Cron","short":"cron","version":"1.0.0","permissions":{"node":true,"timeout":5}}`,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.cron("not a cron spec", () => {});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("cron", true, true); err == nil {
+		t.Fatal("invalid cron spec must fail the load")
+	}
+	infos := List()
+	if len(infos) != 1 || infos[0].Enabled || !strings.Contains(infos[0].LastError, "invalid") {
+		t.Fatalf("state after failed load = %+v", infos)
+	}
+}
+
+func TestConfigurationSaveAndGet(t *testing.T) {
+	withTempDataDir(t)
+	Init(gin.New())
+
+	if err := SaveConfiguration("feat", map[string]any{"greeting": "hello", "n": float64(3)}); err != nil {
+		t.Fatal(err)
+	}
+	values, err := GetConfiguration("feat")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if values["greeting"] != "hello" || values["n"] != float64(3) {
+		t.Fatalf("values = %v", values)
+	}
+	// 覆盖保存
+	if err := SaveConfiguration("feat", map[string]any{"greeting": "bye"}); err != nil {
+		t.Fatal(err)
+	}
+	values, err = GetConfiguration("feat")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if values["greeting"] != "bye" || len(values) != 1 {
+		t.Fatalf("values = %v", values)
+	}
+}
+
+// TestGetConfigurationMergesManifestDefaults 验证与主题一致的行为：未保存的
+// key 返回 manifest 声明的默认值（select 取首个选项、number->0、switch->false、
+// string->""），已保存的 key 保留保存值。
+func TestGetConfigurationMergesManifestDefaults(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Cfg","short":"cfg","version":"1.0.0","configuration":{"type":"managed","data":[
+			{"key":"greeting","name":"Greeting","type":"string","default":"Hello"},
+			{"key":"count","name":"Count","type":"number"},
+			{"key":"enabled","name":"Enabled","type":"switch","default":true},
+			{"key":"mode","name":"Mode","type":"select","options":"json,text"},
+			{"key":"note","name":"Note","type":"string"}
+		]}}`,
+		"script.js": `function load() {}`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// 未保存任何值时，全部返回默认值。
+	values, err := GetConfiguration("cfg")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if values["greeting"] != "Hello" {
+		t.Errorf("greeting default = %v", values["greeting"])
+	}
+	if values["count"] != float64(0) {
+		t.Errorf("count default = %v", values["count"])
+	}
+	if values["enabled"] != true {
+		t.Errorf("enabled default = %v", values["enabled"])
+	}
+	if values["mode"] != "json" {
+		t.Errorf("mode default = %v", values["mode"])
+	}
+	if values["note"] != "" {
+		t.Errorf("note default = %v", values["note"])
+	}
+
+	// 保存部分值：缺失 key 仍回退默认值，已保存 key 不被默认覆盖。
+	if err := SaveConfiguration("cfg", map[string]any{"greeting": "saved"}); err != nil {
+		t.Fatal(err)
+	}
+	values, err = GetConfiguration("cfg")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if values["greeting"] != "saved" {
+		t.Errorf("greeting saved = %v", values["greeting"])
+	}
+	if values["mode"] != "json" {
+		t.Errorf("mode still default = %v", values["mode"])
+	}
+}
+
+func TestGetConfigurationResolvesSelectorValues(t *testing.T) {
+	withTempDataDir(t)
+	if err := dbcore.GetDBInstance().Create(&models.Client{UUID: "node-a"}).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := dbcore.GetDBInstance().Create(&models.PingTask{Id: 8}).Error; err != nil {
+		t.Fatal(err)
+	}
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Cfg","short":"cfg","version":"1.0.0","configuration":{"type":"managed","data":[
+			{"key":"nodes","name":"Nodes","type":"nodes"},
+			{"key":"tasks","name":"Tasks","type":"pingtasks"}
+		]}}`,
+		"script.js": `function load() {}`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SaveConfiguration("cfg", map[string]any{
+		"nodes": `["node-a","deleted-node"]`,
+		"tasks": `[8,7]`,
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	values, err := GetConfiguration("cfg")
+	if err != nil {
+		t.Fatal(err)
+	}
+	nodes, ok := values["nodes"].([]string)
+	if !ok || len(nodes) != 1 || nodes[0] != "node-a" {
+		t.Fatalf("nodes = %#v", values["nodes"])
+	}
+	tasks, ok := values["tasks"].([]uint)
+	if !ok || len(tasks) != 1 || tasks[0] != 8 {
+		t.Fatalf("tasks = %#v", values["tasks"])
+	}
+
+	var stored models.PluginConfiguration
+	if err := dbcore.GetDBInstance().Where("short = ?", "cfg").First(&stored).Error; err != nil {
+		t.Fatal(err)
+	}
+	var raw map[string]any
+	if err := json.Unmarshal([]byte(stored.Data), &raw); err != nil {
+		t.Fatal(err)
+	}
+	if raw["nodes"] != `["node-a","deleted-node"]` || raw["tasks"] != `[8,7]` {
+		t.Fatalf("stored = %#v", raw)
+	}
+}
+
+func TestGetConfigFromScript(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	if err := SaveConfiguration("feat", map[string]any{"greeting": "saved-value"}); err != nil {
+		t.Fatal(err)
+	}
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.route("GET", "/cfg", async (req, res) => {
+					const cfg = await server.getConfig();
+					res.end(JSON.stringify(cfg));
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+
+	rec := httptest.NewRecorder()
+	engine := global.engine
+	engine.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/cfg", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+	var body map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil || body["greeting"] != "saved-value" {
+		t.Fatalf("body = %s", rec.Body.String())
+	}
+}
+
+func TestResolvePublicFileScopedToEnabledPublicPages(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Pub","short":"pub","version":"1.0.0","pages":[{"file":"pages/pub.html","title":"Pub","visibility":"public"},{"file":"admin.html","title":"Admin"}]}`,
+		"script.js":          `function load() {}`,
+		"pages/pub.html":     `<h1>pub</h1>`,
+		"pages/pub.js":       `console.log("asset")`,
+		"admin.html":         `<h1>admin</h1>`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// 未启用：公开文件不可访问。
+	if _, err := ResolvePublicFile("pub", "pages/pub.html"); err == nil {
+		t.Fatal("disabled plugin public page must not resolve")
+	}
+
+	// 启用后：页面与同目录资源可访问，admin 页面与目录外文件不可访问。
+	if err := SetEnabled("pub", true, true); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := ResolvePublicFile("pub", "pages/pub.html"); err != nil {
+		t.Fatalf("public page must resolve when enabled: %v", err)
+	}
+	if _, err := ResolvePublicFile("pub", "pages/pub.js"); err != nil {
+		t.Fatalf("relative asset must resolve: %v", err)
+	}
+	for _, bad := range []string{"admin.html", "script.js", "../evil"} {
+		if _, err := ResolvePublicFile("pub", bad); err == nil {
+			t.Fatalf("ResolvePublicFile(%q) should fail", bad)
+		}
+	}
+}
+func TestResolveFileRejectsTraversal(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js":          `function load() {}`,
+		"pages/hello.html":   `<h1>hello</h1>`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	full, err := ResolveFile("feat", "pages/hello.html")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.HasSuffix(full, "hello.html") {
+		t.Fatalf("path = %q", full)
+	}
+	for _, bad := range []string{"../evil", "/abs", "..", "pages/../evil"} {
+		if _, err := ResolveFile("feat", bad); err == nil {
+			t.Fatalf("ResolveFile(%q) should fail", bad)
+		}
+	}
+}
+
+func TestRouteRequestContextCarriesIdentity(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	// 模拟 IdentityMiddleware：写入 principal/role/uuid（与 web/api 一致）
+	engine.Use(func(c *gin.Context) {
+		c.Set("principal", rpc.NewUserPrincipal("user-1"))
+		c.Set("role", "admin")
+		c.Set("uuid", "user-1")
+		c.Next()
+	})
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.route("GET", "/who", (req, res) => {
+					res.end(JSON.stringify(req.context));
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/who", nil)
+	req.RemoteAddr = "203.0.113.9:1234"
+	engine.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+	var body map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("body = %s", rec.Body.String())
+	}
+	principal, ok := body["principal"].(map[string]any)
+	if !ok || principal["type"] != "user" || principal["user_uuid"] != "user-1" {
+		t.Fatalf("principal = %v", body["principal"])
+	}
+	if body["role"] != "admin" || body["user_uuid"] != "user-1" {
+		t.Fatalf("context = %v", body)
+	}
+	if body["remote_ip"] != "203.0.113.9" {
+		t.Fatalf("remote_ip = %v", body["remote_ip"])
+	}
+}
+
+func TestHookRequestContextHasNetworkOnly(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	engine.GET("/ping", func(c *gin.Context) { c.String(http.StatusOK, "pong") })
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("request", (req) => {
+					req.headers["x-ip"] = req.context.remote_ip;
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+
+	engine.GET("/check", func(c *gin.Context) {
+		if c.GetHeader("x-ip") != "198.51.100.7" {
+			c.String(http.StatusBadRequest, "bad ip: "+c.GetHeader("x-ip"))
+			return
+		}
+		c.String(http.StatusOK, "ok")
+	})
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/check", nil)
+	req.RemoteAddr = "198.51.100.7:4567"
+	WrapHandler(engine).ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+}
+
+// TestServerModulePermissionEnforcement 验证 server 模块的权限门：
+// server.route/server.hook 缺权限时加载失败；server.call 缺权限时 Promise
+// reject；registerRPC/getConfig 始终可用；无危险权限的插件无需批准即可启用。
+func TestServerModulePermissionEnforcement(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	Init(engine)
+
+	// 无危险权限：直接启用，不要求批准。
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Plain","short":"plain","version":"1.0.0","permissions":{"node":true,"timeout":5}}`,
+		"script.js":          `const server = require("server"); function load() { server.registerRPC("plugin:plain", () => ({ok:true})); }`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("plain", true, false); err != nil {
+		t.Fatalf("plain plugin without dangerous permissions must enable without approval: %v", err)
+	}
+	defer func() { _ = SetEnabled("plain", false, false) }()
+	resp := rpc.CallWithContext(context.Background(), nil, "plugin:plain", nil)
+	if resp.Error != nil {
+		t.Fatalf("default-granted registerRPC failed: %v", resp.Error)
+	}
+
+	// server.route 缺 allowRoutes：加载失败并提示权限名。
+	zipPath = writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"NoRoute","short":"noroute","version":"1.0.0"}`,
+		"script.js": `const server = require("server");
+function load() { server.route("GET", "/x", (req, res) => res.end("x")); }`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("noroute", true, true); err == nil || !strings.Contains(err.Error(), "allowRoutes") {
+		t.Fatalf("server.route without allowRoutes must fail loading: %v", err)
+	}
+
+	// server.hook 缺 allowHooks：加载失败并提示权限名。
+	zipPath = writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"NoHook","short":"nohook","version":"1.0.0"}`,
+		"script.js": `const server = require("server");
+function load() { server.hook("request", (req) => {}); }`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("nohook", true, true); err == nil || !strings.Contains(err.Error(), "allowHooks") {
+		t.Fatalf("server.hook without allowHooks must fail loading: %v", err)
+	}
+
+	// server.call 缺 allowSystemRPC：路由可用但 Promise reject。
+	zipPath = writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"NoRPC","short":"norpc","version":"1.0.0","permissions":{"allowRoutes":true}}`,
+		"script.js": `const server = require("server");
+function load() {
+	server.route("GET", "/call", async (req, res) => {
+		try {
+			await server.call("common:getVersion");
+			res.end("ok");
+		} catch (e) {
+			res.end("denied:" + e.message);
+		}
+	});
+}`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("norpc", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("norpc", false, false) }()
+	rec := httptest.NewRecorder()
+	engine.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/call", nil))
+	if rec.Code != http.StatusOK || !strings.Contains(rec.Body.String(), "allowSystemRPC") {
+		t.Fatalf("server.call without allowSystemRPC must reject: status = %d, body = %q", rec.Code, rec.Body.String())
+	}
+}
+
+// TestHookFiltering 验证 server.hook(kind, matcher, fn) 的路径/方法过滤：
+// 不匹配的请求完全跳过 hook 链（不做 body 缓冲），匹配的请求按规则执行。
+func TestHookFiltering(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	check := func(name, header string) gin.HandlerFunc {
+		return func(c *gin.Context) {
+			if c.GetHeader(header) == "" {
+				c.String(http.StatusBadRequest, "missing "+header)
+				return
+			}
+			c.String(http.StatusOK, name)
+		}
+	}
+	engine.GET("/ping", func(c *gin.Context) { c.String(http.StatusOK, "no-hook") })
+	engine.GET("/hooked", check("hooked", "x-hooked"))
+	engine.GET("/hooked/sub", check("hooked", "x-hooked"))
+	engine.GET("/hookedx", func(c *gin.Context) { c.String(http.StatusOK, "no-hook") })
+	engine.POST("/exact", check("exact", "x-exact"))
+	engine.GET("/exact", func(c *gin.Context) { c.String(http.StatusOK, "no-hook") })
+	engine.GET("/prefix/sub", check("prefix", "x-prefix"))
+	engine.GET("/prefixx", func(c *gin.Context) { c.String(http.StatusOK, "no-hook") })
+	engine.GET("/resp/a", func(c *gin.Context) { c.String(http.StatusOK, "r") })
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("request", "/hooked/*", (req) => { req.headers["x-hooked"] = "yes"; });
+				server.hook("request", "POST /exact", (req) => { req.headers["x-exact"] = "yes"; });
+				server.hook("request", "/prefix/*", (req) => { req.headers["x-prefix"] = "yes"; });
+				server.hook("response", "/resp/*", (req, res) => { res.body = res.body + "|resp"; });
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+	wrapped := WrapHandler(engine)
+
+	serve := func(method, path string) *httptest.ResponseRecorder {
+		rec := httptest.NewRecorder()
+		wrapped.ServeHTTP(rec, httptest.NewRequest(method, path, nil))
+		return rec
+	}
+	assert := func(method, path, want string) {
+		rec := serve(method, path)
+		if rec.Code != http.StatusOK || rec.Body.String() != want {
+			t.Fatalf("%s %s = %d %q, want %q", method, path, rec.Code, rec.Body.String(), want)
+		}
+	}
+	assert(http.MethodGet, "/ping", "no-hook")
+	assert(http.MethodGet, "/hooked", "hooked")
+	assert(http.MethodGet, "/hooked/sub", "hooked")
+	assert(http.MethodGet, "/hookedx", "no-hook")
+	assert(http.MethodPost, "/exact", "exact")
+	assert(http.MethodGet, "/exact", "no-hook")
+	assert(http.MethodGet, "/prefix/sub", "prefix")
+	assert(http.MethodGet, "/prefixx", "no-hook")
+	assert(http.MethodGet, "/resp/a", "r|resp")
+	assert(http.MethodGet, "/ping", "no-hook")
+}
+
+// TestHookResponseContentLength 验证响应钩子改写 body 后不会留下失效的
+// Content-Length（否则客户端会截断/挂起）；未改 body 时保留原长度。
+func TestHookResponseContentLength(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	engine.GET("/changed", func(c *gin.Context) {
+		c.Header("Content-Length", strconv.Itoa(len("abcdef")))
+		c.String(http.StatusOK, "abcdef")
+	})
+	engine.GET("/kept", func(c *gin.Context) {
+		c.Header("Content-Length", strconv.Itoa(len("abcdef")))
+		c.String(http.StatusOK, "abcdef")
+	})
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": featureManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("response", (req, res) => {
+					if (req.url === "/changed") { res.body = "modified body"; }
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("feat", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("feat", false, false) }()
+	wrapped := WrapHandler(engine)
+
+	rec := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/changed", nil))
+	if rec.Body.String() != "modified body" {
+		t.Fatalf("body = %q", rec.Body.String())
+	}
+	if cl := rec.Header().Get("Content-Length"); cl != "" {
+		t.Fatalf("stale Content-Length %q kept after body rewrite", cl)
+	}
+
+	rec2 := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec2, httptest.NewRequest(http.MethodGet, "/kept", nil))
+	if rec2.Body.String() != "abcdef" || rec2.Header().Get("Content-Length") != "6" {
+		t.Fatalf("unmodified body: len header = %q, body = %q", rec2.Header().Get("Content-Length"), rec2.Body.String())
+	}
+}
+
+// TestHookBodyLimit 验证请求钩子按插件声明的 maxHTTPBodyBytes 读取请求体：
+// 超过限制的请求返回 413，而非沿用全局默认 32 MiB。
+func TestHookBodyLimit(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	engine.POST("/echo", func(c *gin.Context) {
+		if c.GetHeader("x-hooked") != "yes" {
+			c.String(http.StatusBadRequest, "missing x-hooked")
+			return
+		}
+		c.String(http.StatusOK, "ok")
+	})
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Limit","short":"limit","version":"1.0.0","permissions":{"allowHooks":true,"maxHTTPBodyBytes":256,"timeout":5}}`,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("request", (req) => { req.headers["x-hooked"] = "yes"; });
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("limit", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("limit", false, false) }()
+	wrapped := WrapHandler(engine)
+
+	rec := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/echo", strings.NewReader(strings.Repeat("x", 128))))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("small body = %d, want 200", rec.Code)
+	}
+	rec2 := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec2, httptest.NewRequest(http.MethodPost, "/echo", strings.NewReader(strings.Repeat("x", 1024))))
+	if rec2.Code != http.StatusRequestEntityTooLarge {
+		t.Fatalf("large body = %d %q, want 413", rec2.Code, rec2.Body.String())
+	}
+}
@@ -0,0 +1,603 @@
+package plugin
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/dop251/goja"
+	"github.com/komari-monitor/komari/pkg/jsruntime"
+	"github.com/komari-monitor/komari/pkg/jsruntime/httpbody"
+)
+
+// hookKind identifies the HTTP hook phase.
+type hookKind string
+
+const (
+	hookRequest  hookKind = "request"
+	hookResponse hookKind = "response"
+)
+
+// hookEntry is one registered JavaScript hook.
+type hookEntry struct {
+	short     string
+	kind      hookKind
+	fn        goja.Callable
+	host      *jsruntime.Host
+	matcher   *hookMatcher // nil matches every request
+	bodyLimit int64        // plugin-declared maxHTTPBodyBytes (0 = default)
+}
+
+// hookMatcher optionally restricts a hook to matching requests. A nil
+// matcher matches every request.
+type hookMatcher struct {
+	method string // optional HTTP method; "" matches any
+	path   string // cleaned request path, lowercase
+	prefix bool   // subtree match when the pattern ended with "*"
+}
+
+// parseHookMatcher parses a server.hook path filter: "POST /api/foo",
+// "/api/foo" or "/api/foo/*". The optional leading HTTP method restricts the
+// hook to one request method; a trailing "*" matches the path and its whole
+// subtree; any other pattern is an exact path match.
+func parseHookMatcher(pattern string) (*hookMatcher, error) {
+	pattern = strings.TrimSpace(pattern)
+	if pattern == "" {
+		return nil, errors.New("hook path must not be empty")
+	}
+	m := &hookMatcher{}
+	if method, rest, ok := strings.Cut(pattern, " "); ok {
+		method = strings.ToUpper(strings.TrimSpace(method))
+		if isHTTPMethod(method) {
+			m.method = method
+			pattern = strings.TrimSpace(rest)
+		}
+	}
+	if !strings.HasPrefix(pattern, "/") {
+		return nil, fmt.Errorf("hook path %q must start with /", pattern)
+	}
+	if strings.HasSuffix(pattern, "*") {
+		m.prefix = true
+		pattern = strings.TrimSuffix(pattern, "*")
+	}
+	pattern = strings.TrimRight(pattern, "/")
+	if pattern == "" {
+		if m.prefix {
+			return m, nil // "/*" matches every path
+		}
+		return nil, fmt.Errorf("hook path %q is invalid", pattern)
+	}
+	if !filepath.IsLocal(strings.TrimPrefix(pattern, "/")) {
+		return nil, fmt.Errorf("hook path %q contains invalid segments", pattern)
+	}
+	m.path = strings.ToLower(pattern)
+	return m, nil
+}
+
+// matchesPath reports whether a request path matches the filter. A nil
+// matcher matches everything.
+func (m *hookMatcher) matchesPath(path string) bool {
+	if m == nil {
+		return true
+	}
+	if path == "" {
+		path = "/"
+	}
+	path = strings.ToLower(path)
+	if m.prefix {
+		return path == m.path || strings.HasPrefix(path, m.path+"/")
+	}
+	return path == m.path
+}
+
+// matches reports whether the request matches the filter. A nil matcher
+// matches everything.
+func (m *hookMatcher) matches(r *http.Request) bool {
+	if m == nil {
+		return true
+	}
+	if m.method != "" && r.Method != m.method {
+		return false
+	}
+	return m.matchesPath(r.URL.Path)
+}
+
+// isHTTPMethod reports whether s is a known HTTP request method.
+func isHTTPMethod(s string) bool {
+	switch s {
+	case http.MethodGet, http.MethodHead, http.MethodPost, http.MethodPut,
+		http.MethodPatch, http.MethodDelete, http.MethodOptions:
+		return true
+	default:
+		return false
+	}
+}
+
+// matches reports whether the hook applies to the request: no matcher, or a
+// matching filter.
+func (h *hookEntry) matches(r *http.Request) bool {
+	return h.matcher == nil || h.matcher.matches(r)
+}
+
+// filterHooks drops the hooks whose matcher does not match the request.
+func filterHooks(hooks []*hookEntry, r *http.Request) []*hookEntry {
+	kept := hooks[:0]
+	for _, hook := range hooks {
+		if hook.matches(r) {
+			kept = append(kept, hook)
+		}
+	}
+	return kept
+}
+
+// maxHookBodyLimit returns the body read limit for the request hooks that
+// will run: the largest plugin-declared maxHTTPBodyBytes, or the default
+// when no hook declares a limit.
+func maxHookBodyLimit(hooks []*hookEntry) int64 {
+	var limit int64
+	for _, hook := range hooks {
+		if hook.bodyLimit > limit {
+			limit = hook.bodyLimit
+		}
+	}
+	if limit < 1 {
+		return defaultMaxHTTPBodyBytes
+	}
+	return limit
+}
+
+// wrapHandler installs the hook chain around the application handler. WebSocket
+// upgrades pass through untouched because the response cannot be buffered.
+// Hooks with a path/method filter only run for matching requests; unfiltered
+// requests skip both the hook chain and its body buffering.
+func (m *Manager) wrapHandler(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if isUpgradeRequest(r) {
+			next.ServeHTTP(w, r)
+			return
+		}
+		reqHooks := filterHooks(m.hooksOf(hookRequest), r)
+		respHooks := filterHooks(m.hooksOf(hookResponse), r)
+		if len(reqHooks) == 0 && len(respHooks) == 0 {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		req := r
+		if len(reqHooks) > 0 {
+			body, err := httpbody.ReadAll(r.Body, maxHookBodyLimit(reqHooks))
+			if err != nil {
+				http.Error(w, err.Error(), http.StatusRequestEntityTooLarge)
+				return
+			}
+			for _, hook := range reqHooks {
+				body, err = m.runRequestHook(req, body, hook)
+				if err != nil {
+					m.logHookError(hook, err)
+					http.Error(w, "plugin request hook failed", http.StatusInternalServerError)
+					return
+				}
+			}
+			req = requestWithBody(req, body)
+		}
+
+		if len(respHooks) == 0 {
+			next.ServeHTTP(w, req)
+			return
+		}
+		bw := newBufferedResponseWriter(w)
+		next.ServeHTTP(bw, req)
+		for _, hook := range respHooks {
+			if err := m.runResponseHook(req, bw, hook); err != nil {
+				m.logHookError(hook, err)
+			}
+		}
+		bw.flushTo(w)
+	})
+}
+
+// runRequestHook runs one request hook on its plugin event loop, applies the
+// JS-side modifications to the request, and returns the (possibly replaced)
+// request body.
+func (m *Manager) runRequestHook(r *http.Request, body []byte, h *hookEntry) ([]byte, error) {
+	nextBody := body
+	var hookErr error
+	queued, timedOut := runHookTurn(h.host, "plugin request hook "+h.short, func(vm *goja.Runtime) {
+		reqObj := hookRequestObject(vm, r, nextBody)
+		hookErr = h.host.RunJob(vm, "plugin request hook "+h.short, func() error {
+			_, err := h.fn(goja.Undefined(), reqObj)
+			return err
+		})
+		if hookErr != nil {
+			return
+		}
+		if value := reqObj.Get("method"); value != nil && !goja.IsUndefined(value) {
+			if method := strings.ToUpper(strings.TrimSpace(value.String())); method != "" {
+				r.Method = method
+			}
+		}
+		if value := reqObj.Get("url"); value != nil && !goja.IsUndefined(value) {
+			if raw := strings.TrimSpace(value.String()); raw != "" {
+				if parsed, err := url.Parse(raw); err == nil {
+					r.URL = parsed
+					r.RequestURI = raw
+				}
+			}
+		}
+		if value := reqObj.Get("headers"); value != nil && !goja.IsUndefined(value) {
+			var raw map[string]any
+			if err := vm.ExportTo(value, &raw); err == nil {
+				r.Header = normalizeHeader(raw)
+			}
+		}
+		if value := reqObj.Get("body"); value != nil && !goja.IsUndefined(value) {
+			nextBody = []byte(value.String())
+		}
+	})
+	if !queued {
+		return body, errors.New("plugin runtime is closed")
+	}
+	if timedOut {
+		return body, errors.New("plugin request hook timed out")
+	}
+	return nextBody, hookErr
+}
+
+// runResponseHook runs one response hook on its plugin event loop and applies
+// the JS-side modifications to the captured response.
+func (m *Manager) runResponseHook(r *http.Request, bw *bufferedResponseWriter, h *hookEntry) error {
+	var hookErr error
+	queued, timedOut := runHookTurn(h.host, "plugin response hook "+h.short, func(vm *goja.Runtime) {
+		resObj := hookResponseObject(vm, bw)
+		hookErr = h.host.RunJob(vm, "plugin response hook "+h.short, func() error {
+			_, err := h.fn(goja.Undefined(), hookRequestObject(vm, r, nil), resObj)
+			return err
+		})
+		if hookErr != nil {
+			return
+		}
+		status := bw.status()
+		if value := resObj.Get("statusCode"); value != nil && !goja.IsUndefined(value) {
+			status = int(value.ToInteger())
+		}
+		header := bw.Header().Clone()
+		if value := resObj.Get("headers"); value != nil && !goja.IsUndefined(value) {
+			var raw map[string]any
+			if err := vm.ExportTo(value, &raw); err == nil {
+				header = normalizeHeader(raw)
+			}
+		}
+		responseBody := bw.bodyBytes()
+		if value := resObj.Get("body"); value != nil && !goja.IsUndefined(value) {
+			responseBody = []byte(value.String())
+		}
+		bw.apply(status, header, responseBody)
+	})
+	if !queued {
+		return errors.New("plugin runtime is closed")
+	}
+	if timedOut {
+		return errors.New("plugin response hook timed out")
+	}
+	if bw.passedThrough() {
+		_, _ = m.logStore(h.short).Write([]byte(
+			fmt.Sprintf("[plugin] response exceeded the %d-byte hook buffer limit and was sent to the client unmodified\n", maxHookBufferBytes)))
+	}
+	return hookErr
+}
+
+// runHookTurn queues one hook callback on the plugin event loop and waits
+// for it with the runtime timeout. It reports whether the job was queued and
+// whether it timed out.
+func runHookTurn(host *jsruntime.Host, name string, job func(vm *goja.Runtime)) (queued, timedOut bool) {
+	return runHookTurnTimeout(host, name, host.Timeout(), job)
+}
+
+// runHookTurnTimeout is runHookTurn with an explicit wait budget. The
+// callback keeps running on the plugin loop after a timeout; the waiter gives
+// up and the caller falls back to passing the message through.
+func runHookTurnTimeout(host *jsruntime.Host, name string, timeout time.Duration, job func(vm *goja.Runtime)) (queued, timedOut bool) {
+	done := make(chan struct{})
+	if !host.RunOnLoop(func(vm *goja.Runtime) {
+		defer close(done)
+		job(vm)
+	}) {
+		return false, false
+	}
+	select {
+	case <-done:
+		return true, false
+	case <-time.After(timeout):
+		return true, true
+	}
+}
+
+func (m *Manager) logHookError(h *hookEntry, err error) {
+	_, _ = m.logStore(h.short).Write([]byte("[plugin] hook error: " + err.Error() + "\n"))
+}
+
+// hookRequestObject builds the mutable JS request object.
+func hookRequestObject(vm *goja.Runtime, r *http.Request, body []byte) *goja.Object {
+	req := vm.NewObject()
+	_ = req.Set("method", r.Method)
+	_ = req.Set("url", r.URL.RequestURI())
+	_ = req.Set("headers", headerToMap(r.Header))
+	query := make(map[string]string, len(r.URL.Query()))
+	for name, values := range r.URL.Query() {
+		query[name] = strings.Join(values, ",")
+	}
+	_ = req.Set("query", query)
+	_ = req.Set("body", string(body))
+	_ = req.Set("context", hookRequestContext(vm, r))
+	return req
+}
+
+// hookResponseObject builds the mutable JS response object from the captured
+// response.
+func hookResponseObject(vm *goja.Runtime, bw *bufferedResponseWriter) *goja.Object {
+	res := vm.NewObject()
+	_ = res.Set("statusCode", bw.status())
+	_ = res.Set("statusMessage", "")
+	_ = res.Set("headers", headerToMap(bw.Header()))
+	_ = res.Set("body", string(bw.bodyBytes()))
+	return res
+}
+
+func requestWithBody(r *http.Request, body []byte) *http.Request {
+	clone := r.Clone(r.Context())
+	clone.Body = io.NopCloser(bytes.NewReader(body))
+	clone.ContentLength = int64(len(body))
+	return clone
+}
+
+func normalizeHeader(raw map[string]any) http.Header {
+	header := make(http.Header, len(raw))
+	for name, value := range raw {
+		switch values := value.(type) {
+		case string:
+			header.Set(name, values)
+		case []any:
+			for _, item := range values {
+				header.Add(name, fmt.Sprint(item))
+			}
+		case []string:
+			for _, item := range values {
+				header.Add(name, item)
+			}
+		default:
+			header.Set(name, fmt.Sprint(value))
+		}
+	}
+	return header
+}
+
+func headerToMap(header http.Header) map[string]any {
+	out := make(map[string]any, len(header))
+	for name, values := range header {
+		if len(values) == 1 {
+			out[strings.ToLower(name)] = values[0]
+		} else {
+			out[strings.ToLower(name)] = values
+		}
+	}
+	return out
+}
+
+// isUpgradeRequest reports whether r is a genuine protocol-upgrade request:
+// both Connection: upgrade and an Upgrade header must be present (RFC 9110 §7.8).
+func isUpgradeRequest(r *http.Request) bool {
+	if r.Header.Get("Upgrade") == "" {
+		return false
+	}
+	for _, token := range strings.Split(r.Header.Get("Connection"), ",") {
+		if strings.EqualFold(strings.TrimSpace(token), "upgrade") {
+			return true
+		}
+	}
+	return false
+}
+
+// bufferedResponseWriter captures status/headers/body so response hooks can
+// modify them before the real writer receives the final bytes.
+//
+// Streaming responses (SSE / MJPEG / chunked feeds) must not be buffered:
+// their handlers never return, so buffering would hold the client empty
+// forever and grow memory without bound. The first Flush() switches the
+// writer to passthrough mode: buffered status/headers/body are forwarded to
+// the real writer immediately, every later Write/WriteHeader goes straight
+// through, and the response hooks can no longer rewrite the stream.
+type bufferedResponseWriter struct {
+	mu          sync.Mutex
+	header      http.Header
+	statusCode  int
+	body        bytes.Buffer
+	wroteHeader bool
+	streaming   bool // switched to passthrough after the first Flush()
+	forwarded   bool // status/headers already sent to the underlying writer
+	hijacked    bool
+	limit       int  // maximum buffered body bytes before passthrough
+	passthrough bool // buffering abandoned because the body exceeded limit
+	underlying  http.ResponseWriter
+}
+
+func newBufferedResponseWriter(w http.ResponseWriter) *bufferedResponseWriter {
+	return &bufferedResponseWriter{header: make(http.Header), limit: maxHookBufferBytes, underlying: w}
+}
+
+func (b *bufferedResponseWriter) passedThrough() bool {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.passthrough
+}
+
+func (b *bufferedResponseWriter) Header() http.Header { return b.header }
+
+func (b *bufferedResponseWriter) WriteHeader(code int) {
+	b.mu.Lock()
+	if b.streaming {
+		if b.forwarded || b.hijacked {
+			b.mu.Unlock()
+			return
+		}
+		b.forwarded = true
+		status, header := code, b.header.Clone()
+		b.mu.Unlock()
+		b.writeThrough(status, header)
+		return
+	}
+	if !b.wroteHeader {
+		b.statusCode = code
+		b.wroteHeader = true
+	}
+	b.mu.Unlock()
+}
+
+func (b *bufferedResponseWriter) Write(p []byte) (int, error) {
+	b.mu.Lock()
+	if b.streaming {
+		b.mu.Unlock()
+		return b.underlying.Write(p)
+	}
+	if !b.wroteHeader {
+		b.statusCode = http.StatusOK
+		b.wroteHeader = true
+	}
+	if b.body.Len()+len(p) > b.limit {
+		// Response is too large to rewrite: switch to passthrough mode and
+		// forward status/headers and the buffered body to the real writer
+		// immediately. Response hooks can no longer modify this response.
+		status, header, buffered := b.statusCode, b.header.Clone(), b.body.Bytes()
+		b.streaming = true
+		b.forwarded = true
+		b.passthrough = true
+		b.mu.Unlock()
+		b.writeThrough(status, header)
+		_, _ = b.underlying.Write(buffered)
+		_, _ = b.underlying.Write(p)
+		return len(p), nil
+	}
+	_, err := b.body.Write(p)
+	b.mu.Unlock()
+	return len(p), err
+}
+
+func (b *bufferedResponseWriter) status() int {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if !b.wroteHeader {
+		return http.StatusOK
+	}
+	return b.statusCode
+}
+
+func (b *bufferedResponseWriter) bodyBytes() []byte {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return append([]byte(nil), b.body.Bytes()...)
+}
+
+func (b *bufferedResponseWriter) apply(status int, header http.Header, body []byte) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	if b.streaming {
+		return // already streamed to the client; hooks cannot rewrite it
+	}
+	bodyChanged := !bytes.Equal(body, b.body.Bytes())
+	b.statusCode = status
+	b.wroteHeader = true
+	b.header = header
+	b.body.Reset()
+	_, _ = b.body.Write(body)
+	if bodyChanged {
+		// The rewritten body differs from the original response; a
+		// Content-Length copied from it is now stale and would truncate or
+		// hang the client. Drop it so Go recomputes the length (or falls
+		// back to chunked encoding).
+		b.header.Del("Content-Length")
+	}
+}
+
+func (b *bufferedResponseWriter) flushTo(w http.ResponseWriter) {
+	b.mu.Lock()
+	if b.streaming || b.hijacked {
+		b.mu.Unlock()
+		return // passthrough already forwarded everything
+	}
+	status, body, header := b.statusCode, append([]byte(nil), b.body.Bytes()...), b.header.Clone()
+	b.mu.Unlock()
+	for name, values := range header {
+		for _, value := range values {
+			w.Header().Add(name, value)
+		}
+	}
+	w.WriteHeader(status)
+	_, _ = w.Write(body)
+}
+
+func (b *bufferedResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	b.mu.Lock()
+	b.hijacked = true
+	b.mu.Unlock()
+	hijacker, ok := b.underlying.(http.Hijacker)
+	if !ok {
+		return nil, nil, errors.New("plugin response buffer does not support hijacking")
+	}
+	return hijacker.Hijack()
+}
+
+func (b *bufferedResponseWriter) Flush() {
+	b.mu.Lock()
+	if !b.streaming {
+		// First Flush: switch to passthrough mode and forward the buffered
+		// response to the real writer immediately.
+		b.streaming = true
+		status, body, header := b.statusCode, append([]byte(nil), b.body.Bytes()...), b.header.Clone()
+		b.mu.Unlock()
+		b.writeThrough(status, header)
+		_, _ = b.underlying.Write(body)
+	} else {
+		b.mu.Unlock()
+	}
+	if flusher, ok := b.underlying.(http.Flusher); ok {
+		flusher.Flush()
+	}
+}
+
+// writeThrough forwards status and headers to the underlying writer once.
+func (b *bufferedResponseWriter) writeThrough(status int, header http.Header) {
+	for name, values := range header {
+		for _, value := range values {
+			b.underlying.Header().Add(name, value)
+		}
+	}
+	b.underlying.WriteHeader(status)
+}
+
+func (b *bufferedResponseWriter) ReadFrom(r io.Reader) (int64, error) {
+	if !b.wroteHeader {
+		b.WriteHeader(http.StatusOK)
+	}
+	return io.Copy(b, r)
+}
+
+func (b *bufferedResponseWriter) CloseNotify() <-chan bool {
+	if notifier, ok := b.underlying.(interface{ CloseNotify() <-chan bool }); ok {
+		return notifier.CloseNotify()
+	}
+	return nil
+}
+
+var (
+	_ http.ResponseWriter = (*bufferedResponseWriter)(nil)
+	_ http.Hijacker       = (*bufferedResponseWriter)(nil)
+	_ http.Flusher        = (*bufferedResponseWriter)(nil)
+)
@@ -0,0 +1,277 @@
+package plugin
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"sync"
+)
+
+// injectEntry is one plugin's registered HTML fragments. head is inserted
+// before </head>, body before </body>, in every text/html response.
+type injectEntry struct {
+	short string
+	head  string
+	body  string
+}
+
+// htmlInjectHandler installs the HTML injection wrapper around the
+// application handler. WebSocket upgrades pass through untouched because the
+// response cannot be buffered.
+func (m *Manager) htmlInjectHandler(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if isUpgradeRequest(r) {
+			next.ServeHTTP(w, r)
+			return
+		}
+		fragments := m.injectsSnapshot()
+		if len(fragments) == 0 {
+			next.ServeHTTP(w, r)
+			return
+		}
+		iw := newHTMLInjectWriter(w)
+		next.ServeHTTP(iw, r)
+		iw.flushTo(fragments)
+	})
+}
+
+// injectHTMLContent inserts the plugin head/body fragments into an HTML
+// document: head before </head>, body before </body> with fallbacks to
+// </html> and the document end. Tag matching is case-insensitive.
+func injectHTMLContent(body []byte, fragments []*injectEntry) []byte {
+	if len(fragments) == 0 {
+		return body
+	}
+	var head, tail strings.Builder
+	for _, fragment := range fragments {
+		head.WriteString(fragment.head)
+		tail.WriteString(fragment.body)
+	}
+	if head.Len() == 0 && tail.Len() == 0 {
+		return body
+	}
+	text := string(body)
+	headHTML, tailHTML := head.String(), tail.String()
+	if headHTML != "" {
+		if idx := indexFold(text, "</head>"); idx >= 0 {
+			text = text[:idx] + headHTML + text[idx:]
+		} else {
+			text = headHTML + text
+		}
+	}
+	if tailHTML != "" {
+		switch {
+		case indexFold(text, "</body>") >= 0:
+			text = text[:indexFold(text, "</body>")] + tailHTML + text[indexFold(text, "</body>"):]
+		case indexFold(text, "</html>") >= 0:
+			text = text[:indexFold(text, "</html>")] + tailHTML + text[indexFold(text, "</html>"):]
+		default:
+			text += tailHTML
+		}
+	}
+	return []byte(text)
+}
+
+func indexFold(text, needle string) int {
+	return strings.Index(strings.ToLower(text), needle)
+}
+
+// htmlInjectWriter captures only text/html responses so the registered
+// plugin fragments can be injected before flushTo. Every other response is
+// forwarded to the real writer unmodified as soon as its content type is
+// known, so JSON, assets and streams are never buffered.
+//
+// The content type is read from the response header when set; otherwise the
+// first bytes are sniffed with http.DetectContentType. Streaming responses
+// (SSE / MJPEG / chunked feeds) switch to passthrough on the first Flush(),
+// and responses larger than the buffer limit are forwarded unmodified.
+type htmlInjectWriter struct {
+	mu          sync.Mutex
+	header      http.Header
+	statusCode  int
+	wroteHeader bool
+	body        bytes.Buffer
+	html        bool // decided: the response is text/html and buffered
+	streaming   bool // switched to passthrough
+	hijacked    bool
+	limit       int
+	underlying  http.ResponseWriter
+}
+
+func newHTMLInjectWriter(w http.ResponseWriter) *htmlInjectWriter {
+	return &htmlInjectWriter{header: make(http.Header), limit: maxHTMLInjectBufferBytes, underlying: w}
+}
+
+func (w *htmlInjectWriter) Header() http.Header { return w.header }
+
+func (w *htmlInjectWriter) WriteHeader(code int) {
+	w.mu.Lock()
+	if w.streaming {
+		w.mu.Unlock()
+		return
+	}
+	if !w.wroteHeader {
+		w.statusCode = code
+		w.wroteHeader = true
+	}
+	ct := w.header.Get("Content-Type")
+	w.mu.Unlock()
+	if ct != "" && !isHTMLContentType(ct) {
+		w.passthrough()
+	}
+}
+
+func (w *htmlInjectWriter) Write(p []byte) (int, error) {
+	w.mu.Lock()
+	if w.streaming {
+		w.mu.Unlock()
+		return w.underlying.Write(p)
+	}
+	if !w.wroteHeader {
+		w.statusCode = http.StatusOK
+		w.wroteHeader = true
+	}
+	if !w.html {
+		ct := w.header.Get("Content-Type")
+		if ct == "" {
+			ct = sniffContentType(w.body.Bytes(), p)
+			if ct != "" {
+				w.header.Set("Content-Type", ct)
+			}
+		}
+		if ct != "" {
+			if !isHTMLContentType(ct) {
+				w.mu.Unlock()
+				w.passthrough()
+				return w.underlying.Write(p)
+			}
+			w.html = true
+		}
+	}
+	if w.body.Len()+len(p) > w.limit {
+		w.mu.Unlock()
+		w.passthrough()
+		return w.underlying.Write(p)
+	}
+	n, err := w.body.Write(p)
+	w.mu.Unlock()
+	return n, err
+}
+
+// passthrough forwards the buffered status/headers/body to the real writer
+// and switches every later write to direct passthrough. The injection is
+// skipped for the response.
+func (w *htmlInjectWriter) passthrough() {
+	w.mu.Lock()
+	if w.streaming || w.hijacked {
+		w.mu.Unlock()
+		return
+	}
+	w.streaming = true
+	status, header, body := w.statusCode, w.header.Clone(), append([]byte(nil), w.body.Bytes()...)
+	w.mu.Unlock()
+	w.writeThrough(status, header)
+	_, _ = w.underlying.Write(body)
+}
+
+// flushTo finalizes a fully buffered response. HTML responses get the
+// registered fragments injected, everything else is written through
+// unmodified.
+func (w *htmlInjectWriter) flushTo(fragments []*injectEntry) {
+	w.mu.Lock()
+	if w.streaming || w.hijacked {
+		w.mu.Unlock()
+		return
+	}
+	w.streaming = true
+	status, header, body := w.statusCode, w.header.Clone(), append([]byte(nil), w.body.Bytes()...)
+	w.mu.Unlock()
+
+	ct := header.Get("Content-Type")
+	if ct == "" {
+		ct = http.DetectContentType(body)
+		if isHTMLContentType(ct) {
+			header.Set("Content-Type", ct)
+		}
+	}
+	if isHTMLContentType(ct) {
+		body = injectHTMLContent(body, fragments)
+		header.Del("Content-Length")
+	}
+	w.writeThrough(status, header)
+	_, _ = w.underlying.Write(body)
+}
+
+func (w *htmlInjectWriter) writeThrough(status int, header http.Header) {
+	for name, values := range header {
+		for _, value := range values {
+			w.underlying.Header().Add(name, value)
+		}
+	}
+	w.underlying.WriteHeader(status)
+}
+
+// isHTMLContentType reports whether the MIME type is HTML, with or without
+// parameters such as charset.
+func isHTMLContentType(ct string) bool {
+	return strings.Contains(strings.ToLower(ct), "text/html")
+}
+
+// sniffContentType decides the content type of a response from the header
+// value when available, otherwise from the first bytes via
+// http.DetectContentType. An empty result means the type is not decidable
+// yet; buffering continues.
+func sniffContentType(buffered, next []byte) string {
+	const sniffLength = 512
+	total := buffered
+	if len(total) < sniffLength {
+		room := sniffLength - len(total)
+		if len(next) > room {
+			next = next[:room]
+		}
+		total = append(append([]byte(nil), total...), next...)
+	}
+	return http.DetectContentType(total)
+}
+
+func (w *htmlInjectWriter) ReadFrom(r io.Reader) (int64, error) {
+	if !w.wroteHeader {
+		w.WriteHeader(http.StatusOK)
+	}
+	return io.Copy(w, r)
+}
+
+func (w *htmlInjectWriter) Flush() {
+	w.passthrough()
+	if flusher, ok := w.underlying.(http.Flusher); ok {
+		flusher.Flush()
+	}
+}
+
+func (w *htmlInjectWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	w.mu.Lock()
+	w.hijacked = true
+	w.mu.Unlock()
+	hijacker, ok := w.underlying.(http.Hijacker)
+	if !ok {
+		return nil, nil, errors.New("plugin HTML injector does not support hijacking")
+	}
+	return hijacker.Hijack()
+}
+
+func (w *htmlInjectWriter) CloseNotify() <-chan bool {
+	if notifier, ok := w.underlying.(interface{ CloseNotify() <-chan bool }); ok {
+		return notifier.CloseNotify()
+	}
+	return nil
+}
+
+var (
+	_ http.ResponseWriter = (*htmlInjectWriter)(nil)
+	_ http.Hijacker       = (*htmlInjectWriter)(nil)
+	_ http.Flusher        = (*htmlInjectWriter)(nil)
+)
@@ -0,0 +1,161 @@
+package plugin
+
+import (
+	"archive/zip"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+// InstallZip validates a plugin ZIP and extracts it into DataDir/<short>.
+// The archive must contain komari-plugin.json at its root. Archive limits
+// mirror the theme package format; path-traversal entries reject the whole
+// package instead of being skipped. Reinstalling over a running plugin
+// unloads it first and restores it to its persisted enabled state when the
+// extraction succeeds.
+func InstallZip(zipPath string) (models.Plugin, error) {
+	var info models.Plugin
+	r, err := zip.OpenReader(zipPath)
+	if err != nil {
+		return info, fmt.Errorf("failed to open ZIP file: %v", err)
+	}
+	defer r.Close()
+
+	if err := validatePluginArchive(r.File); err != nil {
+		return info, err
+	}
+
+	var manifest *zip.File
+	for _, f := range r.File {
+		if f.Name == manifestFile {
+			manifest = f
+			break
+		}
+	}
+	if manifest == nil {
+		return info, fmt.Errorf("plugin manifest %s not found, not a valid plugin package", manifestFile)
+	}
+
+	rc, err := manifest.Open()
+	if err != nil {
+		return info, fmt.Errorf("failed to read plugin manifest: %v", err)
+	}
+	configData, readErr := io.ReadAll(io.LimitReader(rc, maxPluginManifestSize+1))
+	_ = rc.Close()
+	if readErr != nil {
+		return info, fmt.Errorf("failed to read plugin manifest: %v", readErr)
+	}
+	if len(configData) > maxPluginManifestSize {
+		return info, fmt.Errorf("plugin manifest exceeds the %d byte limit", maxPluginManifestSize)
+	}
+	if err := json.Unmarshal(configData, &info); err != nil {
+		return info, fmt.Errorf("invalid plugin manifest: %v", err)
+	}
+	if err := validateManifest(&info); err != nil {
+		return info, err
+	}
+	if err := CheckKomariVersion(info.Komari); err != nil {
+		return info, err
+	}
+
+	if err := global.unload(info.Short); err != nil && !errors.Is(err, errNotLoaded) {
+		return info, fmt.Errorf("failed to unload running plugin %q before reinstall: %w", info.Short, err)
+	}
+
+	dir := filepath.Join(DataDir, info.Short)
+	if err := os.RemoveAll(dir); err != nil {
+		return info, fmt.Errorf("failed to remove existing plugin directory: %v", err)
+	}
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return info, fmt.Errorf("failed to create plugin directory: %v", err)
+	}
+	if err := extractPluginArchive(r.File, dir); err != nil {
+		_ = os.RemoveAll(dir)
+		return info, err
+	}
+	if _, err := os.Stat(filepath.Join(dir, info.Entry)); err != nil {
+		_ = os.RemoveAll(dir)
+		return info, fmt.Errorf("plugin entry %s does not exist", info.Entry)
+	}
+	for _, page := range info.Pages {
+		if _, err := os.Stat(filepath.Join(dir, page.File)); err != nil {
+			_ = os.RemoveAll(dir)
+			return info, fmt.Errorf("plugin page %s does not exist", page.File)
+		}
+	}
+	if global.stateStore().get(info.Short).Enabled {
+		if err := global.restartPlugin(info.Short); err != nil {
+			return info, fmt.Errorf("plugin reinstalled but reload failed: %w", err)
+		}
+	}
+	return info, nil
+}
+
+func validatePluginArchive(files []*zip.File) error {
+	if len(files) > maxPluginArchiveFiles {
+		return fmt.Errorf("plugin archive has more than %d files", maxPluginArchiveFiles)
+	}
+	var total uint64
+	for _, file := range files {
+		if file.FileInfo().IsDir() {
+			continue
+		}
+		if file.UncompressedSize64 > maxPluginFileSize {
+			return fmt.Errorf("plugin file %s exceeds the %d byte limit", file.Name, maxPluginFileSize)
+		}
+		total += file.UncompressedSize64
+		if total > maxPluginExtractedSize {
+			return fmt.Errorf("plugin archive exceeds the %d byte extraction limit", maxPluginExtractedSize)
+		}
+	}
+	return nil
+}
+
+func extractPluginArchive(files []*zip.File, dir string) error {
+	for _, f := range files {
+		path := filepath.Join(dir, f.Name)
+		if !withinDir(path, dir) {
+			return fmt.Errorf("plugin archive contains an invalid path %q", f.Name)
+		}
+		if f.FileInfo().IsDir() {
+			if err := os.MkdirAll(path, 0755); err != nil {
+				return fmt.Errorf("failed to create directory: %v", err)
+			}
+			continue
+		}
+		if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+			return fmt.Errorf("failed to create directory: %v", err)
+		}
+		rc, err := f.Open()
+		if err != nil {
+			return fmt.Errorf("failed to open archive file: %v", err)
+		}
+		outFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
+		if err != nil {
+			_ = rc.Close()
+			return fmt.Errorf("failed to create file: %v", err)
+		}
+		_, copyErr := io.Copy(outFile, rc)
+		_ = outFile.Close()
+		_ = rc.Close()
+		if copyErr != nil {
+			return fmt.Errorf("failed to extract file: %v", copyErr)
+		}
+	}
+	return nil
+}
+
+// withinDir reports whether path stays inside dir after cleaning.
+func withinDir(path, dir string) bool {
+	rel, err := filepath.Rel(dir, path)
+	if err != nil {
+		return false
+	}
+	return rel != ".." && !strings.HasPrefix(rel, ".."+string(os.PathSeparator)) && !filepath.IsAbs(rel)
+}
@@ -0,0 +1,191 @@
+package plugin
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+func TestInstallZipExtractsValidPlugin(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Demo","short":"demo","version":"1.0.0","komari":">=0.0.1","permissions":{"node":true}}`,
+		"script.js":          `function load() {}`,
+	})
+	info, err := InstallZip(zipPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Short != "demo" {
+		t.Fatalf("short = %q", info.Short)
+	}
+	if !info.Permissions.Node {
+		t.Fatal("permissions.node not parsed")
+	}
+	if _, err := os.Stat(filepath.Join(DataDir, "demo", "script.js")); err != nil {
+		t.Fatalf("entry not extracted: %v", err)
+	}
+}
+
+func TestInstallZipDefaultsEntryToScriptJS(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Demo","short":"demo","version":"1.0.0"}`,
+		"script.js":          `function load() {}`,
+	})
+	info, err := InstallZip(zipPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Entry != "script.js" {
+		t.Fatalf("entry = %q, want script.js", info.Entry)
+	}
+}
+
+func TestInstallZipRejectsMissingManifest(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{"script.js": "function load() {}"})
+	if _, err := InstallZip(zipPath); err == nil {
+		t.Fatal("expected missing manifest error")
+	}
+}
+
+func TestInstallZipRejectsTraversal(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Demo","short":"demo","version":"1.0.0"}`,
+		"../evil.txt":        "boom",
+	})
+	if _, err := InstallZip(zipPath); err == nil {
+		t.Fatal("expected traversal rejection")
+	}
+	if _, err := os.Stat(filepath.Join(DataDir, "demo")); !os.IsNotExist(err) {
+		t.Fatal("plugin directory must be removed after a failed install")
+	}
+}
+
+func TestInstallZipRejectsKomariVersionMismatch(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Demo","short":"demo","version":"1.0.0","komari":">=99.0.0"}`,
+		"script.js":          `function load() {}`,
+	})
+	if _, err := InstallZip(zipPath); err == nil {
+		t.Fatal("expected komari version mismatch error")
+	}
+}
+
+func TestInstallZipRejectsMissingEntry(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Demo","short":"demo","version":"1.0.0"}`,
+	})
+	if _, err := InstallZip(zipPath); err == nil {
+		t.Fatal("expected missing entry error")
+	}
+}
+func TestInstallZipValidatesPageTypesAndVisibility(t *testing.T) {
+	withTempDataDir(t)
+
+	// iframe page 默认 visibility=admin、type=iframe；合法安装。
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Pages","short":"pages","version":"1.0.0","pages":[{"file":"admin.html","title":"Admin"}]}`,
+		"script.js":          `function load() {}`,
+		"admin.html":         `<h1>admin</h1>`,
+	})
+	info, err := InstallZip(zipPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(info.Pages) != 1 || info.Pages[0].Type != models.PageTypeIframe || info.Pages[0].Visibility != models.PageVisibilityAdmin {
+		t.Fatalf("page defaults = %+v", info.Pages)
+	}
+
+	// redirect 页面需要站内路径。
+	zipPath = writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Pages","short":"pages2","version":"1.0.0","pages":[{"title":"Go","type":"redirect","url":"/admin/settings","visibility":"admin"}]}`,
+		"script.js":          `function load() {}`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// public iframe 页面合法。
+	zipPath = writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Pages","short":"pages3","version":"1.0.0","pages":[{"file":"pub.html","title":"Pub","visibility":"public"}]}`,
+		"script.js":          `function load() {}`,
+		"pub.html":           `<h1>pub</h1>`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestInstallZipRejectsInvalidPages(t *testing.T) {
+	withTempDataDir(t)
+	cases := []struct {
+		name     string
+		manifest string
+	}{
+		{"bad type", `{"name":"P","short":"p1","version":"1.0.0","pages":[{"file":"a.html","title":"A","type":"popup"}]}`},
+		{"redirect without url", `{"name":"P","short":"p2","version":"1.0.0","pages":[{"title":"A","type":"redirect"}]}`},
+		{"redirect external url", `{"name":"P","short":"p3","version":"1.0.0","pages":[{"title":"A","type":"redirect","url":"https://evil.example/"}]}`},
+		{"redirect protocol-relative", `{"name":"P","short":"p4","version":"1.0.0","pages":[{"title":"A","type":"redirect","url":"//evil.example/"}]}`},
+		{"redirect traversal", `{"name":"P","short":"p5","version":"1.0.0","pages":[{"title":"A","type":"redirect","url":"/admin/../secret"}]}`},
+		{"bad visibility", `{"name":"P","short":"p6","version":"1.0.0","pages":[{"file":"a.html","title":"A","visibility":"everyone"}]}`},
+		{"iframe without file", `{"name":"P","short":"p7","version":"1.0.0","pages":[{"title":"A"}]}`},
+	}
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			zipPath := writePluginZip(t, map[string]string{
+				"komari-plugin.json": tt.manifest,
+				"script.js":          `function load() {}`,
+			})
+			if _, err := InstallZip(zipPath); err == nil {
+				t.Fatalf("expected rejection for %s", tt.name)
+			}
+		})
+	}
+}
+func TestInstallZipRejectsInvalidIcon(t *testing.T) {
+	withTempDataDir(t)
+	cases := []struct {
+		name     string
+		manifest string
+	}{
+		{"plugin icon traversal", `{"name":"I","short":"i1","version":"1.0.0","icon":"../evil.png"}`},
+		{"plugin icon absolute", `{"name":"I","short":"i2","version":"1.0.0","icon":"/etc/passwd"}`},
+		{"page icon traversal", `{"name":"I","short":"i3","version":"1.0.0","pages":[{"file":"a.html","title":"A","icon":"../evil.png"}]}`},
+	}
+	for _, tt := range cases {
+		t.Run(tt.name, func(t *testing.T) {
+			zipPath := writePluginZip(t, map[string]string{
+				"komari-plugin.json": tt.manifest,
+				"script.js":          `function load() {}`,
+			})
+			if _, err := InstallZip(zipPath); err == nil {
+				t.Fatalf("expected rejection for %s", tt.name)
+			}
+		})
+	}
+}
+
+func TestInstallZipAcceptsRelativeIcon(t *testing.T) {
+	withTempDataDir(t)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"I","short":"ic","version":"1.0.0","icon":"icon.svg","pages":[{"file":"a.html","title":"A","icon":"page.svg"}]}`,
+		"script.js":          `function load() {}`,
+		"a.html":             `<h1>a</h1>`,
+		"icon.svg":           `<svg/>`,
+		"page.svg":           `<svg/>`,
+	})
+	info, err := InstallZip(zipPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Icon != "icon.svg" || info.Pages[0].Icon != "page.svg" {
+		t.Fatalf("icons = %+v", info)
+	}
+}
@@ -0,0 +1,44 @@
+package plugin
+
+import (
+	"bytes"
+	"sync"
+)
+
+// LogBuffer is a bounded ring buffer holding one plugin's console output and
+// lifecycle markers. Old bytes are dropped from the front when the limit is
+// reached.
+type LogBuffer struct {
+	mu    sync.Mutex
+	buf   bytes.Buffer
+	limit int
+}
+
+func newLogBuffer(limit int) *LogBuffer {
+	if limit <= 0 {
+		limit = defaultLogBufferSize
+	}
+	return &LogBuffer{limit: limit}
+}
+
+func (b *LogBuffer) Write(p []byte) (int, error) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	_, _ = b.buf.Write(p)
+	if b.buf.Len() > b.limit {
+		b.buf.Next(b.buf.Len() - b.limit)
+	}
+	return len(p), nil
+}
+
+func (b *LogBuffer) String() string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.buf.String()
+}
+
+func (b *LogBuffer) Reset() {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	b.buf.Reset()
+}
@@ -0,0 +1,69 @@
+package plugin
+
+import (
+	"archive/zip"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/komari-monitor/komari/cmd/flags"
+	"github.com/komari-monitor/komari/database/dbcore"
+)
+
+func TestMain(m *testing.M) {
+	flags.DatabaseType = flags.DatabaseTypeSQLite
+	flags.DatabaseFile = "file:komari_plugin_test?mode=memory&cache=shared"
+	db := dbcore.GetDBInstance()
+	if sqlDB, err := db.DB(); err == nil {
+		sqlDB.SetMaxOpenConns(1)
+	}
+	os.Exit(m.Run())
+}
+
+// withTempDataDir redirects DataDir and StorageDir and resets the global
+// manager for the duration of a test.
+func withTempDataDir(t *testing.T) {
+	t.Helper()
+	oldDir := DataDir
+	oldStorage := StorageDir
+	oldGlobal := global
+	DataDir = t.TempDir()
+	StorageDir = t.TempDir()
+	mgr := &Manager{
+		instances: make(map[string]*Instance),
+		routes:    make(map[string]map[string]bool),
+		logs:      make(map[string]*LogBuffer),
+	}
+	global = mgr
+	t.Cleanup(func() { _ = mgr.closeAll() }) // release runtimes before TempDir removal
+	t.Cleanup(func() {
+		DataDir = oldDir
+		StorageDir = oldStorage
+		global = oldGlobal
+	})
+}
+
+// writePluginZip creates a plugin ZIP from a name -> content map.
+func writePluginZip(t *testing.T, files map[string]string) string {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "plugin.zip")
+	f, err := os.Create(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+	w := zip.NewWriter(f)
+	for name, content := range files {
+		entry, err := w.Create(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := entry.Write([]byte(content)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := w.Close(); err != nil {
+		t.Fatal(err)
+	}
+	return path
+}
@@ -0,0 +1,244 @@
+package plugin
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/pkg/rpc"
+)
+
+const demoManifest = `{"name":"Demo","short":"demo","version":"1.0.0","komari":">=0.0.1","permissions":{"node":true,"timeout":5,"allowRoutes":true,"allowSystemRPC":true}}`
+
+func TestManagerSwitchRouteCallAndLogs(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": demoManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				console.log("demo loaded");
+				server.route("GET", "/plug", async (req, res) => {
+					const result = await server.call("plugin:testEcho", { x: req.query.x });
+					res.setHeader("Content-Type", "application/json");
+					res.end(JSON.stringify(result));
+				});
+			}
+			function unload() {
+				console.log("demo unloaded");
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+
+	// The switch must ask for permission approval on first enable.
+	if err := SetEnabled("demo", true, false); err != ErrPermissionApprovalRequired {
+		t.Fatalf("first enable: expected permission approval required, got %v", err)
+	}
+	// Approving permissions and enabling must load the plugin.
+	if err := SetEnabled("demo", true, true); err != nil {
+		t.Fatal(err)
+	}
+
+	// Register a test RPC method the plugin calls through server.call.
+	if err := rpc.Register("plugin:testEcho", func(_ context.Context, req *rpc.JsonRpcRequest) (any, *rpc.JsonRpcError) {
+		return req.Params, nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+	defer rpc.Unregister("plugin:testEcho")
+
+	rec := httptest.NewRecorder()
+	engine.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/plug?x=7", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("route status = %d, body = %s", rec.Code, rec.Body.String())
+	}
+	var body map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("route body is not JSON: %v (%s)", err, rec.Body.String())
+	}
+	if body["x"] != "7" {
+		t.Fatalf("server.call echo mismatch: %s", rec.Body.String())
+	}
+
+	logs := GetLogs("demo")
+	if !strings.Contains(logs, "demo loaded") {
+		t.Fatalf("logs missing console output: %q", logs)
+	}
+
+	// Disabling runs unload() and makes the route slot return 404.
+	if err := SetEnabled("demo", false, false); err != nil {
+		t.Fatal(err)
+	}
+	rec2 := httptest.NewRecorder()
+	engine.ServeHTTP(rec2, httptest.NewRequest(http.MethodGet, "/plug", nil))
+	if rec2.Code != http.StatusNotFound {
+		t.Fatalf("expected 404 after unload, got %d", rec2.Code)
+	}
+	if logs := GetLogs("demo"); !strings.Contains(logs, "demo unloaded") {
+		t.Fatalf("logs missing unload marker: %q", logs)
+	}
+
+	// Re-enabling reuses the route slot (approval already stored).
+	if err := SetEnabled("demo", true, false); err != nil {
+		t.Fatal(err)
+	}
+	rec3 := httptest.NewRecorder()
+	engine.ServeHTTP(rec3, httptest.NewRequest(http.MethodGet, "/plug?x=9", nil))
+	if rec3.Code != http.StatusOK || !strings.Contains(rec3.Body.String(), "9") {
+		t.Fatalf("reload route status = %d, body = %s", rec3.Code, rec3.Body.String())
+	}
+
+	infos := List()
+	if len(infos) != 1 || infos[0].Short != "demo" || !infos[0].Enabled || !infos[0].Running {
+		t.Fatalf("List mismatch: %+v", infos)
+	}
+}
+
+func TestSetEnabledFailureAutoDisablesAndRecordsError(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Bad","short":"bad","version":"1.0.0"}`,
+		"script.js":          `throw new Error("boom");`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	err := SetEnabled("bad", true, true)
+	if err == nil || !strings.Contains(err.Error(), "boom") {
+		t.Fatalf("expected boom error, got %v", err)
+	}
+	st := global.stateStore().get("bad")
+	if st.Enabled {
+		t.Fatal("failed plugin must be auto-disabled")
+	}
+	if !strings.Contains(st.LastError, "boom") {
+		t.Fatalf("last_error = %q", st.LastError)
+	}
+	infos := List()
+	if len(infos) != 1 || infos[0].Enabled || infos[0].Running || !strings.Contains(infos[0].LastError, "boom") {
+		t.Fatalf("List mismatch: %+v", infos)
+	}
+}
+
+func TestLoadHookFailureIsReported(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Hook","short":"hook","version":"1.0.0"}`,
+		"script.js": `function load() {
+			throw new Error("loadhook");
+		}`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	err := SetEnabled("hook", true, true)
+	if err == nil || !strings.Contains(err.Error(), "load() failed") || !strings.Contains(err.Error(), "loadhook") {
+		t.Fatalf("unexpected load() error: %v", err)
+	}
+}
+
+func TestLoadAllSkipsDisabledAndApprovesEnabled(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": demoManifest,
+		"script.js":          `function load() { console.log("auto loaded"); }`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	// Not enabled yet: LoadAll must not load it.
+	if err := LoadAll(); err != nil {
+		t.Fatal(err)
+	}
+	if inst := global.instanceFor("demo"); inst != nil {
+		t.Fatal("disabled plugin was loaded")
+	}
+
+	// Persist an enabled+approved state, then LoadAll must load it.
+	hash := approvalPermissionsHash(models.PluginPermissions{AllowRoutes: true, AllowSystemRPC: true})
+	global.stateStore().set("demo", PluginState{Enabled: true, ApprovedPermissionsHash: hash})
+	if err := LoadAll(); err != nil {
+		t.Fatal(err)
+	}
+	infos := List()
+	if len(infos) != 1 || !infos[0].Running {
+		t.Fatalf("enabled plugin not running after LoadAll: %+v", infos)
+	}
+	if logs := GetLogs("demo"); !strings.Contains(logs, "auto loaded") {
+		t.Fatalf("logs missing output: %q", logs)
+	}
+}
+
+func TestLoadAllAutoDisablesUnapprovedPlugin(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": demoManifest,
+		"script.js":          `function load() {}`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	// Simulate a previously enabled plugin whose approval was lost.
+	global.stateStore().set("demo", PluginState{Enabled: true})
+	err := LoadAll()
+	if err == nil || !strings.Contains(err.Error(), "approval") {
+		t.Fatalf("expected approval error, got %v", err)
+	}
+	st := global.stateStore().get("demo")
+	if st.Enabled {
+		t.Fatal("unapproved plugin must be auto-disabled")
+	}
+	if !strings.Contains(st.LastError, "approval") {
+		t.Fatalf("last_error = %q", st.LastError)
+	}
+}
+
+func TestCloseAllUnloadsEverything(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": demoManifest,
+		"script.js":          `function unload() { console.log("bye"); }`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("demo", true, true); err != nil {
+		t.Fatal(err)
+	}
+	if err := CloseAll(); err != nil {
+		t.Fatal(err)
+	}
+	if inst := global.instanceFor("demo"); inst != nil {
+		t.Fatal("plugin still loaded after CloseAll")
+	}
+	if logs := GetLogs("demo"); !strings.Contains(logs, "bye") {
+		t.Fatalf("unload hook not called: %q", logs)
+	}
+}
@@ -0,0 +1,115 @@
+package plugin
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+
+	"github.com/komari-monitor/komari/database/models"
+)
+
+// urlSchemeRE matches a leading URL scheme such as "http:" or "javascript:",
+// mirroring the theme redirect validation.
+var urlSchemeRE = regexp.MustCompile(`^[a-zA-Z][a-zA-Z0-9+\-.]*:`)
+
+// readManifest loads and validates the manifest of an installed plugin
+// directory.
+func readManifest(dir string) (models.Plugin, error) {
+	var info models.Plugin
+	data, err := os.ReadFile(filepath.Join(dir, manifestFile))
+	if err != nil {
+		return info, fmt.Errorf("read plugin manifest: %w", err)
+	}
+	if err := json.Unmarshal(data, &info); err != nil {
+		return info, fmt.Errorf("parse plugin manifest: %w", err)
+	}
+	if err := validateManifest(&info); err != nil {
+		return info, err
+	}
+	return info, nil
+}
+
+// validateManifest checks the fields the server relies on and fills in
+// defaults.
+func validateManifest(info *models.Plugin) error {
+	if info.Short == "" {
+		return fmt.Errorf("plugin short is required")
+	}
+	if !validShort(info.Short) {
+		return fmt.Errorf("plugin short %q is invalid: only letters, digits, '_' and '-' are allowed", info.Short)
+	}
+	if !models.IsLocalizedText(info.Name) {
+		return fmt.Errorf("plugin name is required")
+	}
+	if info.Entry == "" {
+		info.Entry = defaultEntry
+	}
+	if !filepath.IsLocal(info.Entry) {
+		return fmt.Errorf("plugin entry %q must be a relative path inside the plugin directory", info.Entry)
+	}
+	if info.Icon != "" && !filepath.IsLocal(info.Icon) {
+		return fmt.Errorf("plugin icon %q must be a relative path inside the plugin directory", info.Icon)
+	}
+	for i := range info.Pages {
+		if err := validatePage(&info.Pages[i]); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// validatePage checks one declared plugin page. Type and visibility default
+// to iframe/admin so existing manifests keep their behavior.
+func validatePage(page *models.PluginPage) error {
+	if page.Type == "" {
+		page.Type = models.PageTypeIframe
+	}
+	if page.Visibility == "" {
+		page.Visibility = models.PageVisibilityAdmin
+	}
+	switch page.Visibility {
+	case models.PageVisibilityAdmin, models.PageVisibilityPublic:
+	default:
+		return fmt.Errorf("plugin page visibility %q is invalid: use \"admin\" or \"public\"", page.Visibility)
+	}
+	if page.Icon != "" && !filepath.IsLocal(page.Icon) {
+		return fmt.Errorf("plugin page icon %q must be a relative path inside the plugin directory", page.Icon)
+	}
+	switch page.Type {
+	case models.PageTypeIframe:
+		if page.File == "" || !filepath.IsLocal(page.File) {
+			return fmt.Errorf("plugin iframe page requires a relative file path inside the plugin directory")
+		}
+	case models.PageTypeRedirect:
+		if page.URL == "" || !isSafeInternalPath(page.URL) {
+			return fmt.Errorf("plugin redirect page requires an internal site path starting with /")
+		}
+	default:
+		return fmt.Errorf("plugin page type %q is invalid: use \"iframe\" or \"redirect\"", page.Type)
+	}
+	if !models.IsLocalizedText(page.Title) {
+		return fmt.Errorf("plugin page %q requires a title", page.Title)
+	}
+	return nil
+}
+
+// isSafeInternalPath mirrors the theme redirect rule: only same-origin
+// relative paths are allowed, no scheme, no backslashes, no traversal.
+func isSafeInternalPath(target string) bool {
+	target = strings.TrimSpace(target)
+	if !strings.HasPrefix(target, "/") || strings.HasPrefix(target, "//") {
+		return false
+	}
+	if strings.Contains(target, "\\") || urlSchemeRE.MatchString(target) {
+		return false
+	}
+	for _, segment := range strings.Split(target, "/") {
+		if segment == ".." {
+			return false
+		}
+	}
+	return true
+}
@@ -0,0 +1,776 @@
+// Package plugin manages Komari plugins: ZIP packages with a
+// komari-plugin.json manifest, mirroring the theme package format. A plugin
+// runs in its own jsruntime instance confined to its data/plugin/<short>
+// directory, plus its long-term data directory data/plugin-data/<short>
+// exposed as __storageDir__ (which survives plugin updates), declares runtime
+// permissions in its manifest, and receives the host-injected "server" module
+// (server.route / server.call / server.hook, whose ws kinds can intercept
+// WebSocket connections and frames). Plugins run with admin authority inside
+// the system.
+//
+// Lifecycle: plugins are installed as directories under DataDir. The
+// persisted state file (state.json) records which plugins are enabled, which
+// permissions were approved, and the last load error. Enabled plugins are
+// loaded at startup; a failed load auto-disables the plugin and keeps the
+// error text visible through admin:listPlugins.
+package plugin
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/dop251/goja"
+	"github.com/dop251/goja_nodejs/require"
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/database/models"
+	"github.com/komari-monitor/komari/internal/scheduler"
+	"github.com/komari-monitor/komari/pkg/jsruntime"
+	"github.com/komari-monitor/komari/pkg/rpc"
+	"github.com/komari-monitor/komari/web/connection"
+)
+
+// DataDir is the on-disk root for installed plugins, mirroring the theme
+// directory layout. It is a variable so tests can redirect it.
+var DataDir = "./data/plugin"
+
+// StorageDir is the on-disk root for long-term plugin data. Each plugin gets
+// StorageDir/<short>. The directory is confined into the plugin runtime as
+// __storageDir__ and survives plugin reinstalls: update removes only
+// DataDir/<short> (the code from the ZIP) while StorageDir/<short> persists.
+// Deleting a plugin removes both.
+var StorageDir = "./data/plugin-data"
+
+const (
+	manifestFile = "komari-plugin.json"
+	defaultEntry = "script.js"
+
+	defaultMaxHTTPBodyBytes int64 = 32 << 20
+	defaultLogBufferSize          = 64 << 10
+
+	stateFileName = "state.json"
+)
+
+// maxHookBufferBytes caps how much of a response the hook chain buffers
+// for rewriting. Larger responses pass through to the client unmodified;
+// it is a variable so tests can lower it.
+var maxHookBufferBytes = 32 << 20
+
+// maxHTMLInjectBufferBytes caps how much of a text/html response the HTML
+// injector buffers before injecting plugin fragments. Larger responses pass
+// through unmodified; it is a variable so tests can lower it.
+var maxHTMLInjectBufferBytes = 32 << 20
+
+const (
+	maxPluginArchiveFiles  = 10000
+	maxPluginFileSize      = 128 << 20
+	maxPluginExtractedSize = 512 << 20
+	maxPluginManifestSize  = 1 << 20
+)
+
+// ErrPermissionApprovalRequired is returned when enabling a plugin whose
+// declared permissions have not been approved, or changed since approval.
+var ErrPermissionApprovalRequired = errors.New("plugin permissions require approval")
+
+var errNotLoaded = errors.New("plugin is not loaded")
+
+// ErrNotInstalled is returned when deleting a plugin that is not installed.
+var ErrNotInstalled = errors.New("plugin is not installed")
+
+// Info describes one installed plugin for the admin surface.
+type Info struct {
+	models.Plugin
+	Enabled   bool   `json:"enabled"`
+	Running   bool   `json:"running"`
+	LastError string `json:"last_error"`
+}
+
+// Manager owns the installed plugin set: load/unload lifecycle, persisted
+// state, per-plugin logs, and the host engine used by server.route.
+type Manager struct {
+	mu        sync.RWMutex
+	engine    *gin.Engine
+	instances map[string]*Instance
+	routes    map[string]map[string]bool // short -> "METHOD path" -> gin slot registered
+	hooks     []*hookEntry               // http request/response hooks in registration order
+	injects   []*injectEntry             // html head/body fragments in registration order
+
+	stateMu sync.Mutex
+	state   *State
+
+	logsMu sync.Mutex
+	logs   map[string]*LogBuffer
+}
+
+// Instance is one loaded plugin runtime plus its host bindings.
+type Instance struct {
+	mu         sync.RWMutex
+	info       models.Plugin
+	dir        string
+	runtime    *jsruntime.Runtime
+	host       *jsruntime.Host
+	handlers   map[string]goja.Callable // "METHOD path" -> current route handler
+	statics    map[string]*staticConfig // mount path -> static folder config
+	rpcMethods map[string]goja.Callable // registered RPC method -> JS handler
+	cronJobs   []string                 // scheduler job names, removed on unload
+}
+
+// global is the process-wide plugin manager.
+var global = &Manager{
+	instances: make(map[string]*Instance),
+	routes:    make(map[string]map[string]bool),
+	logs:      make(map[string]*LogBuffer),
+}
+
+// Init wires the manager to the HTTP engine and into every WebSocket
+// connection. It must be called before any plugin is loaded.
+func Init(engine *gin.Engine) {
+	global.mu.Lock()
+	global.engine = engine
+	global.mu.Unlock()
+	connection.SetFrameInterceptor(global)
+}
+
+// LoadAll loads every installed plugin whose persisted state is enabled and
+// approved. A failed load auto-disables the plugin, persists last_error and
+// is returned joined so callers can log it without stopping startup.
+func LoadAll() error {
+	return global.loadAll()
+}
+
+// SetEnabled is the single switch entry point. Enabling a plugin whose
+// declared permissions differ from the approved hash requires approved=true.
+func SetEnabled(short string, enabled, approved bool) error {
+	return global.setEnabled(short, enabled, approved)
+}
+
+// Reload unloads and loads an enabled plugin. The load hook completes before
+// this function returns; a failed load is persisted as the plugin's last
+// error and disables the plugin, matching the normal enable/startup path.
+func Reload(short string) error {
+	return global.reload(short)
+}
+
+// CloseAll unloads every loaded plugin. Used during server shutdown.
+func CloseAll() error {
+	return global.closeAll()
+}
+
+// List returns the installed plugins with their enabled/running state.
+func List() []Info {
+	return global.list()
+}
+
+// GetLogs returns the bounded log buffer of one plugin.
+func GetLogs(short string) string {
+	return global.getLogs(short)
+}
+
+// Delete removes an installed plugin and its persisted state.
+func Delete(short string) error {
+	return global.delete(short)
+}
+
+// WrapHandler installs the plugin HTTP hook chain around the application
+// handler. Request hooks run before the handler and may modify the request;
+// response hooks run after the handler and may modify status/headers/body.
+func WrapHandler(next http.Handler) http.Handler {
+	return global.wrapHandler(next)
+}
+
+// HTMLInjectHandler installs plugin HTML injection around the application
+// handler. Every text/html response is buffered and gets the fragments
+// registered through server.injectHTML inserted before </head> and </body>;
+// all other responses (JSON, assets, streams, downloads...) pass through to
+// the client unmodified.
+func HTMLInjectHandler(next http.Handler) http.Handler {
+	return global.htmlInjectHandler(next)
+}
+
+func (m *Manager) stateStore() *State {
+	m.stateMu.Lock()
+	defer m.stateMu.Unlock()
+	if m.state == nil || m.state.path != filepath.Join(DataDir, stateFileName) {
+		m.state = openState(filepath.Join(DataDir, stateFileName))
+	}
+	return m.state
+}
+
+func (m *Manager) logStore(short string) *LogBuffer {
+	m.logsMu.Lock()
+	defer m.logsMu.Unlock()
+	if m.logs == nil {
+		m.logs = make(map[string]*LogBuffer)
+	}
+	buf := m.logs[short]
+	if buf == nil {
+		buf = newLogBuffer(defaultLogBufferSize)
+		m.logs[short] = buf
+	}
+	return buf
+}
+
+func (m *Manager) getLogs(short string) string {
+	m.logsMu.Lock()
+	defer m.logsMu.Unlock()
+	if m.logs == nil {
+		return ""
+	}
+	buf := m.logs[short]
+	if buf == nil {
+		return ""
+	}
+	return buf.String()
+}
+
+func (m *Manager) instanceFor(short string) *Instance {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.instances[short]
+}
+
+// load runs a plugin inside its own jsruntime instance. The manager lock is
+// only held while the instance map is mutated; script evaluation and the
+// load() hook run without it so the plugin can call server.call (which takes
+// a manager read lock through rpcHandler) without deadlocking. On failure the
+// instance is dropped and its hooks and RPC methods are cleaned up.
+func (m *Manager) load(short string) error {
+	dir := filepath.Join(DataDir, short)
+	info, err := readManifest(dir)
+	if err != nil {
+		return err
+	}
+	if err := CheckKomariVersion(info.Komari); err != nil {
+		return err
+	}
+	script, err := os.ReadFile(filepath.Join(dir, info.Entry))
+	if err != nil {
+		return fmt.Errorf("read plugin entry %s: %w", info.Entry, err)
+	}
+
+	logs := m.logStore(short)
+	logs.Reset()
+	_, _ = logs.Write([]byte("[plugin] loading " + short + "\n"))
+
+	inst := &Instance{info: info, dir: dir, handlers: make(map[string]goja.Callable), statics: make(map[string]*staticConfig)}
+	m.mu.Lock()
+	if _, ok := m.instances[short]; ok {
+		m.mu.Unlock()
+		return fmt.Errorf("plugin %q is already loaded", short)
+	}
+	m.instances[short] = inst
+	m.mu.Unlock()
+
+	storageDir := filepath.Join(StorageDir, short)
+	if err := os.MkdirAll(storageDir, 0755); err != nil {
+		m.dropInstance(short, inst)
+		return fmt.Errorf("create plugin storage dir: %w", err)
+	}
+
+	opts := jsruntime.Options{
+		BaseDir:             dir,
+		StorageDir:          storageDir,
+		NodeJS:              info.Permissions.Node,
+		AllowExec:           info.Permissions.AllowExec,
+		AllowListen:         info.Permissions.AllowListen,
+		AllowAllFileAccess:  info.Permissions.AllowAllFileAccess,
+		MaxHTTPBodyBytes:    info.Permissions.MaxHTTPBodyBytes,
+		MaxChildOutputBytes: info.Permissions.MaxChildOutputBytes,
+		Timeout:             time.Duration(info.Permissions.TimeoutSeconds) * time.Second,
+		Console:             logs,
+		ConfigureHost: func(host *jsruntime.Host, registry *require.Registry) {
+			inst.mu.Lock()
+			inst.host = host
+			inst.mu.Unlock()
+			m.registerServerModule(host, registry, inst)
+		},
+	}
+	rt, err := jsruntime.New(string(script), opts)
+	if err != nil {
+		m.dropInstance(short, inst)
+		return fmt.Errorf("initialize plugin %q: %w", short, err)
+	}
+	inst.mu.Lock()
+	inst.runtime = rt
+	inst.mu.Unlock()
+
+	if rt.HasFunction("load") {
+		if err := rt.CallVoid("load"); err != nil {
+			rt.Close()
+			m.dropInstance(short, inst)
+			return fmt.Errorf("plugin %q load() failed: %w", short, err)
+		}
+	}
+	m.mu.Lock()
+	stillLoaded := m.instances[short] == inst
+	m.mu.Unlock()
+	if !stillLoaded {
+		// A concurrent unload claimed this instance while it was loading.
+		rt.Close()
+		return fmt.Errorf("plugin %q was unloaded while loading", short)
+	}
+	_, _ = logs.Write([]byte("[plugin] loaded " + short + "\n"))
+	return nil
+}
+
+// dropInstance removes a failed load from the manager: it detaches the
+// instance, unregisters its RPC methods, and clears its route slots and
+// hooks. Gin route slots from the failed load stay inert, mirroring the
+// unload behavior. The caller must not hold any Manager lock.
+func (m *Manager) dropInstance(short string, inst *Instance) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.instances[short] != inst {
+		return // replaced by a newer load or already unloaded
+	}
+	delete(m.instances, short)
+	inst.mu.Lock()
+	for method := range inst.rpcMethods {
+		rpc.Unregister(method)
+	}
+	removeCronJobs(inst.cronJobs)
+	inst.runtime = nil
+	inst.host = nil
+	clear(inst.handlers)
+	clear(inst.statics)
+	clear(inst.rpcMethods)
+	inst.cronJobs = nil
+	inst.mu.Unlock()
+	m.removeHooksLocked(short)
+	m.removeInjectsLocked(short)
+}
+
+// removeCronJobs cancels and forgets the scheduler jobs of one plugin load.
+// It runs with the instance lock held; scheduler.Remove only takes the
+// scheduler's own lock, so no lock cycle is possible.
+func removeCronJobs(names []string) {
+	for _, name := range names {
+		scheduler.Remove(name)
+	}
+}
+
+// unload stops one plugin. The instance is claimed (removed from the map)
+// under the manager lock, then the unload() hook runs without any lock so
+// the script can still call other registered RPC methods. After the hook the
+// remaining state is detached under the lock and the runtime is closed.
+// Calls to server.call made from unload() itself are rejected with a clean
+// "not loaded" error instead of deadlocking.
+func (m *Manager) unload(short string) error {
+	m.mu.Lock()
+	inst, ok := m.instances[short]
+	if !ok {
+		m.mu.Unlock()
+		return fmt.Errorf("%w: %q", errNotLoaded, short)
+	}
+	delete(m.instances, short)
+	m.mu.Unlock()
+
+	inst.mu.RLock()
+	rt := inst.runtime
+	inst.mu.RUnlock()
+	var unloadErr error
+	if rt != nil {
+		if rt.HasFunction("unload") {
+			if err := rt.CallVoid("unload"); err != nil {
+				unloadErr = fmt.Errorf("plugin %q unload() failed: %w", short, err)
+			}
+		}
+	}
+	m.mu.Lock()
+	inst.mu.Lock()
+	for method := range inst.rpcMethods {
+		rpc.Unregister(method)
+	}
+	removeCronJobs(inst.cronJobs)
+	inst.runtime = nil
+	inst.host = nil
+	clear(inst.handlers)
+	clear(inst.statics)
+	clear(inst.rpcMethods)
+	inst.cronJobs = nil
+	inst.mu.Unlock()
+	m.removeHooksLocked(short)
+	m.removeInjectsLocked(short)
+	m.mu.Unlock()
+	if rt != nil {
+		rt.Close()
+	}
+	_, _ = m.logStore(short).Write([]byte("[plugin] unloaded " + short + "\n"))
+	return unloadErr
+}
+
+func (m *Manager) closeAll() error {
+	m.mu.RLock()
+	shorts := make([]string, 0, len(m.instances))
+	for short := range m.instances {
+		shorts = append(shorts, short)
+	}
+	m.mu.RUnlock()
+	var errs []error
+	for _, short := range shorts {
+		if err := m.unload(short); err != nil {
+			errs = append(errs, err)
+		}
+	}
+	return errors.Join(errs...)
+}
+
+func (m *Manager) setEnabled(short string, enabled, approved bool) error {
+	dir := filepath.Join(DataDir, short)
+	info, err := readManifest(dir)
+	if err != nil {
+		return err
+	}
+	if !enabled {
+		st := m.stateStore().get(short)
+		st.Enabled = false
+		if err := m.unload(short); err != nil && !errors.Is(err, errNotLoaded) {
+			st.LastError = err.Error()
+		}
+		m.stateStore().set(short, st)
+		return nil
+	}
+	if m.instanceFor(short) != nil {
+		// Already running: enabling is idempotent. Re-running load() would
+		// fail with "already loaded" and auto-disable the plugin.
+		st := m.stateStore().get(short)
+		st.Enabled = true
+		st.LastError = ""
+		m.stateStore().set(short, st)
+		return nil
+	}
+
+	hash := approvalPermissionsHash(info.Permissions)
+	st := m.stateStore().get(short)
+	if permissionsRequireApproval(info.Permissions) && st.ApprovedPermissionsHash != hash {
+		if !approved {
+			return ErrPermissionApprovalRequired
+		}
+		st.ApprovedPermissionsHash = hash
+		m.stateStore().set(short, st)
+	}
+	if err := m.load(short); err != nil {
+		st.Enabled = false
+		st.LastError = err.Error()
+		m.stateStore().set(short, st)
+		return err
+	}
+	st.Enabled = true
+	st.LastError = ""
+	m.stateStore().set(short, st)
+	return nil
+}
+
+func (m *Manager) loadAll() error {
+	entries, err := os.ReadDir(DataDir)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil
+		}
+		return err
+	}
+	var errs []error
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		short := entry.Name()
+		st := m.stateStore().get(short)
+		if !st.Enabled || m.instanceFor(short) != nil {
+			continue
+		}
+		info, err := readManifest(filepath.Join(DataDir, short))
+		if err != nil {
+			errs = append(errs, m.disableWithError(short, st, err))
+			continue
+		}
+		if permissionsRequireApproval(info.Permissions) &&
+			st.ApprovedPermissionsHash != approvalPermissionsHash(info.Permissions) {
+			errs = append(errs, m.disableWithError(short, st, ErrPermissionApprovalRequired))
+			continue
+		}
+		if err := m.load(short); err != nil {
+			errs = append(errs, m.disableWithError(short, st, err))
+			continue
+		}
+	}
+	return errors.Join(errs...)
+}
+
+// restartPlugin brings a plugin back to its persisted enabled state after a
+// reinstall. A failed reload or a changed approval hash auto-disables the
+// plugin and keeps the error visible, mirroring the startup load path.
+func (m *Manager) restartPlugin(short string) error {
+	st := m.stateStore().get(short)
+	info, err := readManifest(filepath.Join(DataDir, short))
+	if err != nil {
+		return m.disableWithError(short, st, err)
+	}
+	if permissionsRequireApproval(info.Permissions) &&
+		st.ApprovedPermissionsHash != approvalPermissionsHash(info.Permissions) {
+		return m.disableWithError(short, st, ErrPermissionApprovalRequired)
+	}
+	if err := m.load(short); err != nil {
+		return m.disableWithError(short, st, err)
+	}
+	st.Enabled = true
+	st.LastError = ""
+	m.stateStore().set(short, st)
+	return nil
+}
+
+func (m *Manager) reload(short string) error {
+	if !m.stateStore().get(short).Enabled {
+		return nil
+	}
+	if err := m.unload(short); err != nil && !errors.Is(err, errNotLoaded) {
+		return err
+	}
+	return m.restartPlugin(short)
+}
+
+// disableWithError persists the auto-disable state for one plugin and wraps
+// the load failure for the startup error summary.
+func (m *Manager) disableWithError(short string, st PluginState, err error) error {
+	st.Enabled = false
+	st.LastError = err.Error()
+	m.stateStore().set(short, st)
+	return fmt.Errorf("plugin %q: %w", short, err)
+}
+
+func (m *Manager) list() []Info {
+	entries, err := os.ReadDir(DataDir)
+	if err != nil {
+		return []Info{}
+	}
+	infos := make([]Info, 0, len(entries))
+	for _, entry := range entries {
+		if !entry.IsDir() {
+			continue
+		}
+		short := entry.Name()
+		info, err := readManifest(filepath.Join(DataDir, short))
+		if err != nil {
+			continue // mirror the theme list: skip unreadable entries
+		}
+		st := m.stateStore().get(short)
+		infos = append(infos, Info{
+			Plugin:    info,
+			Enabled:   st.Enabled,
+			Running:   m.instanceFor(short) != nil,
+			LastError: st.LastError,
+		})
+	}
+	sort.Slice(infos, func(i, j int) bool { return infos[i].Short < infos[j].Short })
+	return infos
+}
+
+// Delete removes an installed plugin: it unloads the runtime, deletes the
+// plugin directory and clears its persisted state. Registered gin route
+// slots stay inert (404) until the server restarts.
+func (m *Manager) delete(short string) error {
+	if err := m.unload(short); err != nil && !errors.Is(err, errNotLoaded) {
+		return err
+	}
+	if !validShort(short) {
+		return fmt.Errorf("invalid plugin short %q", short)
+	}
+	dir := filepath.Join(DataDir, short)
+	if _, err := os.Stat(dir); err != nil {
+		if os.IsNotExist(err) {
+			return fmt.Errorf("%w: %q", ErrNotInstalled, short)
+		}
+		return err
+	}
+	if err := os.RemoveAll(dir); err != nil {
+		return err
+	}
+	if err := os.RemoveAll(filepath.Join(StorageDir, short)); err != nil {
+		return err
+	}
+	m.stateStore().delete(short)
+	return nil
+}
+
+// Manifest returns the parsed manifest of an installed plugin.
+func Manifest(short string) (models.Plugin, error) {
+	if !validShort(short) {
+		return models.Plugin{}, fmt.Errorf("invalid plugin short %q", short)
+	}
+	return readManifest(filepath.Join(DataDir, short))
+}
+
+// ResolvePublicFile returns the absolute path of a file that belongs to a
+// public iframe page of an installed plugin. Public pages are served without
+// authentication: the plugin must be enabled and the requested file must live
+// inside the directory of a page declared with visibility=public, so the page
+// HTML and its relative assets are reachable without exposing the whole
+// plugin directory.
+func ResolvePublicFile(short, name string) (string, error) {
+	if !validShort(short) {
+		return "", fmt.Errorf("invalid plugin short %q", short)
+	}
+	if !global.stateStore().get(short).Enabled {
+		return "", fmt.Errorf("plugin %q is not enabled", short)
+	}
+	info, err := readManifest(filepath.Join(DataDir, short))
+	if err != nil {
+		return "", err
+	}
+	name = filepath.Clean(strings.TrimPrefix(name, "/"))
+	for _, page := range info.Pages {
+		if page.Visibility != models.PageVisibilityPublic || page.Type != models.PageTypeIframe {
+			continue
+		}
+		dir := filepath.Dir(page.File)
+		if dir == "." || name == dir || strings.HasPrefix(name, dir+string(os.PathSeparator)) {
+			return ResolveFile(short, name)
+		}
+	}
+	return "", fmt.Errorf("plugin page %q is not public", name)
+}
+
+// ResolveFile returns the absolute path of a file inside an installed plugin
+// directory, rejecting traversal. Used to serve injected plugin pages.
+func ResolveFile(short, name string) (string, error) {
+	if !validShort(short) {
+		return "", fmt.Errorf("invalid plugin short %q", short)
+	}
+	if !filepath.IsLocal(name) {
+		return "", fmt.Errorf("invalid plugin file path %q", name)
+	}
+	dir := filepath.Join(DataDir, short)
+	full := filepath.Join(dir, name)
+	if !withinDir(full, dir) {
+		return "", fmt.Errorf("invalid plugin file path %q", name)
+	}
+	if _, err := os.Stat(full); err != nil {
+		return "", err
+	}
+	return full, nil
+}
+
+// hooksOf returns a snapshot of the hooks with the given kind.
+func (m *Manager) hooksOf(kind hookKind) []*hookEntry {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	snapshot := make([]*hookEntry, 0, len(m.hooks))
+	for _, hook := range m.hooks {
+		if hook.kind == kind {
+			snapshot = append(snapshot, hook)
+		}
+	}
+	return snapshot
+}
+
+// registerHook appends a hook. Called from the plugin's own event loop
+// during script evaluation; it takes the manager lock itself. matcher is
+// nil for unfiltered hooks; the plugin-declared body limit is captured at
+// registration so unloaded plugins never contribute a stale limit.
+func (m *Manager) registerHook(short string, kind hookKind, fn goja.Callable, matcher *hookMatcher) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	inst := m.instances[short]
+	if inst == nil {
+		return
+	}
+	inst.mu.RLock()
+	host := inst.host
+	bodyLimit := inst.info.Permissions.MaxHTTPBodyBytes
+	inst.mu.RUnlock()
+	m.hooks = append(m.hooks, &hookEntry{short: short, kind: kind, fn: fn, host: host, matcher: matcher, bodyLimit: bodyLimit})
+}
+
+// removeHooksLocked drops all hooks of one plugin. The caller must hold the
+// manager write lock.
+func (m *Manager) removeHooksLocked(short string) {
+	kept := m.hooks[:0]
+	for _, hook := range m.hooks {
+		if hook.short != short {
+			kept = append(kept, hook)
+		}
+	}
+	m.hooks = kept
+}
+
+// injectsSnapshot returns the registered HTML injection fragments in
+// registration order.
+func (m *Manager) injectsSnapshot() []*injectEntry {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return append([]*injectEntry(nil), m.injects...)
+}
+
+// registerInject appends one plugin's HTML head/body fragments. Called from
+// the plugin's own event loop during script evaluation; it takes the manager
+// lock itself.
+func (m *Manager) registerInject(short, head, body string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.instances[short] == nil {
+		return
+	}
+	m.injects = append(m.injects, &injectEntry{short: short, head: head, body: body})
+}
+
+// removeInjectsLocked drops all injection fragments of one plugin. The
+// caller must hold the manager write lock.
+func (m *Manager) removeInjectsLocked(short string) {
+	kept := m.injects[:0]
+	for _, inject := range m.injects {
+		if inject.short != short {
+			kept = append(kept, inject)
+		}
+	}
+	m.injects = kept
+}
+
+// validShort mirrors the theme short-name rule.
+func validShort(short string) bool {
+	if short == "" || short == "default" {
+		return false
+	}
+	for _, r := range short {
+		if !((r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') ||
+			(r >= '0' && r <= '9') || r == '_' || r == '-') {
+			return false
+		}
+	}
+	return true
+}
+
+// permissionsRequireApproval reports whether the manifest declares at least
+// one approval-relevant capability. Plugins without dangerous capabilities
+// (for example only declaring node modules, limits or the timeout) enable
+// without an approval step.
+func permissionsRequireApproval(p models.PluginPermissions) bool {
+	return p.AllowSystemRPC || p.AllowRoutes || p.AllowHooks || p.AllowHTMLInject ||
+		p.AllowExec || p.AllowListen || p.AllowAllFileAccess
+}
+
+// approvalPermissionsHash canonicalizes the approval-relevant permissions so
+// approval can be compared across plugin upgrades. Runtime settings such as
+// node modules, resource limits and the execution timeout are granted by
+// default and do not participate in the approval hash.
+func approvalPermissionsHash(p models.PluginPermissions) string {
+	data, _ := json.Marshal(models.PluginPermissions{
+		AllowSystemRPC:     p.AllowSystemRPC,
+		AllowRoutes:        p.AllowRoutes,
+		AllowHooks:         p.AllowHooks,
+		AllowHTMLInject:    p.AllowHTMLInject,
+		AllowExec:          p.AllowExec,
+		AllowListen:        p.AllowListen,
+		AllowAllFileAccess: p.AllowAllFileAccess,
+	})
+	sum := sha256.Sum256(data)
+	return "sha256:" + hex.EncodeToString(sum[:])
+}
@@ -0,0 +1,140 @@
+package plugin
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/dop251/goja"
+	"github.com/komari-monitor/komari/pkg/rpc"
+)
+
+// registerRPC registers a plugin-owned RPC method. The handler is a
+// JavaScript function receiving the JSON-RPC params and returning the result
+// (or throwing an Error with optional code/data). Called from the plugin's
+// own event loop during script evaluation; it takes the manager lock itself.
+func (m *Manager) registerRPC(short, method string, handler goja.Callable) error {
+	method = strings.TrimSpace(method)
+	if method == "" || strings.HasPrefix(method, "rpc.") {
+		return fmt.Errorf("invalid RPC method name %q", method)
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	inst, ok := m.instances[short]
+	if !ok {
+		return fmt.Errorf("plugin %q is not loaded", short)
+	}
+	inst.mu.Lock()
+	if inst.rpcMethods == nil {
+		inst.rpcMethods = make(map[string]goja.Callable)
+	}
+	if _, exists := inst.rpcMethods[method]; exists {
+		inst.mu.Unlock()
+		return nil // already registered in this load
+	}
+	inst.rpcMethods[method] = handler
+	inst.mu.Unlock()
+	if err := rpc.Register(method, m.rpcHandler(short, method)); err != nil {
+		inst.mu.Lock()
+		delete(inst.rpcMethods, method)
+		inst.mu.Unlock()
+		return err
+	}
+	return nil
+}
+
+// rpcHandler bridges one registered RPC call into the plugin event loop.
+func (m *Manager) rpcHandler(short, method string) rpc.Handler {
+	return func(ctx context.Context, req *rpc.JsonRpcRequest) (any, *rpc.JsonRpcError) {
+		inst := m.instanceFor(short)
+		if inst == nil {
+			return nil, &rpc.JsonRpcError{Code: rpc.Unavailable, Message: fmt.Sprintf("plugin %q is not loaded", short)}
+		}
+		inst.mu.RLock()
+		handler := inst.rpcMethods[method]
+		host := inst.host
+		alive := inst.runtime != nil
+		inst.mu.RUnlock()
+		if !alive || handler == nil || host == nil {
+			return nil, &rpc.JsonRpcError{Code: rpc.MethodNotFound, Message: "method not found", Data: method}
+		}
+
+		resultCh := make(chan any, 1)
+		errCh := make(chan *rpc.JsonRpcError, 1)
+		queued := host.RunOnLoop(func(vm *goja.Runtime) {
+			_ = host.RunJob(vm, "plugin rpc "+method, func() error {
+				params := vm.ToValue(req.Params)
+				if params == nil {
+					params = goja.Null()
+				}
+				value, callErr := handler(goja.Undefined(), params)
+				if callErr != nil {
+					errCh <- jsErrorToRPCError(vm, callErr)
+					return nil // error is captured, do not double-report
+				}
+				exported, exportErr := exportJSValue(value)
+				if exportErr != nil {
+					errCh <- &rpc.JsonRpcError{Code: rpc.InternalError, Message: exportErr.Error()}
+					return nil
+				}
+				resultCh <- exported
+				return nil
+			})
+		})
+		if !queued {
+			return nil, &rpc.JsonRpcError{Code: rpc.Unavailable, Message: "plugin runtime is closed"}
+		}
+		timer := time.NewTimer(host.Timeout())
+		defer timer.Stop()
+		select {
+		case result := <-resultCh:
+			return result, nil
+		case rpcErr := <-errCh:
+			return nil, rpcErr
+		case <-timer.C:
+			return nil, &rpc.JsonRpcError{Code: rpc.DeadlineExceeded, Message: "plugin RPC handler timed out"}
+		}
+	}
+}
+
+// exportJSValue exports a goja value into a JSON-RPC result. Circular
+// structures and other export failures become an error instead of panicking
+// inside the event loop.
+func exportJSValue(value goja.Value) (result any, err error) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			result = nil
+			err = fmt.Errorf("export JavaScript value: %v", recovered)
+		}
+	}()
+	return value.Export(), nil
+}
+
+// jsErrorToRPCError converts a thrown JavaScript error into a JSON-RPC error,
+// honoring optional code/data properties.
+func jsErrorToRPCError(vm *goja.Runtime, err error) *rpc.JsonRpcError {
+	code := rpc.InternalError
+	message := err.Error()
+	var data any
+	var exception *goja.Exception
+	if errors.As(err, &exception) {
+		if obj, ok := exception.Value().(*goja.Object); ok {
+			if value := obj.Get("code"); value != nil && !goja.IsUndefined(value) {
+				if n := value.ToInteger(); n != 0 {
+					code = int(n)
+				}
+			}
+			if value := obj.Get("message"); value != nil && !goja.IsUndefined(value) && value.String() != "" {
+				message = value.String()
+			}
+			if value := obj.Get("data"); value != nil && !goja.IsUndefined(value) {
+				if exported, exportErr := exportJSValue(value); exportErr == nil {
+					data = exported
+				}
+			}
+		}
+	}
+	return &rpc.JsonRpcError{Code: code, Message: message, Data: data}
+}
@@ -0,0 +1,700 @@
+package plugin
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/dop251/goja"
+	"github.com/dop251/goja_nodejs/buffer"
+	"github.com/dop251/goja_nodejs/require"
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/pkg/jsruntime"
+	"github.com/komari-monitor/komari/pkg/jsruntime/httpbody"
+	"github.com/komari-monitor/komari/pkg/rpc"
+)
+
+// registerServerModule registers the "server" native module for one plugin
+// instance. The module exposes:
+//
+//	server.route(method, path, handler)   register an HTTP route on the host
+//	                                      engine; handler receives (req, res)
+//	                                      and must call res.end() to finish
+//	server.static(path, dir, opts)        serve a folder from the plugin
+//	                                      directory at a mount path; opts.spa
+//	                                      makes unmatched paths fall back to
+//	                                      index.html
+//	server.hook(kind, fn)                 register a request or response hook;
+//	                                      an optional "METHOD /path", "/path"
+//	                                      or "/path/*" filter limits the hook
+//	                                      to matching requests. The ws kinds
+//	                                      (wsConnect / wsMessage / wsSend /
+//	                                      wsClose) intercept WebSocket
+//	                                      connections and frames on matching
+//	                                      endpoints; they share the
+//	                                      allowHooks permission and accept
+//	                                      only path matchers
+//	server.injectHTML(head, body)         register HTML fragments embedded
+//	                                      into every text/html response:
+//	                                      head before </head>, body before
+//	                                      </body> (all pages, including the
+//	                                      admin and terminal pages)
+//	server.call(method, params...)        call a registered RPC method with
+//	                                      admin authority; resolves to the RPC
+//	                                      result or rejects with an Error
+//	                                      carrying code/message/data
+//	server.registerRPC(method, handler)   register a plugin-owned RPC method
+//	server.getConfig()                    resolve the saved plugin configuration
+//	server.cron(expr, fn)                 run fn on the plugin event loop each
+//	                                      time the cron expression fires
+//
+// server.registerRPC, server.getConfig, server.cron and filesystem access
+// confined to the plugin directory are always granted without a manifest
+// declaration.
+// server.route, server.hook, server.injectHTML and server.call require the
+// allowRoutes, allowHooks, allowHTMLInject and allowSystemRPC permissions
+// respectively; a missing permission fails at load time (route/hook/inject)
+// or rejects the call.
+//
+// The host engine keeps a registered route slot after unload; requests then
+// receive 404 until the plugin is loaded again.
+func (m *Manager) registerServerModule(host *jsruntime.Host, registry *require.Registry, inst *Instance) {
+	registry.RegisterNativeModule("server", func(vm *goja.Runtime, module *goja.Object) {
+		exports := vm.NewObject()
+		_ = exports.Set("route", func(call goja.FunctionCall) goja.Value {
+			method := strings.ToUpper(strings.TrimSpace(call.Argument(0).String()))
+			path := call.Argument(1).String()
+			handler, ok := goja.AssertFunction(call.Argument(2))
+			if method == "" {
+				panic(vm.NewTypeError("server.route requires an HTTP method"))
+			}
+			if path == "" || !strings.HasPrefix(path, "/") {
+				panic(vm.NewTypeError("server.route requires a path starting with /"))
+			}
+			if !ok {
+				panic(vm.NewTypeError("server.route requires a function handler"))
+			}
+			if !inst.info.Permissions.AllowRoutes {
+				panic(vm.NewTypeError("server.route requires the \"route\" permission (allowRoutes)"))
+			}
+			if err := m.registerRoute(inst.info.Short, method, path, handler); err != nil {
+				panic(vm.NewGoError(err))
+			}
+			return goja.Undefined()
+		})
+		_ = exports.Set("static", func(call goja.FunctionCall) goja.Value {
+			mount := strings.TrimSpace(call.Argument(0).String())
+			mount = strings.TrimRight(mount, "/")
+			dir := strings.TrimSpace(call.Argument(1).String())
+			if mount == "" || mount == "/" || !strings.HasPrefix(mount, "/") {
+				panic(vm.NewTypeError("server.static requires a mount path starting with / (and not \"/\")"))
+			}
+			if dir == "" {
+				panic(vm.NewTypeError("server.static requires a folder name"))
+			}
+			if !filepath.IsLocal(dir) {
+				panic(vm.NewTypeError("server.static folder must be a relative path inside the plugin directory"))
+			}
+			if !inst.info.Permissions.AllowRoutes {
+				panic(vm.NewTypeError("server.static requires the \"route\" permission (allowRoutes)"))
+			}
+			var opts map[string]any
+			if !goja.IsUndefined(call.Argument(2)) && !goja.IsNull(call.Argument(2)) {
+				if err := vm.ExportTo(call.Argument(2), &opts); err != nil {
+					panic(vm.NewTypeError("server.static options must be an object like { spa: true }"))
+				}
+			}
+			spa := false
+			if v, ok := opts["spa"]; ok {
+				spa, _ = v.(bool)
+			}
+			if err := m.registerStatic(inst.info.Short, mount, dir, spa); err != nil {
+				panic(vm.NewGoError(err))
+			}
+			return goja.Undefined()
+		})
+		_ = exports.Set("call", func(call goja.FunctionCall) goja.Value {
+			method := strings.TrimSpace(call.Argument(0).String())
+			if method == "" {
+				panic(vm.NewTypeError("server.call requires an RPC method name"))
+			}
+			params := callParams(call)
+			promise, resolve, reject := vm.NewPromise()
+			go func() {
+				if !inst.info.Permissions.AllowSystemRPC {
+					host.RunOnLoop(func(vm *goja.Runtime) {
+						_ = reject(vm.NewGoError(errors.New("server.call requires the \"system RPC\" permission (allowSystemRPC)")))
+					})
+					return
+				}
+				meta := &rpc.ContextMeta{Permission: rpc.RoleAdmin, Principal: rpc.PrincipalFromRole(rpc.RoleAdmin)}
+				ctx := rpc.NewContextWithMeta(context.Background(), meta)
+				resp := rpc.CallWithContext(ctx, nil, method, params)
+				host.RunOnLoop(func(vm *goja.Runtime) {
+					if resp.Error != nil {
+						_ = reject(jsRPCError(vm, resp.Error))
+						return
+					}
+					result, err := normalizeRPCValue(resp.Result)
+					if err != nil {
+						_ = reject(vm.NewGoError(err))
+						return
+					}
+					_ = resolve(result)
+				})
+			}()
+			return vm.ToValue(promise)
+		})
+		_ = exports.Set("hook", func(call goja.FunctionCall) goja.Value {
+			kind := strings.ToLower(strings.TrimSpace(call.Argument(0).String()))
+			switch kind {
+			case "request", "response", string(hookWSConnect), string(hookWSMessage), string(hookWSSend), string(hookWSClose):
+				if !inst.info.Permissions.AllowHooks {
+					panic(vm.NewTypeError("server.hook requires the \"hook\" permission (allowHooks)"))
+				}
+			default:
+				panic(vm.NewTypeError("server.hook kind must be \"request\", \"response\", \"wsConnect\", \"wsMessage\", \"wsSend\" or \"wsClose\""))
+			}
+			// server.hook(kind, fn) or server.hook(kind, matcher, fn) where
+			// matcher is "METHOD /path", "/path" or "/path/*". The ws kinds
+			// only accept a path matcher: every upgrade is a GET request.
+			fnValue := call.Argument(1)
+			var matcher *hookMatcher
+			if goja.IsString(fnValue) {
+				parsed, err := parseHookMatcher(fnValue.String())
+				if err != nil {
+					panic(vm.NewTypeError(err.Error()))
+				}
+				if isWSHookKind(kind) && parsed.method != "" {
+					panic(vm.NewTypeError("server.hook \"" + kind + "\" only accepts a path matcher like \"/api/*\""))
+				}
+				matcher = parsed
+				fnValue = call.Argument(2)
+			}
+			fn, ok := goja.AssertFunction(fnValue)
+			if !ok {
+				panic(vm.NewTypeError("server.hook requires a function handler"))
+			}
+			m.registerHook(inst.info.Short, hookKind(kind), fn, matcher)
+			return goja.Undefined()
+		})
+		_ = exports.Set("injectHTML", func(call goja.FunctionCall) goja.Value {
+			if !inst.info.Permissions.AllowHTMLInject {
+				panic(vm.NewTypeError("server.injectHTML requires the \"HTML inject\" permission (allowHTMLInject)"))
+			}
+			m.registerInject(inst.info.Short, call.Argument(0).String(), call.Argument(1).String())
+			return goja.Undefined()
+		})
+		_ = exports.Set("cron", func(call goja.FunctionCall) goja.Value {
+			spec := strings.TrimSpace(call.Argument(0).String())
+			fn, ok := goja.AssertFunction(call.Argument(1))
+			if spec == "" {
+				panic(vm.NewTypeError("server.cron requires a cron expression"))
+			}
+			if !ok {
+				panic(vm.NewTypeError("server.cron requires a function handler"))
+			}
+			if err := m.registerCron(inst.info.Short, spec, fn); err != nil {
+				panic(vm.NewGoError(err))
+			}
+			return goja.Undefined()
+		})
+		_ = exports.Set("registerRPC", func(call goja.FunctionCall) goja.Value {
+			method := strings.TrimSpace(call.Argument(0).String())
+			fn, ok := goja.AssertFunction(call.Argument(1))
+			if method == "" {
+				panic(vm.NewTypeError("server.registerRPC requires an RPC method name"))
+			}
+			if !ok {
+				panic(vm.NewTypeError("server.registerRPC requires a function handler"))
+			}
+			if err := m.registerRPC(inst.info.Short, method, fn); err != nil {
+				panic(vm.NewGoError(err))
+			}
+			return goja.Undefined()
+		})
+		_ = exports.Set("getConfig", func(call goja.FunctionCall) goja.Value {
+			promise, resolve, reject := vm.NewPromise()
+			go func() {
+				data, err := GetConfiguration(inst.info.Short)
+				host.RunOnLoop(func(vm *goja.Runtime) {
+					if err != nil {
+						_ = reject(vm.NewGoError(err))
+						return
+					}
+					_ = resolve(data)
+				})
+			}()
+			return vm.ToValue(promise)
+		})
+		_ = module.Set("exports", exports)
+	})
+}
+
+// callParams converts JS arguments into JSON-RPC params: no params, a single
+// value, or a positional array. Values that cannot be exported (for example
+// circular objects) are skipped so the call rejects instead of panicking.
+func callParams(call goja.FunctionCall) any {
+	switch n := len(call.Arguments); {
+	case n <= 1:
+		return nil
+	case n == 2:
+		exported, _ := exportJSValue(call.Argument(1))
+		return exported
+	default:
+		params := make([]any, 0, n-1)
+		for i := 1; i < n; i++ {
+			exported, err := exportJSValue(call.Argument(i))
+			if err != nil {
+				return nil
+			}
+			params = append(params, exported)
+		}
+		return params
+	}
+}
+
+func jsRPCError(vm *goja.Runtime, e *rpc.JsonRpcError) *goja.Object {
+	obj := vm.NewGoError(fmt.Errorf("%s", e.Message))
+	_ = obj.Set("code", e.Code)
+	if e.Data != nil {
+		_ = obj.Set("data", e.Data)
+	}
+	return obj
+}
+
+func normalizeRPCValue(value any) (any, error) {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return nil, fmt.Errorf("serialize RPC result: %w", err)
+	}
+
+	var normalized any
+	if err := json.Unmarshal(data, &normalized); err != nil {
+		return nil, fmt.Errorf("decode RPC result: %w", err)
+	}
+	return normalized, nil
+}
+
+// registerRoute registers (or reuses) a gin route slot for one plugin. It is
+// called from the plugin's own event loop during script evaluation and takes
+// the manager lock itself. The critical section is short and never waits on
+// the event loop, so no lock cycle is possible.
+func (m *Manager) registerRoute(short, method, path string, handler goja.Callable) (err error) {
+	key := method + " " + path
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	inst, ok := m.instances[short]
+	if !ok {
+		return fmt.Errorf("plugin %q is not loaded", short)
+	}
+	if m.engine == nil {
+		return fmt.Errorf("plugin manager has no HTTP engine")
+	}
+	if m.routes[short] == nil {
+		m.routes[short] = make(map[string]bool)
+	}
+	slotExists := m.routes[short][key]
+	inst.mu.Lock()
+	if !slotExists && inst.handlers[key] != nil {
+		inst.mu.Unlock()
+		return nil // already registered in this load
+	}
+	inst.handlers[key] = handler
+	inst.mu.Unlock()
+	if slotExists {
+		return nil // gin slot from an earlier load stays; the handler slot is refreshed
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			inst.mu.Lock()
+			delete(inst.handlers, key)
+			inst.mu.Unlock()
+			err = fmt.Errorf("register route %s %s: %v", method, path, r)
+		}
+	}()
+	m.engine.Handle(method, path, m.routeHandler(short))
+	m.routes[short][key] = true
+	return nil
+}
+
+// routeHandler bridges one gin request into the plugin event loop. The
+// handler receives (req, res); the response is written once res.end() runs
+// or the runtime timeout elapses.
+func (m *Manager) routeHandler(short string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		inst := m.instanceFor(short)
+		if inst == nil {
+			c.Status(http.StatusNotFound)
+			return
+		}
+		key := c.Request.Method + " " + c.FullPath()
+		inst.mu.RLock()
+		handler := inst.handlers[key]
+		host := inst.host
+		alive := inst.runtime != nil
+		limit := inst.info.Permissions.MaxHTTPBodyBytes
+		inst.mu.RUnlock()
+		if !alive || handler == nil || host == nil {
+			c.Status(http.StatusNotFound)
+			return
+		}
+		if limit < 1 {
+			limit = defaultMaxHTTPBodyBytes
+		}
+		body, err := httpbody.ReadAll(c.Request.Body, limit)
+		if err != nil {
+			c.Status(http.StatusRequestEntityTooLarge)
+			_, _ = c.Writer.WriteString(err.Error())
+			return
+		}
+
+		state := &routeResponse{
+			headers:    make(http.Header),
+			statusCode: http.StatusOK,
+			done:       make(chan struct{}),
+			chunks:     make(chan []byte, 4),
+			abortCh:    make(chan struct{}),
+		}
+		queued := host.RunOnLoop(func(vm *goja.Runtime) {
+			req := routeRequest(vm, c, body)
+			res := routeResponseObject(vm, state)
+			runErr := host.RunJob(vm, "plugin route "+short, func() error {
+				_, callErr := handler(goja.Undefined(), req, res)
+				return callErr
+			})
+			if runErr != nil {
+				state.finish(http.StatusInternalServerError, nil)
+			}
+		})
+		if !queued {
+			c.Status(http.StatusServiceUnavailable)
+			return
+		}
+
+		writeFinal := func(status int, body []byte) {
+			state.mu.Lock()
+			if status != 0 {
+				state.statusCode = status
+			}
+			if body != nil {
+				_, _ = state.body.Write(body)
+			}
+			for name, values := range state.headers {
+				for _, value := range values {
+					c.Header(name, value)
+				}
+			}
+			statusCode := state.statusCode
+			responseBody := append([]byte(nil), state.body.Bytes()...)
+			state.mu.Unlock()
+			c.Status(statusCode)
+			_, _ = c.Writer.Write(responseBody)
+		}
+
+		// Streaming pump: with res.streaming = true every res.write is sent back
+		// to the client and flushed immediately; normal mode buffers and writes
+		// once at res.end(). When the client disconnects, aborted is set so the
+		// plugin script can stop producing via res.isAborted().
+		idle := time.NewTimer(host.Timeout())
+		defer idle.Stop()
+		committed := false
+		for {
+			select {
+			case chunk := <-state.chunks:
+				if !committed {
+					state.mu.Lock()
+					for name, values := range state.headers {
+						for _, value := range values {
+							c.Header(name, value)
+						}
+					}
+					statusCode := state.statusCode
+					state.mu.Unlock()
+					c.Status(statusCode)
+					committed = true
+				}
+				_, _ = c.Writer.Write(chunk)
+				if flusher, ok := c.Writer.(http.Flusher); ok {
+					flusher.Flush()
+				}
+				if !idle.Stop() {
+					select {
+					case <-idle.C:
+					default:
+					}
+				}
+				idle.Reset(host.Timeout())
+			case <-state.done:
+				if !committed {
+					writeFinal(0, nil)
+				}
+				return
+			case <-c.Request.Context().Done():
+				state.aborted.Store(true)
+				close(state.abortCh)
+				return
+			case <-idle.C:
+				if state.isStreaming() {
+					// Streaming idle timeout: end the stream and notify JS
+					state.aborted.Store(true)
+					close(state.abortCh)
+					return
+				}
+				writeFinal(http.StatusGatewayTimeout, []byte("plugin route handler timed out"))
+				return
+			}
+		}
+	}
+}
+
+// staticConfig is the current static folder config of one mount path. It is
+// stored on the Instance so the gin slot (which survives unload) always reads
+// the config of the latest load.
+type staticConfig struct {
+	dir string // absolute folder path inside the plugin directory
+	spa bool   // fall back to index.html for unmatched paths
+}
+
+// registerStatic serves a folder from the plugin directory at a mount path.
+// It registers GET and HEAD slots for both the mount path and its wildcard
+// so /ui and /ui/anything both reach the folder. Like registerRoute, the gin
+// slots survive unload (they return 404) and are reused on reload; the
+// handler always resolves the current config from the instance.
+func (m *Manager) registerStatic(short, mount, dir string, spa bool) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	inst, ok := m.instances[short]
+	if !ok {
+		return fmt.Errorf("plugin %q is not loaded", short)
+	}
+	if m.engine == nil {
+		return fmt.Errorf("plugin manager has no HTTP engine")
+	}
+	absDir := filepath.Join(inst.dir, dir)
+	if !withinDir(absDir, inst.dir) {
+		return fmt.Errorf("static folder %q must be inside the plugin directory", dir)
+	}
+	fi, statErr := os.Stat(absDir)
+	if statErr != nil || !fi.IsDir() {
+		return fmt.Errorf("static folder %q does not exist", dir)
+	}
+	if m.routes[short] == nil {
+		m.routes[short] = make(map[string]bool)
+	}
+	inst.mu.Lock()
+	inst.statics[mount] = &staticConfig{dir: absDir, spa: spa}
+	inst.mu.Unlock()
+
+	key := "STATIC " + mount
+	if m.routes[short][key] {
+		return nil // gin slots from an earlier load stay; the config was refreshed above
+	}
+	defer func() {
+		if r := recover(); r != nil {
+			inst.mu.Lock()
+			delete(inst.statics, mount)
+			inst.mu.Unlock()
+			err = fmt.Errorf("register static %s: %v", mount, r)
+		}
+	}()
+	handler := m.staticHandler(short, mount)
+	for _, method := range []string{http.MethodGet, http.MethodHead} {
+		m.engine.Handle(method, mount, handler)
+		m.engine.Handle(method, mount+"/*filepath", handler)
+	}
+	m.routes[short][key] = true
+	return nil
+}
+
+// staticHandler serves files from a static folder. Requests to the mount
+// path resolve to index.html; requests into subpaths resolve to the matching
+// file. With spa enabled, any unmatched path (including directories without
+// an index.html) falls back to index.html so client-side routers work.
+func (m *Manager) staticHandler(short, mount string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		inst := m.instanceFor(short)
+		if inst == nil {
+			c.Status(http.StatusNotFound)
+			return
+		}
+		inst.mu.RLock()
+		cfg := inst.statics[mount]
+		inst.mu.RUnlock()
+		if cfg == nil {
+			c.Status(http.StatusNotFound)
+			return
+		}
+		name := strings.TrimPrefix(c.Request.URL.Path, mount)
+		name = strings.TrimPrefix(name, "/")
+		target, err := resolveStaticFile(cfg.dir, name)
+		if err != nil {
+			if !cfg.spa {
+				c.Status(http.StatusNotFound)
+				return
+			}
+			target = filepath.Join(cfg.dir, "index.html")
+		}
+		c.File(target)
+	}
+}
+
+// resolveStaticFile maps a request path to a file inside a static folder,
+// rejecting traversal. A directory resolves to its index.html.
+func resolveStaticFile(dir, name string) (string, error) {
+	if name == "" {
+		name = "index.html"
+	}
+	if !filepath.IsLocal(name) {
+		return "", fmt.Errorf("invalid static path %q", name)
+	}
+	full := filepath.Join(dir, name)
+	if !withinDir(full, dir) {
+		return "", fmt.Errorf("invalid static path %q", name)
+	}
+	fi, err := os.Stat(full)
+	if err != nil {
+		return "", err
+	}
+	if fi.IsDir() {
+		full = filepath.Join(full, "index.html")
+		if _, err := os.Stat(full); err != nil {
+			return "", err
+		}
+	}
+	return full, nil
+}
+
+// routeResponse is the Go side of the JS response object. It mirrors the
+// minimal nodeHTTPResponse pattern from the jsruntime http module. When
+// res.streaming is enabled, chunks are pushed through a channel and written
+// back to the client immediately instead of being buffered.
+type routeResponse struct {
+	mu         sync.Mutex
+	headers    http.Header
+	body       bytes.Buffer
+	statusCode int
+	ended      bool
+	done       chan struct{}
+
+	streaming bool
+	chunks    chan []byte
+	aborted   atomic.Bool
+	abortCh   chan struct{}
+}
+
+func (state *routeResponse) markStreaming() {
+	state.mu.Lock()
+	state.streaming = true
+	state.mu.Unlock()
+}
+
+func (state *routeResponse) isStreaming() bool {
+	state.mu.Lock()
+	defer state.mu.Unlock()
+	return state.streaming
+}
+
+// pushChunk delivers a streamed chunk to the HTTP pump. It returns false
+// when the client connection is gone so the script can stop producing.
+func (state *routeResponse) pushChunk(p []byte) bool {
+	select {
+	case state.chunks <- p:
+		return true
+	case <-state.abortCh:
+		return false
+	}
+}
+
+func (state *routeResponse) finish(status int, body []byte) {
+	state.mu.Lock()
+	defer state.mu.Unlock()
+	if state.ended {
+		return
+	}
+	if status != 0 {
+		state.statusCode = status
+	}
+	if body != nil {
+		_, _ = state.body.Write(body)
+	}
+	state.ended = true
+	close(state.done)
+}
+
+func routeRequest(vm *goja.Runtime, c *gin.Context, body []byte) *goja.Object {
+	req := hookRequestObject(vm, c.Request, body)
+	_ = req.Set("context", routeRequestContext(vm, c))
+	return req
+}
+
+func routeResponseObject(vm *goja.Runtime, state *routeResponse) *goja.Object {
+	res := vm.NewObject()
+	_ = res.Set("statusCode", http.StatusOK)
+	_ = res.Set("statusMessage", "")
+	_ = res.Set("streaming", false)
+	_ = res.Set("isAborted", func() bool { return state.aborted.Load() })
+	_ = res.Set("setHeader", func(name string, value goja.Value) *goja.Object {
+		state.mu.Lock()
+		defer state.mu.Unlock()
+		var values []string
+		if err := vm.ExportTo(value, &values); err == nil {
+			state.headers[name] = values
+		} else {
+			state.headers.Set(name, value.String())
+		}
+		return res
+	})
+	_ = res.Set("getHeader", func(name string) goja.Value {
+		state.mu.Lock()
+		defer state.mu.Unlock()
+		values := state.headers.Values(name)
+		if len(values) == 0 {
+			return goja.Undefined()
+		}
+		if len(values) == 1 {
+			return vm.ToValue(values[0])
+		}
+		return vm.ToValue(values)
+	})
+	_ = res.Set("removeHeader", func(name string) {
+		state.mu.Lock()
+		state.headers.Del(name)
+		state.mu.Unlock()
+	})
+	_ = res.Set("write", func(call goja.FunctionCall) goja.Value {
+		data := buffer.Bytes(vm, call.Argument(0))
+		if value := res.Get("streaming"); value != nil && value.ToBoolean() {
+			state.markStreaming()
+			_ = state.pushChunk(data)
+			return vm.ToValue(true)
+		}
+		state.mu.Lock()
+		_, _ = state.body.Write(data)
+		state.mu.Unlock()
+		return vm.ToValue(true)
+	})
+	_ = res.Set("end", func(call goja.FunctionCall) goja.Value {
+		state.mu.Lock()
+		if len(call.Arguments) > 0 && !goja.IsUndefined(call.Argument(0)) && !goja.IsNull(call.Argument(0)) {
+			_, _ = state.body.WriteString(call.Argument(0).String())
+		}
+		state.statusCode = int(res.Get("statusCode").ToInteger())
+		if !state.ended {
+			state.ended = true
+			close(state.done)
+		}
+		state.mu.Unlock()
+		return res
+	})
+	return res
+}
@@ -0,0 +1,83 @@
+package plugin
+
+import (
+	"encoding/json"
+	"os"
+	"sync"
+	"time"
+)
+
+// State persists the enabled flag, the approved permissions hash and the
+// last error for each installed plugin in DataDir/state.json. Keeping it
+// next to the plugin directories keeps plugin management self-contained.
+type State struct {
+	mu      sync.Mutex
+	path    string
+	current map[string]PluginState
+}
+
+// PluginState is the persisted state of one plugin.
+type PluginState struct {
+	Enabled                 bool      `json:"enabled"`
+	ApprovedPermissionsHash string    `json:"approved_permissions_hash"`
+	LastError               string    `json:"last_error"`
+	UpdatedAt               time.Time `json:"updated_at"`
+}
+
+func openState(path string) *State {
+	return &State{path: path}
+}
+
+func (s *State) get(short string) PluginState {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.ensure()
+	return s.current[short]
+}
+
+func (s *State) set(short string, st PluginState) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.ensure()
+	st.UpdatedAt = time.Now().UTC()
+	s.current[short] = st
+	s.saveLocked()
+}
+
+func (s *State) delete(short string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.ensure()
+	if _, ok := s.current[short]; ok {
+		delete(s.current, short)
+		s.saveLocked()
+	}
+}
+
+func (s *State) ensure() {
+	if s.current != nil {
+		return
+	}
+	s.current = map[string]PluginState{}
+	data, err := os.ReadFile(s.path)
+	if err != nil {
+		return
+	}
+	var file struct {
+		Plugins map[string]PluginState `json:"plugins"`
+	}
+	if json.Unmarshal(data, &file) == nil && file.Plugins != nil {
+		s.current = file.Plugins
+	}
+}
+
+func (s *State) saveLocked() {
+	file := struct {
+		Plugins map[string]PluginState `json:"plugins"`
+	}{Plugins: s.current}
+	data, err := json.MarshalIndent(file, "", "  ")
+	if err != nil {
+		return
+	}
+	_ = os.WriteFile(s.path, data, 0644)
+}
@@ -0,0 +1,201 @@
+package plugin
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"fmt"
+	"image"
+	"image/jpeg"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+func encodeTestJPEG(t *testing.T) []byte {
+	t.Helper()
+	img := image.NewRGBA(image.Rect(0, 0, 32, 32))
+	var buf bytes.Buffer
+	if err := jpeg.Encode(&buf, img, nil); err != nil {
+		t.Fatal(err)
+	}
+	return buf.Bytes()
+}
+
+// TestBuiltinStyleStreamingWithResponseHooks 模拟普通 Gin handler 风格的流式
+// 路由（直接写 c.Writer + Flush）在存在 response hook 时仍然能把数据推给客户端。
+// 回归：bufferedResponseWriter 此前会吞掉所有 Write，直到 handler 返回（流式
+// handler 永不返回），客户端因此收不到任何数据（黑屏）。
+func TestBuiltinStyleStreamingWithResponseHooks(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	Init(engine)
+
+	hookZip := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Hook","short":"hook","version":"1.0.0","permissions":{"timeout":5,"allowHooks":true}}`,
+		"script.js": `const server = require("server");
+function load() {
+  server.hook("response", (req, res) => { res.headers["x-hooked"] = "1"; });
+}
+`,
+	})
+	if _, err := InstallZip(hookZip); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("hook", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("hook", false, false) }()
+
+	frame := encodeTestJPEG(t)
+	engine.GET("/live", func(c *gin.Context) {
+		c.Header("Content-Type", "multipart/x-mixed-replace; boundary=frame")
+		for i := 0; i < 5; i++ {
+			_, _ = c.Writer.WriteString("--frame\r\nContent-Type: image/jpeg\r\n\r\n")
+			_, _ = c.Writer.Write(frame)
+			_, _ = c.Writer.WriteString("\r\n")
+			c.Writer.Flush()
+			time.Sleep(20 * time.Millisecond)
+		}
+	})
+
+	wrapped := WrapHandler(engine)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, "http://127.0.0.1/live", nil)
+	rec := httptest.NewRecorder()
+	wrapped.ServeHTTP(rec, req)
+	body := rec.Body.Bytes()
+
+	if ct := rec.Header().Get("Content-Type"); !strings.Contains(ct, "multipart/x-mixed-replace") {
+		t.Fatalf("content-type = %q, want multipart stream", ct)
+	}
+	if !bytes.Contains(body, []byte("--frame")) || !bytes.Contains(body, []byte{0xFF, 0xD8}) {
+		t.Fatalf("streamed body missing frames: len=%d", len(body))
+	}
+	// 流式响应不能被 response hook 改写，也不应带上 hook 头
+	if got := rec.Header().Get("X-Hooked"); got != "" {
+		t.Fatalf("streaming response unexpectedly rewritten by response hook: x-hooked=%q", got)
+	}
+}
+
+// TestRouteStreamingMJPEG 用本地“摄像头”（单张 JPEG）验证流式路由：
+// multipart 帧即时写出、客户端断开后脚本通过 isAborted 退出循环。
+func TestRouteStreamingMJPEG(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	Init(engine)
+
+	frame := encodeTestJPEG(t)
+	camera := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set("Content-Type", "image/jpeg")
+		_, _ = w.Write(frame)
+	}))
+	defer camera.Close()
+
+	script := fmt.Sprintf(`
+		const server = require("server");
+		function load() {
+			server.route("GET", "/stream", async (req, res) => {
+				res.streaming = true;
+				res.setHeader("Content-Type", "multipart/x-mixed-replace; boundary=frame");
+				res.setHeader("Cache-Control", "no-cache");
+				while (!res.isAborted()) {
+					try {
+						const resp = await fetch("%s");
+						const data = await resp.arrayBuffer();
+						res.write("--frame\r\nContent-Type: image/jpeg\r\nContent-Length: " + data.byteLength + "\r\n\r\n");
+						res.write(data);
+						res.write("\r\n");
+					} catch (e) {
+						console.log("frame error: " + e.message);
+					}
+					await new Promise((resolve) => setTimeout(resolve, 50));
+				}
+				console.log("stream ended");
+			});
+		}
+	`, camera.URL)
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Mjpeg","short":"mjpeg","version":"1.0.0","permissions":{"node":true,"timeout":5,"allowRoutes":true}}`,
+		"script.js":          script,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("mjpeg", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("mjpeg", false, false) }()
+
+	srv := httptest.NewServer(engine)
+	defer srv.Close()
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, srv.URL+"/stream", nil)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer resp.Body.Close()
+	if ct := resp.Header.Get("Content-Type"); !strings.Contains(ct, "multipart/x-mixed-replace") {
+		t.Fatalf("content-type = %q", ct)
+	}
+
+	// 读取第一个完整帧并校验 JPEG magic 与长度
+	reader := bufio.NewReader(resp.Body)
+	deadline := time.Now().Add(5 * time.Second)
+	found := false
+	for time.Now().Before(deadline) {
+		line, err := reader.ReadBytes(10)
+		if err != nil {
+			t.Fatalf("read stream: %v", err)
+		}
+		if !bytes.Contains(line, []byte("--frame")) {
+			continue
+		}
+		_, _ = reader.ReadBytes(10) // Content-Type
+		lengthLine, err := reader.ReadBytes(10)
+		if err != nil {
+			t.Fatalf("read length line: %v", err)
+		}
+		length, _ := strconv.Atoi(strings.TrimSpace(strings.TrimPrefix(string(lengthLine), "Content-Length:")))
+		_, _ = reader.ReadBytes(10) // 空行
+		head := make([]byte, 2)
+		if _, err := io.ReadFull(reader, head); err != nil {
+			t.Fatalf("read jpeg head: %v", err)
+		}
+		if head[0] != 0xFF || head[1] != 0xD8 {
+			t.Fatalf("jpeg magic = % X", head)
+		}
+		rest := make([]byte, length-2)
+		if _, err := io.ReadFull(reader, rest); err != nil {
+			t.Fatalf("read jpeg body: %v", err)
+		}
+		found = true
+		break
+	}
+	if !found {
+		t.Fatal("no frame received within 5s")
+	}
+
+	// 客户端断开 → 脚本 isAborted 退出循环
+	cancel()
+	deadline = time.Now().Add(5 * time.Second)
+	for time.Now().Before(deadline) {
+		if logs := GetLogs("mjpeg"); strings.Contains(logs, "stream ended") {
+			return
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+	t.Fatalf("stream did not stop after disconnect; logs = %q", GetLogs("mjpeg"))
+}
@@ -0,0 +1,99 @@
+package plugin
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+)
+
+// TestIsUpgradeRequest 覆盖升级请求判定：真正的协议升级必须同时携带
+// Connection: upgrade 记号与 Upgrade 目标协议头（RFC 9110 §7.8）；仅带
+// 其中一个头的普通请求（如反代模板给每个请求无条件附加
+// Connection: upgrade）不得被视为升级。
+func TestIsUpgradeRequest(t *testing.T) {
+	cases := []struct {
+		name       string
+		connection string
+		upgrade    string
+		want       bool
+	}{
+		{"websocket upgrade with both headers", "upgrade", "websocket", true},
+		{"case insensitive", "Upgrade", "WebSocket", true},
+		{"connection list keeps other tokens", "keep-alive, upgrade", "websocket", true},
+		{"bare connection upgrade is not an upgrade", "upgrade", "", false},
+		{"upgrade header alone is not an upgrade", "", "websocket", false},
+		{"plain request", "", "", false},
+		{"keep-alive only", "keep-alive", "", false},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			req := httptest.NewRequest(http.MethodGet, "/", nil)
+			if tc.connection != "" {
+				req.Header.Set("Connection", tc.connection)
+			}
+			if tc.upgrade != "" {
+				req.Header.Set("Upgrade", tc.upgrade)
+			}
+			if got := isUpgradeRequest(req); got != tc.want {
+				t.Fatalf("isUpgradeRequest(Connection=%q, Upgrade=%q) = %v, want %v",
+					tc.connection, tc.upgrade, got, tc.want)
+			}
+		})
+	}
+}
+
+// TestInjectSurvivesBareConnectionUpgradeHeader 回归：部分反代模板（如 1Panel
+// 的 OpenResty 站点模板）会给每个代理请求无条件附加 Connection: upgrade。
+// 这类普通页面请求必须照常获得插件 HTML 注入；只有同时携带两个头的真实升级
+// 才走放行路径。
+func TestInjectSurvivesBareConnectionUpgradeHeader(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	engine := gin.New()
+	engine.GET("/admin/dashboard", func(c *gin.Context) {
+		c.Data(http.StatusOK, "text/html; charset=utf-8",
+			[]byte("<!DOCTYPE html><html><head></head><body></body></html>"))
+	})
+	Init(engine)
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Guard","short":"guard","version":"1.0.0","permissions":{"allowHTMLInject":true,"timeout":5}}`,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.injectHTML("", "<script>window.__guard = 1;</script>");
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("guard", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("guard", false, false) }()
+
+	handler := HTMLInjectHandler(engine)
+
+	// 仅 Connection: upgrade（反代常见行为）→ 注入照常生效
+	req := httptest.NewRequest(http.MethodGet, "/admin/dashboard", nil)
+	req.Header.Set("Connection", "upgrade")
+	rec := httptest.NewRecorder()
+	handler.ServeHTTP(rec, req)
+	if !strings.Contains(rec.Body.String(), "__guard") {
+		t.Fatalf("bare Connection: upgrade must not skip injection, body = %q", rec.Body.String())
+	}
+
+	// 两个头齐全的真实升级 → 放行，不注入
+	req2 := httptest.NewRequest(http.MethodGet, "/admin/dashboard", nil)
+	req2.Header.Set("Connection", "upgrade")
+	req2.Header.Set("Upgrade", "websocket")
+	rec2 := httptest.NewRecorder()
+	handler.ServeHTTP(rec2, req2)
+	if strings.Contains(rec2.Body.String(), "__guard") {
+		t.Fatalf("real upgrade must skip injection, body = %q", rec2.Body.String())
+	}
+}
@@ -0,0 +1,89 @@
+package plugin
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/komari-monitor/komari/utils"
+)
+
+// CheckKomariVersion validates a manifest komari constraint against the
+// running server version. Supported constraints: empty (any version),
+// "x.y.z" (exact), and ">=x.y.z", ">x.y.z", "<=x.y.z", "<x.y.z". An optional
+// leading "v" is accepted.
+func CheckKomariVersion(constraint string) error {
+	constraint = strings.TrimSpace(constraint)
+	if constraint == "" {
+		return nil
+	}
+	rest := constraint
+	op := ""
+	for _, candidate := range []string{">=", "<=", ">", "<", "="} {
+		if strings.HasPrefix(rest, candidate) {
+			op = candidate
+			rest = strings.TrimSpace(strings.TrimPrefix(rest, candidate))
+			break
+		}
+	}
+	want, err := parseSemver(rest)
+	if err != nil {
+		return fmt.Errorf("invalid komari version constraint %q: %w", constraint, err)
+	}
+	have, err := parseSemver(utils.CurrentVersion)
+	if err != nil {
+		// A malformed server version must not block plugin loading.
+		return nil
+	}
+	if !satisfies(compareSemver(have, want), op) {
+		return fmt.Errorf("plugin requires komari %s, running %s", constraint, utils.CurrentVersion)
+	}
+	return nil
+}
+
+func satisfies(cmp int, op string) bool {
+	switch op {
+	case ">=":
+		return cmp >= 0
+	case ">":
+		return cmp > 0
+	case "<=":
+		return cmp <= 0
+	case "<":
+		return cmp < 0
+	default: // exact
+		return cmp == 0
+	}
+}
+
+func parseSemver(s string) ([3]int, error) {
+	s = strings.TrimSpace(strings.TrimPrefix(s, "v"))
+	if s == "" {
+		return [3]int{}, fmt.Errorf("empty version")
+	}
+	parts := strings.Split(s, ".")
+	if len(parts) > 3 {
+		return [3]int{}, fmt.Errorf("too many version parts")
+	}
+	var v [3]int
+	for i, part := range parts {
+		n, err := strconv.Atoi(part)
+		if err != nil || n < 0 {
+			return [3]int{}, fmt.Errorf("invalid version part %q", part)
+		}
+		v[i] = n
+	}
+	return v, nil
+}
+
+func compareSemver(a, b [3]int) int {
+	for i := 0; i < 3; i++ {
+		if a[i] < b[i] {
+			return -1
+		}
+		if a[i] > b[i] {
+			return 1
+		}
+	}
+	return 0
+}
@@ -0,0 +1,30 @@
+package plugin
+
+import "testing"
+
+func TestCheckKomariVersion(t *testing.T) {
+	tests := []struct {
+		constraint string
+		wantErr    bool
+	}{
+		{"", false},
+		{"0.0.1", false},
+		{"v0.0.1", false},
+		{">=0.0.1", false},
+		{">0.0.1", true},
+		{"<1.0.0", false},
+		{"<=0.0.1", false},
+		{">=99.0.0", true},
+		{"0.1", true}, // 0.1.0 > 0.0.1
+		{"1", true},   // 1.0.0 > 0.0.1
+		{"1.2.3.4", true},
+		{"abc", true},
+		{">", true},
+	}
+	for _, tt := range tests {
+		err := CheckKomariVersion(tt.constraint)
+		if (err != nil) != tt.wantErr {
+			t.Errorf("CheckKomariVersion(%q) error = %v, wantErr %v", tt.constraint, err, tt.wantErr)
+		}
+	}
+}
@@ -0,0 +1,233 @@
+package plugin
+
+import (
+	"time"
+
+	"github.com/dop251/goja"
+	"github.com/gorilla/websocket"
+	"github.com/komari-monitor/komari/web/connection"
+)
+
+// WebSocket hook kinds. wsConnect runs right after the upgrade and may deny
+// the connection; wsMessage/wsSend see every inbound/outbound frame;
+// wsClose fires once when the connection ends. Path filtering reuses the
+// HTTP matcher syntax without the method prefix, since every upgrade is a
+// GET. Like the HTTP kinds, the input is lowercased, so any casing works
+// from JS.
+const (
+	hookWSConnect  hookKind = "wsconnect"
+	hookWSMessage  hookKind = "wsmessage"
+	hookWSSend     hookKind = "wssend"
+	hookWSClose    hookKind = "wsclose"
+)
+
+// wsFrameHookTimeout bounds one frame-level callback. The agent read pumps
+// run on the agent read deadline; a frame hook must never stall
+// them, so the wait is cut short and the frame passes through untouched.
+const wsFrameHookTimeout = time.Second
+
+// maxWSFrameBytes caps the payload copied into the plugin event loop; larger
+// frames pass through without invoking the hooks.
+const maxWSFrameBytes = 8 << 20
+
+// isWSHookKind reports whether kind is one of the WebSocket hook kinds.
+func isWSHookKind(kind string) bool {
+	switch kind {
+	case string(hookWSConnect), string(hookWSMessage), string(hookWSSend), string(hookWSClose):
+		return true
+	default:
+		return false
+	}
+}
+
+// OnConnect implements connection.FrameInterceptor. It runs the wsConnect
+// hooks registered for the connection path; the first denial rejects the
+// connection.
+func (m *Manager) OnConnect(info *connection.ConnInfo) (deny bool, reason string) {
+	for _, h := range m.wsHooksFor(hookWSConnect, info.Path) {
+		var denied bool
+		var why string
+		queued, timedOut := runHookTurn(h.host, "plugin wsConnect hook "+h.short, func(vm *goja.Runtime) {
+			_ = h.host.RunJob(vm, "plugin wsConnect hook "+h.short, func() error {
+				res, err := h.fn(goja.Undefined(), wsHookContext(vm, info))
+				if err != nil {
+					return err
+				}
+				if goja.IsUndefined(res) || goja.IsNull(res) {
+					return nil
+				}
+				obj := res.ToObject(vm)
+				if v := obj.Get("deny"); v != nil && v.ToBoolean() {
+					denied = true
+				}
+				if v := obj.Get("reason"); v != nil && !goja.IsUndefined(v) {
+					why = v.String()
+				}
+				return nil
+			})
+		})
+		if !queued {
+			continue // runtime closed; later plugins still get a chance
+		}
+		if timedOut {
+			m.logWSHookTimeout(h)
+			continue
+		}
+		if denied {
+			return true, why
+		}
+	}
+	return false, ""
+}
+
+// OnMessage implements connection.FrameInterceptor for inbound frames.
+func (m *Manager) OnMessage(info *connection.ConnInfo, frameType int, data []byte) (int, []byte, bool) {
+	return m.runFrameHooks(hookWSMessage, info, frameType, data)
+}
+
+// OnSend implements connection.FrameInterceptor for outbound frames.
+func (m *Manager) OnSend(info *connection.ConnInfo, frameType int, data []byte) (int, []byte, bool) {
+	return m.runFrameHooks(hookWSSend, info, frameType, data)
+}
+
+// runFrameHooks runs the wsMessage/wsSend chain for one frame in
+// registration order; each hook sees the previous hook's replacement. A drop
+// wins over later hooks. Timeouts, errors and oversized frames pass the
+// frame through.
+func (m *Manager) runFrameHooks(kind hookKind, info *connection.ConnInfo, frameType int, data []byte) (int, []byte, bool) {
+	hooks := m.wsHooksFor(kind, info.Path)
+	if len(hooks) == 0 || len(data) > maxWSFrameBytes {
+		return frameType, data, false
+	}
+	next := data
+	for _, h := range hooks {
+		var drop bool
+		var hookErr error
+		queued, timedOut := runHookTurnTimeout(h.host, "plugin "+string(kind)+" hook "+h.short, wsFrameHookTimeout, func(vm *goja.Runtime) {
+			msg := wsFrameObject(vm, info, frameType, next)
+			hookErr = h.host.RunJob(vm, "plugin "+string(kind)+" hook "+h.short, func() error {
+				res, err := h.fn(goja.Undefined(), wsHookContext(vm, info), msg)
+				if err != nil {
+					return err
+				}
+				if goja.IsUndefined(res) || goja.IsNull(res) {
+					return nil
+				}
+				obj := res.ToObject(vm)
+				if v := obj.Get("drop"); v != nil && v.ToBoolean() {
+					drop = true
+					return nil
+				}
+				if v := obj.Get("type"); v != nil && !goja.IsUndefined(v) {
+					frameType = int(v.ToInteger())
+				}
+				if v := obj.Get("data"); v != nil && !goja.IsUndefined(v) && !goja.IsNull(v) {
+					if data := wsFrameBytes(vm, v); data != nil {
+						next = data
+					}
+				}
+				return nil
+			})
+		})
+		if !queued {
+			return frameType, next, false // runtime closed: pass the frame on
+		}
+		if timedOut {
+			m.logWSHookTimeout(h)
+			continue
+		}
+		if hookErr != nil {
+			m.logHookError(h, hookErr)
+			continue
+		}
+		if drop {
+			return frameType, nil, true
+		}
+	}
+	return frameType, next, false
+}
+
+// OnClose implements connection.FrameInterceptor for connection teardown.
+func (m *Manager) OnClose(info *connection.ConnInfo) {
+	for _, h := range m.wsHooksFor(hookWSClose, info.Path) {
+		var hookErr error
+		queued, timedOut := runHookTurn(h.host, "plugin wsClose hook "+h.short, func(vm *goja.Runtime) {
+			hookErr = h.host.RunJob(vm, "plugin wsClose hook "+h.short, func() error {
+				_, err := h.fn(goja.Undefined(), wsHookContext(vm, info))
+				return err
+			})
+		})
+		if !queued {
+			return
+		}
+		if timedOut {
+			m.logWSHookTimeout(h)
+			continue
+		}
+		if hookErr != nil {
+			m.logHookError(h, hookErr)
+		}
+	}
+}
+
+// wsHooksFor returns the hooks of one ws kind whose matcher matches the
+// connection path, in registration order.
+func (m *Manager) wsHooksFor(kind hookKind, path string) []*hookEntry {
+	all := m.hooksOf(kind)
+	kept := all[:0]
+	for _, h := range all {
+		if h.matcher == nil || h.matcher.matchesPath(path) {
+			kept = append(kept, h)
+		}
+	}
+	return kept
+}
+
+// wsHookContext builds the immutable per-connection context object.
+func wsHookContext(vm *goja.Runtime, info *connection.ConnInfo) *goja.Object {
+	ctx := vm.NewObject()
+	_ = ctx.Set("path", info.Path)
+	_ = ctx.Set("connId", info.ID)
+	_ = ctx.Set("remoteIp", info.RemoteIP)
+	_ = ctx.Set("userAgent", info.UserAgent)
+	if info.ClientUUID != "" {
+		_ = ctx.Set("clientUuid", info.ClientUUID)
+	}
+	return ctx
+}
+
+// wsFrameObject builds the frame object handed to wsMessage/wsSend hooks.
+// Text frames arrive as strings, binary frames as ArrayBuffers.
+func wsFrameObject(vm *goja.Runtime, info *connection.ConnInfo, frameType int, data []byte) *goja.Object {
+	msg := vm.NewObject()
+	_ = msg.Set("type", frameType)
+	if frameType == websocket.BinaryMessage {
+		_ = msg.Set("data", vm.NewArrayBuffer(append([]byte(nil), data...)))
+	} else {
+		_ = msg.Set("data", string(data))
+	}
+	_ = msg.Set("connId", info.ID)
+	_ = msg.Set("path", info.Path)
+	return msg
+}
+
+// wsFrameBytes converts a hook-returned payload (string or ArrayBuffer) back
+// to bytes; anything else reports nil and leaves the frame untouched.
+func wsFrameBytes(vm *goja.Runtime, v goja.Value) []byte {
+	if goja.IsString(v) {
+		return []byte(v.String())
+	}
+	var data []byte
+	if err := vm.ExportTo(v, &data); err == nil {
+		return data
+	}
+	return nil
+}
+
+// logWSHookTimeout records a timed-out ws hook for the plugin console.
+func (m *Manager) logWSHookTimeout(h *hookEntry) {
+	_, _ = m.logStore(h.short).Write([]byte("[plugin] " + string(h.kind) + " hook timed out; the message passed through unmodified\n"))
+}
+
+// The Manager is the process-wide WebSocket frame interceptor.
+var _ connection.FrameInterceptor = (*Manager)(nil)
@@ -0,0 +1,319 @@
+package plugin
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/komari-monitor/komari/web/connection"
+)
+
+// wsManifest is a plugin manifest that declares the hooks permission (the
+// ws kinds reuse allowHooks).
+const wsManifest = `{"name":"Ws","short":"ws","version":"1.0.0","permissions":{"allowHooks":true,"timeout":5}}`
+
+func wsInfo(path string) *connection.ConnInfo {
+	return &connection.ConnInfo{ID: 1, Path: path, RemoteIP: "203.0.113.9", UserAgent: "test"}
+}
+
+// TestWSHookConnectDenyAndAllow 验证 wsConnect 钩子：返回 {deny:true,reason}
+// 拒绝连接，返回 undefined 放行。
+func TestWSHookConnectDenyAndAllow(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsConnect", (ctx) => {
+					if (ctx.path === "/deny") return { deny: true, reason: "no agents here" };
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("ws", false, false) }()
+
+	if deny, reason := global.OnConnect(wsInfo("/deny")); !deny || reason != "no agents here" {
+		t.Fatalf("deny = %v, reason = %q", deny, reason)
+	}
+	if deny, reason := global.OnConnect(wsInfo("/api/clients/v2/rpc")); deny || reason != "" {
+		t.Fatalf("unmatched path must be allowed, deny = %v, reason = %q", deny, reason)
+	}
+}
+
+// TestWSHookMessageChainReplaceAndDrop 验证 wsMessage 钩子链：按注册顺序链式
+// 传递替换结果，drop 优先于后续钩子。
+func TestWSHookMessageChainReplaceAndDrop(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsMessage", (ctx, msg) => {
+					if (msg.data === "hello") return { data: "hi" };
+				});
+				server.hook("wsMessage", (ctx, msg) => {
+					if (msg.data === "dropme" || msg.data === "hi") return { drop: true };
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("ws", false, false) }()
+
+	info := wsInfo("/api/clients/v2/rpc")
+	// 第一个钩子改 hello->hi，第二个钩子丢弃 hi：结果应为 drop。
+	if _, _, drop := global.OnMessage(info, 1, []byte("hello")); !drop {
+		t.Fatal("chained replace followed by drop must drop")
+	}
+	// 第一个钩子不匹配，第二个钩子丢弃 dropme。
+	if _, _, drop := global.OnMessage(info, 1, []byte("dropme")); !drop {
+		t.Fatal("direct drop must drop")
+	}
+	// 两个钩子都不匹配：原样放行。
+	typ, data, drop := global.OnMessage(info, 1, []byte("other"))
+	if drop || typ != 1 || string(data) != "other" {
+		t.Fatalf("pass-through = type %d data %q drop %v", typ, data, drop)
+	}
+}
+
+// TestWSHookSendReplacesType 验证 wsSend 钩子可以同时替换帧类型与载荷。
+func TestWSHookSendReplacesType(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsSend", (ctx, msg) => {
+					if (msg.data === "text") return { type: 2, data: "bin" };
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("ws", false, false) }()
+
+	typ, data, drop := global.OnSend(wsInfo("/api/rpc2"), 1, []byte("text"))
+	if drop || typ != 2 || string(data) != "bin" {
+		t.Fatalf("send rewrite = type %d data %q drop %v", typ, data, drop)
+	}
+}
+
+// TestWSHookClose 验证 wsClose 钩子在连接结束时触发。
+func TestWSHookClose(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Ws","short":"ws","version":"1.0.0","permissions":{"node":true,"allowHooks":true,"timeout":5}}`,
+		"script.js": `
+			const fs = require("fs");
+			const server = require("server");
+			function load() {
+				server.hook("wsClose", (ctx) => {
+					fs.appendFileSync("closes.txt", ctx.path + "\n");
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("ws", false, false) }()
+
+	global.OnClose(wsInfo("/api/clients/v2/rpc"))
+	global.OnClose(wsInfo("/api/clients/v2/rpc"))
+
+	data, err := os.ReadFile(filepath.Join(DataDir, "ws", "closes.txt"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := string(data); strings.Count(got, "/api/clients/v2/rpc") != 2 {
+		t.Fatalf("wsClose fired %d times: %q", strings.Count(got, "/api/clients/v2/rpc"), got)
+	}
+}
+
+// TestWSHookPathFiltering 验证 ws kind 的路径 matcher 只拦截匹配端点的连接。
+func TestWSHookPathFiltering(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsMessage", "/api/clients/v2/rpc", (ctx, msg) => {
+					return { data: "filtered" };
+				});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("ws", false, false) }()
+
+	typ, data, _ := global.OnMessage(wsInfo("/api/clients/v2/rpc"), 1, []byte("x"))
+	if string(data) != "filtered" {
+		t.Fatalf("matching path not intercepted: %q", data)
+	}
+	typ, data, _ = global.OnMessage(wsInfo("/api/rpc2"), 1, []byte("x"))
+	if typ != 1 || string(data) != "x" {
+		t.Fatalf("non-matching path intercepted: type %d data %q", typ, data)
+	}
+}
+
+// TestWSHookMethodPrefixRejected 验证 ws kind 的 matcher 不接受方法前缀。
+func TestWSHookMethodPrefixRejected(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsMessage", "POST /api/x", (ctx, msg) => {});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err == nil || !strings.Contains(err.Error(), "path matcher") {
+		t.Fatalf("method prefix must fail loading: %v", err)
+	}
+}
+
+// TestWSHookRequiresPermission 验证 ws kind 缺 allowHooks 时加载失败（与
+// 请求/响应钩子共用同一权限）。
+func TestWSHookRequiresPermission(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": `{"name":"Ws","short":"ws","version":"1.0.0","permissions":{"timeout":5}}`,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsConnect", (ctx) => {});
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err == nil || !strings.Contains(err.Error(), "allowHooks") {
+		t.Fatalf("missing allowHooks must fail loading: %v", err)
+	}
+}
+
+// TestWSHookUnloadRemovesHooks 验证卸载后 ws 钩子全部移除。
+func TestWSHookUnloadRemovesHooks(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsMessage", (ctx, msg) => { return { data: "hooked" }; });
+				server.hook("wsConnect", (ctx) => { return { deny: true }; });
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	if deny, _ := global.OnConnect(wsInfo("/x")); !deny {
+		t.Fatal("wsConnect must deny while loaded")
+	}
+	if err := SetEnabled("ws", false, false); err != nil {
+		t.Fatal(err)
+	}
+	if deny, _ := global.OnConnect(wsInfo("/x")); deny {
+		t.Fatal("wsConnect must allow after unload")
+	}
+	typ, data, _ := global.OnMessage(wsInfo("/x"), 1, []byte("plain"))
+	if typ != 1 || string(data) != "plain" {
+		t.Fatalf("frame hook still active after unload: %q", data)
+	}
+}
+
+// TestWSHookOversizedFramePassesThrough 验证超过帧上限的载荷不经过钩子。
+func TestWSHookOversizedFramePassesThrough(t *testing.T) {
+	withTempDataDir(t)
+	gin.SetMode(gin.TestMode)
+	Init(gin.New())
+
+	zipPath := writePluginZip(t, map[string]string{
+		"komari-plugin.json": wsManifest,
+		"script.js": `
+			const server = require("server");
+			function load() {
+				server.hook("wsMessage", (ctx, msg) => { return { data: "replaced" }; });
+			}
+		`,
+	})
+	if _, err := InstallZip(zipPath); err != nil {
+		t.Fatal(err)
+	}
+	if err := SetEnabled("ws", true, true); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = SetEnabled("ws", false, false) }()
+
+	big := make([]byte, maxWSFrameBytes+1)
+	for i := range big {
+		big[i] = 'x'
+	}
+	typ, data, _ := global.OnMessage(wsInfo("/x"), 1, big)
+	if typ != 1 || len(data) != len(big) {
+		t.Fatalf("oversized frame must pass through untouched, got %d bytes", len(data))
+	}
+}
@@ -16,6 +16,12 @@ func (a *App) Bootstrap() error {
 	if err := os.MkdirAll("./data/theme", os.ModePerm); err != nil {
 		return fmt.Errorf("failed to create theme directory: %w", err)
 	}
+	if err := os.MkdirAll("./data/plugin", os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create plugin directory: %w", err)
+	}
+	if err := os.MkdirAll("./data/plugin-data", os.ModePerm); err != nil {
+		return fmt.Errorf("failed to create plugin storage directory: %w", err)
+	}

 	dbcore.SetVersionID(utils.CurrentVersion + "-" + utils.VersionHash)
 	if err := dbcore.Initialize(); err != nil {
@@ -4,7 +4,7 @@ import (
 	"context"

 	"github.com/komari-monitor/komari/database/dbcore"
-	"github.com/komari-monitor/komari/database/metricstore"
+	"github.com/komari-monitor/komari/internal/metricstore"
 	"github.com/komari-monitor/komari/database/models"
 	"github.com/komari-monitor/komari/internal/migrations"
 	installweb "github.com/komari-monitor/komari/web/install"
@@ -5,7 +5,7 @@ import (
 	"time"

 	"github.com/komari-monitor/komari/database/auditlog"
-	"github.com/komari-monitor/komari/database/metricstore"
+	"github.com/komari-monitor/komari/internal/metricstore"
 	"github.com/komari-monitor/komari/internal/config"
 	logger "github.com/komari-monitor/komari/utils/log"
 )
@@ -14,11 +14,12 @@ import (
 	"github.com/komari-monitor/komari/database"
 	"github.com/komari-monitor/komari/database/accounts"
 	"github.com/komari-monitor/komari/database/auditlog"
-	"github.com/komari-monitor/komari/database/metricstore"
 	d_notification "github.com/komari-monitor/komari/database/notification"
 	"github.com/komari-monitor/komari/database/tasks"
 	"github.com/komari-monitor/komari/internal/config"
 	"github.com/komari-monitor/komari/internal/lifecycle"
+	"github.com/komari-monitor/komari/internal/metricstore"
+	"github.com/komari-monitor/komari/internal/plugin"
 	"github.com/komari-monitor/komari/internal/scheduler"
 	"github.com/komari-monitor/komari/utils/geoip"
 	logger "github.com/komari-monitor/komari/utils/log"
@@ -95,6 +96,15 @@ func (a *App) BuildRouter() error {
 		c.Redirect(http.StatusTemporaryRedirect, "/")
 	})
 	router.Register(r)
+
+	// Plugins are loaded after the router exists so server.route can bind
+	// routes; a failed plugin only disables itself and is logged.
+	plugin.Init(r)
+	if err := plugin.LoadAll(); err != nil {
+		logger.ErrorArgs("server", "Failed to load some plugins:", err)
+	}
+	a.addCleanup("plugins", func(context.Context) error { return plugin.CloseAll() })
+
 	a.registerReloadHandlers(cors)
 	a.reload.Start()
 	a.engine = r
@@ -103,7 +113,10 @@ func (a *App) BuildRouter() error {

 // Run starts the normal HTTP server and blocks until shutdown or fatal error.
 func (a *App) Run() error {
-	a.server = &http.Server{Addr: a.listenAddr, Handler: a.engine}
+	// The HTML injector runs outside the hook chain so it sees the final
+	// response: plugin hooks can still rewrite the body, then the registered
+	// head/body fragments are embedded into every text/html page.
+	a.server = &http.Server{Addr: a.listenAddr, Handler: plugin.HTMLInjectHandler(plugin.WrapHandler(a.engine))}
 	serverErr := make(chan error, 1)
 	logger.Infof("server", "Starting server on %s ...", a.listenAddr)
 	go func() {
@@ -184,13 +197,15 @@ func registerScheduledWork() {
 	if err := scheduler.AddContextFunc("metrics:compact", "@every 5m", true, compactMetricStore); err != nil {
 		logger.ErrorArgs("server", "Failed to add metric compact scheduled task:", err)
 	}
+	if err := scheduler.AddContextFunc("metrics:retention", "@every 1h", true, cleanupMetricStore); err != nil {
+		logger.ErrorArgs("server", "Failed to add metric retention scheduled task:", err)
+	}
 	if err := scheduler.AddFunc("notifier:traffic", "@every 1m", notifier.CheckTraffic); err != nil {
 		logger.ErrorArgs("server", "Failed to add traffic notification task:", err)
 	}
 	if err := scheduler.AddFunc("notifier:expire", "0 0 9 * * *", notifier.CheckExpireScheduledWork); err != nil {
 		logger.ErrorArgs("server", "Failed to add expire notification task:", err)
 	}
-	notifier.InitTrafficReportSchedule()
 }

 const taskResultRetentionDays = 30
@@ -219,3 +234,19 @@ func compactMetricStore(ctx context.Context) {
 		logger.Infof("server", "Metric store compacted %d rollup buckets", written)
 	}
 }
+
+func cleanupMetricStore(ctx context.Context) {
+	cleanupCtx, cancel := context.WithTimeout(ctx, 15*time.Minute)
+	defer cancel()
+	deleted, err := metricstore.CleanupExpired(cleanupCtx, time.Now().UTC())
+	if errors.Is(err, metricstore.ErrCompactInProgress) {
+		return
+	}
+	if err != nil {
+		logger.Errorf("server", "Failed to clean expired metric data after deleting %d rows: %v", deleted, err)
+		return
+	}
+	if deleted > 0 {
+		logger.Infof("server", "Metric retention cleanup deleted %d rows", deleted)
+	}
+}
@@ -0,0 +1,587 @@
+package child_process
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/dop251/goja"
+	"github.com/dop251/goja_nodejs/buffer"
+	"github.com/dop251/goja_nodejs/require"
+	"github.com/komari-monitor/komari/pkg/jsruntime/events"
+	"github.com/komari-monitor/komari/pkg/jsruntime/fs"
+	"github.com/komari-monitor/komari/pkg/jsruntime/internal/bridge"
+	"github.com/komari-monitor/komari/pkg/jsruntime/internal/writequeue"
+)
+
+type childCommandOptions struct {
+	cwd       string
+	env       []string
+	shell     bool
+	timeout   time.Duration
+	encoding  string
+	maxBuffer int
+}
+
+type childOutputLimitError struct {
+	stream string
+}
+
+func (e *childOutputLimitError) Error() string {
+	return fmt.Sprintf("%s maxBuffer length exceeded", e.stream)
+}
+
+type childOutputBuffer struct {
+	buffer bytes.Buffer
+	limit  int
+	stream string
+	cancel context.CancelFunc
+	err    error
+	once   sync.Once
+}
+
+func (b *childOutputBuffer) Write(data []byte) (int, error) {
+	if b.err != nil {
+		return len(data), nil
+	}
+	remaining := b.limit - b.Len()
+	if remaining >= len(data) {
+		_, _ = b.buffer.Write(data)
+		return len(data), nil
+	}
+	if remaining > 0 {
+		_, _ = b.buffer.Write(data[:remaining])
+	}
+	b.err = &childOutputLimitError{stream: b.stream}
+	b.once.Do(b.cancel)
+	return len(data), nil
+}
+
+func (b *childOutputBuffer) Len() int      { return b.buffer.Len() }
+func (b *childOutputBuffer) Bytes() []byte { return b.buffer.Bytes() }
+
+type Module struct {
+	runtime    *bridge.Runtime
+	filesystem *fs.Module
+	allowExec  bool
+	maxOutput  int
+}
+
+func New(runtime *bridge.Runtime, filesystem *fs.Module, allowExec bool, maxOutput int) *Module {
+	return &Module{runtime: runtime, filesystem: filesystem, allowExec: allowExec, maxOutput: maxOutput}
+}
+
+func (m *Module) Load(vm *goja.Runtime, module *goja.Object) {
+	if !m.allowExec {
+		panic(vm.NewGoError(fmt.Errorf("child_process requires AllowExec")))
+	}
+	exports := vm.NewObject()
+	_ = exports.Set("spawn", func(call goja.FunctionCall) goja.Value {
+		command, arguments, options := m.childCommandArguments(vm, call, false)
+		return m.spawnChild(vm, command, arguments, options)
+	})
+	_ = exports.Set("exec", func(call goja.FunctionCall) goja.Value {
+		command := call.Argument(0).String()
+		optionsValue, callbackValue := call.Argument(1), call.Argument(2)
+		if _, ok := goja.AssertFunction(optionsValue); ok {
+			callbackValue, optionsValue = optionsValue, goja.Undefined()
+		}
+		callback, ok := goja.AssertFunction(callbackValue)
+		if !ok {
+			panic(vm.NewTypeError("callback must be a function"))
+		}
+		options := m.childOptions(vm, optionsValue)
+		options.shell = true
+		return m.execChild(vm, command, nil, options, callback)
+	})
+	_ = exports.Set("execFile", func(call goja.FunctionCall) goja.Value {
+		command, arguments, options := m.childCommandArguments(vm, call, true)
+		callbackIndex := 1
+		if _, ok := call.Argument(1).Export().([]any); ok {
+			callbackIndex = 2
+		}
+		callbackValue := call.Argument(callbackIndex)
+		if _, ok := goja.AssertFunction(callbackValue); !ok {
+			callbackValue = call.Argument(callbackIndex + 1)
+		}
+		callback, ok := goja.AssertFunction(callbackValue)
+		if !ok {
+			panic(vm.NewTypeError("callback must be a function"))
+		}
+		return m.execChild(vm, command, arguments, options, callback)
+	})
+	_ = exports.Set("spawnSync", func(call goja.FunctionCall) goja.Value {
+		command, arguments, options := m.childCommandArguments(vm, call, false)
+		return m.spawnChildSync(vm, command, arguments, options)
+	})
+	_ = exports.Set("execFileSync", func(call goja.FunctionCall) goja.Value {
+		command, arguments, options := m.childCommandArguments(vm, call, false)
+		result := m.runChildSync(command, arguments, options)
+		if result.err != nil {
+			panic(childProcessError(vm, result.err, result.exitCode, result.stdout, result.stderr))
+		}
+		return encodeChildOutput(vm, result.stdout, options.encoding)
+	})
+	_ = exports.Set("execSync", func(call goja.FunctionCall) goja.Value {
+		options := m.childOptions(vm, call.Argument(1))
+		options.shell = true
+		result := m.runChildSync(call.Argument(0).String(), nil, options)
+		if result.err != nil {
+			panic(childProcessError(vm, result.err, result.exitCode, result.stdout, result.stderr))
+		}
+		return encodeChildOutput(vm, result.stdout, options.encoding)
+	})
+	_ = exports.Set("fork", func() {
+		panic(vm.NewGoError(fmt.Errorf("child_process.fork is unavailable because this runtime is not a Node executable")))
+	})
+	_ = module.Set("exports", exports)
+}
+
+func (m *Module) childCommandArguments(vm *goja.Runtime, call goja.FunctionCall, callbackExpected bool) (string, []string, childCommandOptions) {
+	command := call.Argument(0).String()
+	arguments := []string{}
+	optionsIndex := 1
+	if value := call.Argument(1); !goja.IsUndefined(value) && !goja.IsNull(value) {
+		var exported []string
+		if err := vm.ExportTo(value, &exported); err == nil {
+			arguments = exported
+			optionsIndex = 2
+		}
+	}
+	options := m.childOptions(vm, call.Argument(optionsIndex))
+	_ = callbackExpected
+	return command, arguments, options
+}
+
+func (m *Module) childOptions(vm *goja.Runtime, value goja.Value) childCommandOptions {
+	options := childCommandOptions{cwd: m.filesystem.Cwd(), env: os.Environ(), maxBuffer: m.maxOutput}
+	if value == nil || goja.IsUndefined(value) || goja.IsNull(value) {
+		return options
+	}
+	object := value.ToObject(vm)
+	if cwd := object.Get("cwd"); cwd != nil && !goja.IsUndefined(cwd) && !goja.IsNull(cwd) {
+		resolved, err := m.filesystem.Resolve(cwd.String(), false)
+		if err != nil {
+			panic(vm.NewGoError(err))
+		}
+		options.cwd = resolved
+	}
+	if environment := object.Get("env"); environment != nil && !goja.IsUndefined(environment) && !goja.IsNull(environment) {
+		var values map[string]string
+		if err := vm.ExportTo(environment, &values); err != nil {
+			panic(vm.NewTypeError("env must be an object"))
+		}
+		options.env = make([]string, 0, len(values))
+		for name, value := range values {
+			options.env = append(options.env, name+"="+value)
+		}
+	}
+	if shell := object.Get("shell"); shell != nil {
+		options.shell = shell.ToBoolean()
+	}
+	if timeoutValue := object.Get("timeout"); timeoutValue != nil && timeoutValue.ToInteger() > 0 {
+		timeout := timeoutValue.ToInteger()
+		options.timeout = time.Duration(timeout) * time.Millisecond
+	}
+	if encoding := object.Get("encoding"); encoding != nil && !goja.IsUndefined(encoding) && !goja.IsNull(encoding) {
+		options.encoding = encoding.String()
+	}
+	if maxBuffer := object.Get("maxBuffer"); maxBuffer != nil {
+		requested := maxBuffer.ToInteger()
+		if requested > 0 && requested < int64(options.maxBuffer) {
+			options.maxBuffer = int(requested)
+		}
+	}
+	return options
+}
+
+func childExecCommand(command string, arguments []string, options childCommandOptions) (*exec.Cmd, context.CancelFunc) {
+	ctx := context.Background()
+	cancel := func() {}
+	if options.timeout > 0 {
+		ctx, cancel = context.WithTimeout(ctx, options.timeout)
+	}
+	if options.shell {
+		line := command
+		if len(arguments) > 0 {
+			line += " " + strings.Join(arguments, " ")
+		}
+		if runtime.GOOS == "windows" {
+			return exec.CommandContext(ctx, "cmd.exe", "/d", "/s", "/c", line), cancel
+		}
+		return exec.CommandContext(ctx, "/bin/sh", "-c", line), cancel
+	}
+	return exec.CommandContext(ctx, command, arguments...), cancel
+}
+
+func (m *Module) childOutputLimit(options childCommandOptions) int {
+	if options.maxBuffer > 0 && options.maxBuffer < m.maxOutput {
+		return options.maxBuffer
+	}
+	return m.maxOutput
+}
+
+func (m *Module) spawnChild(vm *goja.Runtime, command string, arguments []string, options childCommandOptions) *goja.Object {
+	child := events.NewEmitter(vm)
+	cmd, cancel := childExecCommand(command, arguments, options)
+	cmd.Dir = options.cwd
+	cmd.Env = options.env
+	stdin, stdinErr := cmd.StdinPipe()
+	stdoutReader, stdoutErr := cmd.StdoutPipe()
+	stderrReader, stderrErr := cmd.StderrPipe()
+	if err := errors.Join(stdinErr, stdoutErr, stderrErr); err != nil {
+		panic(vm.NewGoError(err))
+	}
+	stdinStream, stdout, stderr := m.childStreams(vm, stdin)
+	_ = child.Set("stdout", stdout)
+	_ = child.Set("stderr", stderr)
+	_ = child.Set("stdin", stdinStream)
+	_ = child.Set("stdio", []any{stdinStream, stdout, stderr})
+	_ = child.Set("pid", goja.Undefined())
+	_ = child.Set("exitCode", goja.Null())
+	_ = child.Set("signalCode", goja.Null())
+	_ = child.Set("killed", false)
+	_ = child.Set("connected", false)
+
+	if err := cmd.Start(); err != nil {
+		cancel()
+		m.runtime.Loop().SetTimeout(func(vm *goja.Runtime) {
+			_ = m.runtime.RunJob(vm, "child_process.spawn", func() error {
+				return events.Emit(vm, child, "error", vm.NewGoError(err))
+			})
+		}, 0)
+		return child
+	}
+	_ = child.Set("pid", cmd.Process.Pid)
+	resourceID := m.runtime.AddResource(func() { _ = cmd.Process.Kill(); cancel() })
+	if resourceID == 0 {
+		_ = stdin.Close()
+		_ = stdoutReader.Close()
+		_ = stderrReader.Close()
+		go func() { _ = cmd.Wait() }()
+		return child
+	}
+	_ = child.Set("kill", func(signal string) bool {
+		if cmd.Process == nil {
+			return false
+		}
+		var err error
+		if signal == "SIGKILL" {
+			err = cmd.Process.Kill()
+		} else {
+			err = cmd.Process.Signal(os.Interrupt)
+		}
+		if err == nil {
+			_ = child.Set("killed", true)
+		}
+		return err == nil
+	})
+	_ = child.Set("ref", func() *goja.Object {
+		panic(vm.NewGoError(fmt.Errorf("child_process.ChildProcess.ref is not supported by jsruntime; the event loop is host-driven")))
+	})
+	_ = child.Set("unref", func() *goja.Object {
+		panic(vm.NewGoError(fmt.Errorf("child_process.ChildProcess.unref is not supported by jsruntime; the event loop is host-driven")))
+	})
+	_ = child.Set("disconnect", func() { _ = events.Emit(vm, child, "disconnect") })
+	_ = child.Set("send", func(call goja.FunctionCall) goja.Value {
+		if callback, ok := goja.AssertFunction(call.Argument(len(call.Arguments) - 1)); ok {
+			_, _ = callback(goja.Undefined(), vm.NewGoError(fmt.Errorf("IPC is not enabled")))
+		}
+		return vm.ToValue(false)
+	})
+
+	m.pipeChildOutput(vm, stdoutReader, stdout, options.encoding)
+	m.pipeChildOutput(vm, stderrReader, stderr, options.encoding)
+	go func() {
+		err := cmd.Wait()
+		cancel()
+		m.runtime.RemoveResource(resourceID)
+		exitCode := 0
+		if err != nil {
+			if exitError, ok := err.(*exec.ExitError); ok {
+				exitCode = exitError.ExitCode()
+			} else {
+				exitCode = -1
+			}
+		}
+		m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+			_ = m.runtime.RunJob(vm, "child_process", func() error {
+				_ = child.Set("exitCode", exitCode)
+				if emitErr := events.Emit(vm, child, "exit", exitCode, goja.Null()); emitErr != nil {
+					return emitErr
+				}
+				return events.Emit(vm, child, "close", exitCode, goja.Null())
+			})
+		})
+	}()
+	return child
+}
+
+//go:embed stdio.js
+var childStdioSource string
+
+// childStreams creates the Writable stdin and Readable stdout/stderr streams
+// for one spawned child process. The Go side owns the underlying pipes and
+// serializes writes through a per-child queue.
+func (m *Module) childStreams(vm *goja.Runtime, stdin io.WriteCloser) (*goja.Object, *goja.Object, *goja.Object) {
+	factoryValue, err := vm.RunString(childStdioSource)
+	if err != nil {
+		panic(vm.NewGoError(fmt.Errorf("load child_process stdio: %w", err)))
+	}
+	factory, _ := goja.AssertFunction(factoryValue)
+	hooks := vm.NewObject()
+	var writes writequeue.Queue
+	_ = hooks.Set("stdinWrite", func(chunk goja.Value, callback goja.Callable) {
+		data := append([]byte(nil), buffer.Bytes(vm, chunk)...)
+		writes.Submit(func() {
+			_, err := stdin.Write(data)
+			if callback == nil {
+				return
+			}
+			m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+				_ = m.runtime.RunJob(vm, "child_process.stdin.write", func() error {
+					if err != nil {
+						_, callbackErr := callback(goja.Undefined(), vm.NewGoError(err))
+						return callbackErr
+					}
+					_, callbackErr := callback(goja.Undefined())
+					return callbackErr
+				})
+			})
+		})
+	})
+	_ = hooks.Set("stdinEnd", func(callback goja.Callable) {
+		writes.Submit(func() {
+			err := stdin.Close()
+			m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+				_ = m.runtime.RunJob(vm, "child_process.stdin.end", func() error {
+					if callback != nil {
+						if err != nil {
+							_, callbackErr := callback(goja.Undefined(), vm.NewGoError(err))
+							return callbackErr
+						}
+						_, callbackErr := callback(goja.Undefined())
+						return callbackErr
+					}
+					return nil
+				})
+			})
+		})
+	})
+	_ = hooks.Set("stdinDestroy", func() {
+		go func() { _ = stdin.Close() }()
+	})
+	streams, err := factory(goja.Undefined(), require.Require(vm, "stream"), hooks)
+	if err != nil {
+		panic(err)
+	}
+	streamsObject := streams.ToObject(vm)
+	createStdin, _ := goja.AssertFunction(streamsObject.Get("createStdin"))
+	createOutput, _ := goja.AssertFunction(streamsObject.Get("createOutput"))
+	if createStdin == nil || createOutput == nil {
+		panic(vm.NewGoError(fmt.Errorf("child_process stdio factory is incomplete")))
+	}
+	stdinValue, err := createStdin(goja.Undefined())
+	if err != nil {
+		panic(err)
+	}
+	stdoutValue, err := createOutput(goja.Undefined())
+	if err != nil {
+		panic(err)
+	}
+	stderrValue, err := createOutput(goja.Undefined())
+	if err != nil {
+		panic(err)
+	}
+	return stdinValue.ToObject(vm), stdoutValue.ToObject(vm), stderrValue.ToObject(vm)
+}
+
+func childCallback(call goja.FunctionCall) goja.Callable {
+	for index := len(call.Arguments) - 1; index >= 0; index-- {
+		if callback, ok := goja.AssertFunction(call.Arguments[index]); ok {
+			return callback
+		}
+	}
+	return nil
+}
+
+func (m *Module) pipeChildOutput(vm *goja.Runtime, reader io.Reader, stream *goja.Object, encoding string) {
+	push, _ := goja.AssertFunction(stream.Get("push"))
+	setEncoding, _ := goja.AssertFunction(stream.Get("setEncoding"))
+	if encoding != "" && setEncoding != nil {
+		_, _ = setEncoding(stream, vm.ToValue(encoding))
+	}
+	go func() {
+		data := make([]byte, 32*1024)
+		for {
+			count, err := reader.Read(data)
+			if count > 0 {
+				chunk := append([]byte(nil), data[:count]...)
+				delivered := make(chan struct{})
+				if !m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+					defer close(delivered)
+					_ = m.runtime.RunJob(vm, "child_process stream", func() error {
+						_, pushErr := push(stream, buffer.WrapBytes(vm, chunk))
+						return pushErr
+					})
+				}) {
+					return
+				}
+				<-delivered
+			}
+			if err != nil {
+				m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+					_ = m.runtime.RunJob(vm, "child_process stream close", func() error {
+						_, pushErr := push(stream, goja.Null())
+						return pushErr
+					})
+				})
+				return
+			}
+		}
+	}()
+}
+
+func (m *Module) execChild(vm *goja.Runtime, command string, arguments []string, options childCommandOptions, callback goja.Callable) *goja.Object {
+	child := events.NewEmitter(vm)
+	_ = child.Set("pid", goja.Undefined())
+	_ = child.Set("killed", false)
+	cmd, cancel := childExecCommand(command, arguments, options)
+	cmd.Dir, cmd.Env = options.cwd, options.env
+	outputLimit := m.childOutputLimit(options)
+	stdout := &childOutputBuffer{limit: outputLimit, stream: "stdout", cancel: cancel}
+	stderr := &childOutputBuffer{limit: outputLimit, stream: "stderr", cancel: cancel}
+	cmd.Stdout, cmd.Stderr = stdout, stderr
+	if err := cmd.Start(); err != nil {
+		cancel()
+		m.runtime.Loop().SetTimeout(func(vm *goja.Runtime) {
+			_ = m.runtime.RunJob(vm, "child_process.exec", func() error {
+				if _, callbackErr := callback(goja.Undefined(), childProcessError(vm, err, -1, nil, nil), goja.Undefined(), goja.Undefined()); callbackErr != nil {
+					return callbackErr
+				}
+				return events.Emit(vm, child, "error", vm.NewGoError(err))
+			})
+		}, 0)
+		return child
+	}
+	_ = child.Set("pid", cmd.Process.Pid)
+	resourceID := m.runtime.AddResource(func() { _ = cmd.Process.Kill(); cancel() })
+	if resourceID == 0 {
+		go func() { _ = cmd.Wait() }()
+		return child
+	}
+	_ = child.Set("kill", func() bool {
+		err := cmd.Process.Kill()
+		if err == nil {
+			_ = child.Set("killed", true)
+		}
+		return err == nil
+	})
+	go func() {
+		err := cmd.Wait()
+		err = errors.Join(err, stdout.err, stderr.err)
+		cancel()
+		m.runtime.RemoveResource(resourceID)
+		exitCode := 0
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) {
+			exitCode = exitError.ExitCode()
+		} else if err != nil {
+			exitCode = -1
+		}
+		m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+			_ = m.runtime.RunJob(vm, "child_process.exec", func() error {
+				stdoutValue := encodeChildOutput(vm, stdout.Bytes(), options.encoding)
+				stderrValue := encodeChildOutput(vm, stderr.Bytes(), options.encoding)
+				var errorValue goja.Value = goja.Null()
+				if err != nil {
+					errorValue = childProcessError(vm, err, exitCode, stdout.Bytes(), stderr.Bytes())
+				}
+				if _, callbackErr := callback(goja.Undefined(), errorValue, stdoutValue, stderrValue); callbackErr != nil {
+					return callbackErr
+				}
+				_ = child.Set("exitCode", exitCode)
+				_ = events.Emit(vm, child, "exit", exitCode, goja.Null())
+				return events.Emit(vm, child, "close", exitCode, goja.Null())
+			})
+		})
+	}()
+	return child
+}
+
+type childSyncResult struct {
+	stdout   []byte
+	stderr   []byte
+	err      error
+	exitCode int
+	pid      int
+}
+
+func (m *Module) runChildSync(command string, arguments []string, options childCommandOptions) childSyncResult {
+	cmd, cancel := childExecCommand(command, arguments, options)
+	defer cancel()
+	cmd.Dir, cmd.Env = options.cwd, options.env
+	outputLimit := m.childOutputLimit(options)
+	stdout := &childOutputBuffer{limit: outputLimit, stream: "stdout", cancel: cancel}
+	stderr := &childOutputBuffer{limit: outputLimit, stream: "stderr", cancel: cancel}
+	cmd.Stdout, cmd.Stderr = stdout, stderr
+	err := cmd.Run()
+	err = errors.Join(err, stdout.err, stderr.err)
+	result := childSyncResult{stdout: stdout.Bytes(), stderr: stderr.Bytes(), err: err, exitCode: 0}
+	if cmd.Process != nil {
+		result.pid = cmd.Process.Pid
+	}
+	var exitError *exec.ExitError
+	if errors.As(err, &exitError) {
+		result.exitCode = exitError.ExitCode()
+	} else if err != nil {
+		result.exitCode = -1
+	}
+	return result
+}
+
+func (m *Module) spawnChildSync(vm *goja.Runtime, command string, arguments []string, options childCommandOptions) *goja.Object {
+	result := m.runChildSync(command, arguments, options)
+	object := vm.NewObject()
+	_ = object.Set("pid", result.pid)
+	_ = object.Set("status", result.exitCode)
+	_ = object.Set("signal", goja.Null())
+	_ = object.Set("stdout", encodeChildOutput(vm, result.stdout, options.encoding))
+	_ = object.Set("stderr", encodeChildOutput(vm, result.stderr, options.encoding))
+	_ = object.Set("output", []any{goja.Null(), encodeChildOutput(vm, result.stdout, options.encoding), encodeChildOutput(vm, result.stderr, options.encoding)})
+	if result.err != nil {
+		_ = object.Set("error", childProcessError(vm, result.err, result.exitCode, result.stdout, result.stderr))
+	}
+	return object
+}
+
+func encodeChildOutput(vm *goja.Runtime, data []byte, encoding string) goja.Value {
+	if encoding == "" || encoding == "buffer" {
+		return buffer.WrapBytes(vm, append([]byte(nil), data...))
+	}
+	return buffer.EncodeBytes(vm, data, vm.ToValue(encoding))
+}
+
+func childProcessError(vm *goja.Runtime, err error, exitCode int, stdout, stderr []byte) *goja.Object {
+	object := vm.NewGoError(err)
+	var limitError *childOutputLimitError
+	if errors.As(err, &limitError) {
+		_ = object.Set("code", "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+	} else {
+		_ = object.Set("code", exitCode)
+	}
+	_ = object.Set("killed", false)
+	_ = object.Set("signal", goja.Null())
+	_ = object.Set("stdout", encodeChildOutput(vm, stdout, ""))
+	_ = object.Set("stderr", encodeChildOutput(vm, stderr, ""))
+	return object
+}
@@ -0,0 +1,30 @@
+(function (stream, hooks) {
+	"use strict";
+
+	const { Writable, Readable } = stream;
+
+	function createStdin() {
+		return new Writable({
+			write(chunk, encoding, callback) {
+				hooks.stdinWrite(chunk, callback);
+			},
+			final(callback) {
+				hooks.stdinEnd(callback);
+			},
+			destroy(err, callback) {
+				hooks.stdinDestroy();
+				callback(err);
+			},
+		});
+	}
+
+	function createOutput() {
+		return new Readable({
+			read() {
+				// Output is pushed from the Go side as it arrives.
+			},
+		});
+	}
+
+	return { createStdin, createOutput };
+})
@@ -0,0 +1,235 @@
+package console
+
+// JavaScript compatibility: console.assert(), debug(), error(), exception(),
+// info(), log(), trace(), and warn(). Supports basic %s/%d/%i/%f/%o/%O/%c/%%
+// substitutions. assert(false, ...) and trace() include a stack trace.
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"strings"
+
+	"github.com/dop251/goja"
+	logger "github.com/komari-monitor/komari/utils/log"
+)
+
+type level uint8
+
+const (
+	debug level = iota
+	info
+	warn
+	errorLevel
+)
+
+type Module struct {
+	output io.Writer
+}
+
+func New(output io.Writer) *Module {
+	return &Module{output: output}
+}
+
+func (m *Module) Inject(vm *goja.Runtime) error {
+	console := vm.NewObject()
+	console.Set("assert", func(call goja.FunctionCall) goja.Value {
+		if len(call.Arguments) > 0 && call.Argument(0).ToBoolean() {
+			return goja.Undefined()
+		}
+		values := call.Arguments
+		if len(values) <= 1 {
+			values = []goja.Value{vm.ToValue("Assertion failed")}
+		} else {
+			values = append([]goja.Value{vm.ToValue("Assertion failed:")}, values[1:]...)
+		}
+		m.write(vm, errorLevel, values, true)
+		return goja.Undefined()
+	})
+	console.Set("debug", func(call goja.FunctionCall) goja.Value {
+		m.write(vm, debug, call.Arguments, false)
+		return goja.Undefined()
+	})
+	error := func(call goja.FunctionCall) goja.Value {
+		m.write(vm, errorLevel, call.Arguments, false)
+		return goja.Undefined()
+	}
+	console.Set("error", error)
+	console.Set("exception", error)
+	console.Set("info", func(call goja.FunctionCall) goja.Value {
+		m.write(vm, info, call.Arguments, false)
+		return goja.Undefined()
+	})
+	console.Set("log", func(call goja.FunctionCall) goja.Value {
+		m.write(vm, info, call.Arguments, false)
+		return goja.Undefined()
+	})
+	console.Set("trace", func(call goja.FunctionCall) goja.Value {
+		m.write(vm, debug, call.Arguments, true)
+		return goja.Undefined()
+	})
+	console.Set("warn", func(call goja.FunctionCall) goja.Value {
+		m.write(vm, warn, call.Arguments, false)
+		return goja.Undefined()
+	})
+	return vm.Set("console", console)
+}
+
+func (m *Module) WriteError(vm *goja.Runtime, values []goja.Value, withStack bool) {
+	m.write(vm, errorLevel, values, withStack)
+}
+
+func (m *Module) Report(vm *goja.Runtime, name string, err error) {
+	m.WriteError(vm, []goja.Value{vm.ToValue(fmt.Sprintf("%s callback failed: %v", name, err))}, false)
+}
+
+func (m *Module) write(vm *goja.Runtime, messageLevel level, values []goja.Value, withStack bool) {
+	message := formatConsoleValues(values)
+	if withStack {
+		if stack := stackTrace(vm); stack != "" {
+			if message != "" {
+				message += "\n"
+			}
+			message += stack
+		}
+	}
+	if m.output != nil {
+		_, _ = fmt.Fprintln(m.output, message)
+		return
+	}
+	switch messageLevel {
+	case debug:
+		logger.Debug("JavaScript", message)
+	case warn:
+		logger.Warn("JavaScript", message)
+	case errorLevel:
+		logger.Error("JavaScript", message)
+	default:
+		logger.Info("JavaScript", message)
+	}
+}
+
+func formatConsoleValues(values []goja.Value) string {
+	if len(values) == 0 {
+		return ""
+	}
+	args := make([]any, 0, len(values))
+	for _, value := range values {
+		args = append(args, value.Export())
+	}
+	if format, ok := args[0].(string); ok && strings.Contains(format, "%") {
+		return formatConsoleString(format, args[1:])
+	}
+	parts := make([]string, 0, len(args))
+	for _, arg := range args {
+		parts = append(parts, formatConsoleValue(arg))
+	}
+	return strings.Join(parts, " ")
+}
+
+func formatConsoleValue(value any) string {
+	switch value := value.(type) {
+	case nil:
+		return "null"
+	case string:
+		return value
+	case error:
+		return value.Error()
+	}
+
+	if data, err := json.Marshal(value); err == nil {
+		return string(data)
+	}
+	return fmt.Sprint(value)
+}
+
+func formatConsoleString(format string, args []any) string {
+	var builder strings.Builder
+	argIndex := 0
+	for i := 0; i < len(format); i++ {
+		if format[i] != '%' || i+1 >= len(format) {
+			builder.WriteByte(format[i])
+			continue
+		}
+		i++
+		if format[i] == '%' {
+			builder.WriteByte('%')
+			continue
+		}
+		if format[i] == 'c' {
+			if argIndex < len(args) {
+				argIndex++
+			}
+			continue
+		}
+		if argIndex >= len(args) {
+			builder.WriteByte('%')
+			builder.WriteByte(format[i])
+			continue
+		}
+		arg := args[argIndex]
+		argIndex++
+		switch format[i] {
+		case 's', 'o', 'O':
+			builder.WriteString(formatConsoleValue(arg))
+		case 'd', 'i':
+			builder.WriteString(fmt.Sprintf("%d", toConsoleInteger(arg)))
+		case 'f':
+			builder.WriteString(fmt.Sprintf("%f", toConsoleFloat(arg)))
+		default:
+			builder.WriteByte('%')
+			builder.WriteByte(format[i])
+			builder.WriteString(fmt.Sprint(arg))
+		}
+	}
+	if argIndex < len(args) {
+		remaining := make([]string, 0, len(args)-argIndex)
+		for _, arg := range args[argIndex:] {
+			remaining = append(remaining, formatConsoleValue(arg))
+		}
+		if builder.Len() > 0 {
+			builder.WriteByte(' ')
+		}
+		builder.WriteString(strings.Join(remaining, " "))
+	}
+	return builder.String()
+}
+
+func toConsoleInteger(value any) int64 {
+	switch value := value.(type) {
+	case int:
+		return int64(value)
+	case int64:
+		return value
+	case float64:
+		return int64(value)
+	default:
+		return 0
+	}
+}
+
+func toConsoleFloat(value any) float64 {
+	switch value := value.(type) {
+	case float32:
+		return float64(value)
+	case float64:
+		return value
+	case int:
+		return float64(value)
+	case int64:
+		return float64(value)
+	default:
+		return 0
+	}
+}
+
+func stackTrace(vm *goja.Runtime) string {
+	if vm == nil {
+		return ""
+	}
+	value, err := vm.RunString("new Error().stack")
+	if err != nil {
+		return ""
+	}
+	return value.String()
+}
@@ -0,0 +1,57 @@
+package jsruntime
+
+import (
+	"io"
+	"testing"
+	"time"
+)
+
+// TestCryptoNodeInterop decrypts ciphertext generated by real Node.js so the
+// Go-backed implementation stays wire-compatible with OpenSSL/Node.
+func TestCryptoNodeInterop(t *testing.T) {
+	runtime, err := New(`
+		function joinBuffers(parts) {
+			let total = 0;
+			for (const part of parts) total += part.length;
+			const out = Buffer.alloc(total);
+			let offset = 0;
+			for (const part of parts) {
+				for (let i = 0; i < part.length; i++) out[offset + i] = part[i];
+				offset += part.length;
+			}
+			return out;
+		}
+		function verify() {
+			const crypto = require("node:crypto");
+			const key = Buffer.alloc(32, 1);
+			const iv = Buffer.alloc(12, 2);
+			// Ciphertext and tag produced by Node.js aes-256-gcm.
+			const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+			decipher.setAAD(Buffer.from("aad"));
+			decipher.setAuthTag(Buffer.from("7e82cd250bea9365ccb4151131ef1cf4", "hex"));
+			const plain = joinBuffers([decipher.update(Buffer.from("6eb8bd2c3838b1dda7a9cfbc", "hex")), decipher.final()]);
+			if (plain.toString() !== "interop test") return "gcm decrypt";
+			// Re-encrypt with the same fixed key/IV: output must match Node's.
+			const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+			cipher.setAAD(Buffer.from("aad"));
+			const encrypted = joinBuffers([cipher.update("interop test"), cipher.final()]);
+			if (encrypted.toString("hex") !== "6eb8bd2c3838b1dda7a9cfbc") return "gcm encrypt";
+			if (cipher.getAuthTag().toString("hex") !== "7e82cd250bea9365ccb4151131ef1cf4") return "gcm tag";
+			// Node aes-256-cbc ciphertext.
+			const decbc = crypto.createDecipheriv("aes-256-cbc", Buffer.alloc(32, 3), Buffer.alloc(16, 4));
+			const cbcPlain = joinBuffers([decbc.update(Buffer.from("b00d5d15de8d38270478ea1ce3b97990", "hex")), decbc.final()]);
+			if (cbcPlain.toString() !== "interop cbc") return "cbc decrypt";
+			// Node pbkdf2-sha512 vector.
+			if (crypto.pbkdf2Sync("pw", "salt", 1000, 32, "sha512").toString("hex") !==
+				"dba2956d5d8f05e6f06dc9732ca6037d32a4fcbcdde4b35e62594b632d059275") return "pbkdf2 sha512";
+			return true;
+		}
+	`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 5 * time.Second})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer runtime.Close()
+	if err := runtime.Call("verify"); err != nil {
+		t.Fatalf("Node interop verification failed: %v", err)
+	}
+}
@@ -0,0 +1,404 @@
+package jsruntime
+
+import (
+	"crypto/ecdsa"
+	"crypto/ed25519"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/rsa"
+	"crypto/x509"
+	"encoding/pem"
+	"io"
+	"testing"
+	"time"
+)
+
+func newCryptoTestRuntime(t *testing.T, script string) *Runtime {
+	t.Helper()
+	baseDir := t.TempDir()
+	runtime, err := New(script, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: 15 * time.Second})
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(runtime.Close)
+	return runtime
+}
+
+func TestCryptoHashAndHMAC(t *testing.T) {
+	runtime := newCryptoTestRuntime(t, `
+		async function verify() {
+			const crypto = require("crypto");
+			if (require("crypto") !== require("node:crypto")) return "module identity";
+			const hash = crypto.createHash("sha256");
+			hash.update("m").update("sg");
+			const sha256 = hash.digest("hex");
+			const sha256HexInput = crypto.createHash("sha256").update("deadbeef", "hex").digest("hex");
+			const sha3 = crypto.createHash("sha3-256").update("msg").digest("hex");
+			const md5 = crypto.createHash("md5").update("msg").digest("hex");
+			const sha512224 = crypto.createHash("sha512-224").update("msg").digest("hex");
+			const ripemd = crypto.createHash("ripemd160").update("msg").digest("hex");
+			const blake = crypto.createHash("blake2b512").update("msg").digest("hex");
+			if (blake !== crypto.hash("blake2b512", "msg", "hex")) return "oneshot mismatch";
+			const hmac = crypto.createHmac("sha256", "key").update("msg").digest("hex");
+			const hmacB64u = crypto.createHmac("sha256", "key").update("msg").digest("base64url");
+			const copy = crypto.createHash("sha256");
+			copy.update("a");
+			const clone = copy.copy();
+			clone.update("b");
+			const hmacBufferKey = crypto.createHmac("sha256", Buffer.from("key")).update("msg").digest("hex");
+			const instance = crypto.createHash("sha256") instanceof crypto.Hash;
+			const hmacInstance = crypto.createHmac("sha256", "k") instanceof crypto.Hmac;
+			const oneshot = crypto.hash("sha256", "msg", "hex");
+			let finalizedError = null;
+			const used = crypto.createHash("sha256");
+			used.update("a");
+			used.digest();
+			try { used.update("b"); } catch (error) { finalizedError = error.code; }
+			let unknownDigest = null;
+			try { crypto.createHash("no-such-digest"); } catch (error) { unknownDigest = String(error.message); }
+			return sha256 === "e46b320165eec91e6344fa10340d5b3208304d6cad29d0d5aed18466d1d9d80e" &&
+				sha256HexInput === "5f78c33274e43fa9de5659265c1d917e25c03722dcb0b8d27db8d5feaa813953" &&
+				sha3 === "87da20e8da9c58e355cae2ee140b2109f2b5256860d153052070108de2452e72" &&
+				md5 === "6e2baaf3b97dbeef01c0043275f9a0e7" &&
+				sha512224 === "96144ffa45fc368f4f8431dabec44d62fbc987ba89b078e30dbe33c3" &&
+				ripemd === "1986f4891dc4e91212f452ba64af540b949303da" &&
+				hmac === "2d93cbc1be167bcb1637a4a23cbff01a7878f0c50ee833954ea5221bb1b8c628" &&
+				hmacB64u === "LZPLwb4We8sWN6SiPL_wGnh48MUO6DOVTqUiG7G4xig" &&
+				hmacBufferKey === hmac &&
+				copy.digest("hex") === "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb" &&
+				clone.digest("hex") === "fb8e20fc2e4c3f248c60c39bd652f3c1347298bb977b8b4d5903b85055620603" &&
+				instance && hmacInstance && oneshot === sha256 &&
+				finalizedError === "ERR_CRYPTO_HASH_FINALIZED" &&
+				unknownDigest === "Digest method not supported" &&
+				crypto.getHashes().includes("sha3-256") && crypto.getCiphers().includes("aes-256-gcm") &&
+				crypto.constants.RSA_PKCS1_PADDING === 1;
+		}
+	`)
+	if err := runtime.Call("verify"); err != nil {
+		t.Fatalf("crypto hash/hmac verification failed: %v", err)
+	}
+}
+
+func TestCryptoRandom(t *testing.T) {
+	runtime := newCryptoTestRuntime(t, `
+		async function verify() {
+			const crypto = require("node:crypto");
+			const bytes = crypto.randomBytes(16);
+			if (!Buffer.isBuffer && bytes.length !== 16) return "randomBytes length";
+			const asyncBytes = await new Promise((resolve, reject) =>
+				crypto.randomBytes(8, (error, value) => error ? reject(error) : resolve(value)));
+			if (asyncBytes.length !== 8) return "randomBytes callback";
+			const uuid = crypto.randomUUID();
+			if (!/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(uuid)) return "uuid format";
+			if (crypto.randomUUID() === uuid) return "uuid uniqueness";
+			const view = new Uint32Array(4);
+			if (crypto.getRandomValues(view) !== view || view.length !== 4) return "getRandomValues";
+			let floatRejected = false;
+			try { crypto.getRandomValues(new Float32Array(2)); } catch (error) { floatRejected = error instanceof TypeError; }
+			if (!floatRejected) return "getRandomValues float";
+			const u16 = new Uint16Array(4);
+			crypto.randomFillSync(u16, 1, 2);
+			if (u16[0] !== 0 || u16[3] !== 0) return "randomFillSync u16 offsets";
+			const dv = new DataView(new ArrayBuffer(6));
+			crypto.randomFillSync(dv, 2, 3);
+			const dvBytes = new Uint8Array(dv.buffer);
+			if (dvBytes[0] !== 0 || dvBytes[1] !== 0 || dvBytes[5] !== 0) return "randomFillSync dataview";
+			const filled = await new Promise((resolve, reject) => {
+				const target = new Uint8Array(4);
+				crypto.randomFill(target, 1, 2, (error, value) => error ? reject(error) : resolve(value === target ? target : null));
+			});
+			if (filled === null || filled[0] !== 0 || filled[3] !== 0) return "randomFill callback";
+			let fillRangeError = null;
+			try { crypto.randomFillSync(new Uint8Array(4), 2, 5); } catch (error) { fillRangeError = error.code; }
+			if (fillRangeError !== "ERR_OUT_OF_RANGE") return "randomFillSync range";
+			const ri = crypto.randomInt(10);
+			const ri2 = crypto.randomInt(5, 10);
+			if (ri < 0 || ri >= 10 || ri2 < 5 || ri2 >= 10) return "randomInt range";
+			const riAsync = await new Promise((resolve, reject) =>
+				crypto.randomInt(1, 100, (error, value) => error ? reject(error) : resolve(value)));
+			if (riAsync < 1 || riAsync >= 100) return "randomInt callback";
+			if (!crypto.timingSafeEqual(Buffer.from("ab"), Buffer.from("ab"))) return "timingSafeEqual equal";
+			if (crypto.timingSafeEqual(Buffer.from("ab"), Buffer.from("ac"))) return "timingSafeEqual unequal";
+			let timingError = null;
+			try { crypto.timingSafeEqual(Buffer.from("ab"), Buffer.from("abc")); } catch (error) { timingError = error.code; }
+			return timingError === "ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH";
+		}
+	`)
+	if err := runtime.Call("verify"); err != nil {
+		t.Fatalf("crypto random verification failed: %v", err)
+	}
+}
+
+func TestCryptoKeyDerivation(t *testing.T) {
+	runtime := newCryptoTestRuntime(t, `
+		async function verify() {
+			const crypto = require("node:crypto");
+			const pbkdf2 = crypto.pbkdf2Sync("pw", "salt", 1000, 16, "sha256").toString("hex");
+			const pbkdf2HexSalt = crypto.pbkdf2Sync("pw", Buffer.from("73616c74", "hex"), 1000, 16, "sha256").toString("hex");
+			const scrypt = crypto.scryptSync("pw", "salt", 16).toString("hex");
+			const scryptCost = crypto.scryptSync("pw", "salt", 16, { N: 1024, r: 8, p: 1 }).toString("hex");
+			const asyncPbkdf2 = await new Promise((resolve, reject) =>
+				crypto.pbkdf2("pw", "salt", 1000, 16, "sha256", (error, key) => error ? reject(error) : resolve(key.toString("hex"))));
+			const asyncScrypt = await new Promise((resolve, reject) =>
+				crypto.scrypt("pw", "salt", 16, (error, key) => error ? reject(error) : resolve(key.toString("hex"))));
+			let iterError = null;
+			try { crypto.pbkdf2Sync("p", "s", 0, 16, "sha256"); } catch (error) { iterError = error.code; }
+			let scryptParamError = null;
+			try { crypto.scryptSync("p", "s", 16, { N: 1000 }); } catch (error) { scryptParamError = error.code; }
+			let scryptMemError = null;
+			try { crypto.scryptSync("p", "s", 16, { N: 16384, r: 8, maxmem: 1024 }); } catch (error) { scryptMemError = error.code; }
+			return pbkdf2 === "0a38253555ce37f5c72a6b703f996814" &&
+				pbkdf2HexSalt === pbkdf2 &&
+				scrypt === "c0b515908e61334cae6d6003c00be60e" &&
+				scryptCost === "9f1f8695838e682c1689750f45a69fb9" &&
+				asyncPbkdf2 === pbkdf2 && asyncScrypt === scrypt &&
+				iterError === "ERR_OUT_OF_RANGE" &&
+				scryptParamError === "ERR_CRYPTO_INVALID_SCRYPT_PARAMS" &&
+				scryptMemError === "ERR_CRYPTO_INVALID_SCRYPT_PARAMS";
+		}
+	`)
+	if err := runtime.Call("verify"); err != nil {
+		t.Fatalf("crypto key derivation verification failed: %v", err)
+	}
+}
+
+func TestCryptoCiphers(t *testing.T) {
+	runtime := newCryptoTestRuntime(t, `
+		function joinBuffers(parts) {
+			let total = 0;
+			for (const part of parts) total += part.length;
+			const out = Buffer.alloc(total);
+			let offset = 0;
+			for (const part of parts) {
+				for (let i = 0; i < part.length; i++) out[offset + i] = part[i];
+				offset += part.length;
+			}
+			return out;
+		}
+		async function verify() {
+			const crypto = require("node:crypto");
+			const key = Buffer.alloc(32, 1);
+			const iv = Buffer.alloc(16, 2);
+			// AES-256-CBC with padding, multi-block input.
+			const cbc = crypto.createCipheriv("aes-256-cbc", key, iv);
+			const cbcParts = [cbc.update("komari is a monitoring platform with a lot of data")];
+			cbcParts.push(cbc.final());
+			const cbcEncrypted = joinBuffers(cbcParts);
+			const decbc = crypto.createDecipheriv("aes-256-cbc", key, iv);
+			const decbcParts = [decbc.update(cbcEncrypted)];
+			decbcParts.push(decbc.final());
+			if (joinBuffers(decbcParts).toString() !== "komari is a monitoring platform with a lot of data") return "cbc";
+			// CBC with no padding.
+			const cbcRaw = Buffer.alloc(32, 7);
+			const cbcNopad = crypto.createCipheriv("aes-256-cbc", key, iv);
+			cbcNopad.setAutoPadding(false);
+			const cbcNopadParts = [cbcNopad.update(cbcRaw), cbcNopad.final()];
+			const cbcNopadEncrypted = joinBuffers(cbcNopadParts);
+			const decbcNopad = crypto.createDecipheriv("aes-256-cbc", key, iv);
+			decbcNopad.setAutoPadding(false);
+			const decbcNopadParts = [decbcNopad.update(cbcNopadEncrypted), decbcNopad.final()];
+			if (!joinBuffers(decbcNopadParts).equals(cbcRaw)) return "cbc nopad";
+			// CBC with string output encoding.
+			const cbcHex = crypto.createCipheriv("aes-256-cbc", key, iv);
+			const cbcHexText = cbcHex.update("hex out", "utf8", "hex") + cbcHex.final("hex");
+			const decbcHex = crypto.createDecipheriv("aes-256-cbc", key, iv);
+			const decbcHexText = decbcHex.update(cbcHexText, "hex", "utf8") + decbcHex.final("utf8");
+			if (decbcHexText !== "hex out") return "cbc hex";
+			// AES-256-CTR.
+			const ctr = crypto.createCipheriv("aes-256-ctr", key, iv);
+			const ctrParts = [ctr.update("stream cipher data")];
+			ctrParts.push(ctr.final());
+			const ctrEncrypted = joinBuffers(ctrParts);
+			const dctr = crypto.createDecipheriv("aes-256-ctr", key, iv);
+			const dctrParts = [dctr.update(ctrEncrypted)];
+			dctrParts.push(dctr.final());
+			if (joinBuffers(dctrParts).toString() !== "stream cipher data") return "ctr";
+			// AES-256-ECB.
+			const ecb = crypto.createCipheriv("aes-256-ecb", key, null);
+			const ecbParts = [ecb.update("ecb block cipher")];
+			ecbParts.push(ecb.final());
+			const ecbEncrypted = joinBuffers(ecbParts);
+			const decb = crypto.createDecipheriv("aes-256-ecb", key, null);
+			const decbParts = [decb.update(ecbEncrypted)];
+			decbParts.push(decb.final());
+			if (joinBuffers(decbParts).toString() !== "ecb block cipher") return "ecb";
+			// AES-256-GCM with AAD and a 12-byte IV.
+			const gcmKey = Buffer.alloc(32, 3);
+			const gcmIV = Buffer.alloc(12, 4);
+			const gcm = crypto.createCipheriv("aes-256-gcm", gcmKey, gcmIV);
+			gcm.setAAD(Buffer.from("aad data"));
+			const gcmParts = [gcm.update("authenticated secret")];
+			gcmParts.push(gcm.final());
+			const gcmEncrypted = joinBuffers(gcmParts);
+			const gcmTag = gcm.getAuthTag();
+			if (gcmTag.length !== 16) return "gcm tag length";
+			const dgcm = crypto.createDecipheriv("aes-256-gcm", gcmKey, gcmIV);
+			dgcm.setAAD(Buffer.from("aad data"));
+			dgcm.setAuthTag(gcmTag);
+			const dgcmParts = [dgcm.update(gcmEncrypted)];
+			dgcmParts.push(dgcm.final());
+			if (joinBuffers(dgcmParts).toString() !== "authenticated secret") return "gcm";
+			// GCM tampered tag must fail at final().
+			const badTag = Buffer.from(gcmTag);
+			badTag[0] ^= 0xff;
+			const dgcmBad = crypto.createDecipheriv("aes-256-gcm", gcmKey, gcmIV);
+			dgcmBad.setAAD(Buffer.from("aad data"));
+			dgcmBad.setAuthTag(badTag);
+			dgcmBad.update(gcmEncrypted);
+			let tamperFailed = false;
+			try { dgcmBad.final(); } catch (error) { tamperFailed = String(error.message).includes("Unsupported state or unable to authenticate data"); }
+			if (!tamperFailed) return "gcm tamper";
+			// GCM without setAuthTag must fail at final().
+			const dgcmNoTag = crypto.createDecipheriv("aes-256-gcm", gcmKey, gcmIV);
+			dgcmNoTag.update(gcmEncrypted);
+			let noTagFailed = false;
+			try { dgcmNoTag.final(); } catch (error) { noTagFailed = true; }
+			if (!noTagFailed) return "gcm missing tag";
+			// GCM getAuthTag before final throws.
+			const gcmEarly = crypto.createCipheriv("aes-256-gcm", gcmKey, gcmIV);
+			let earlyTagError = null;
+			try { gcmEarly.getAuthTag(); } catch (error) { earlyTagError = error.code; }
+			if (earlyTagError !== "ERR_CRYPTO_INVALID_STATE") return "gcm early tag";
+			// GCM with an 8-byte IV (non-standard nonce length).
+			const gcmIV8 = Buffer.alloc(8, 5);
+			const gcm8 = crypto.createCipheriv("aes-256-gcm", gcmKey, gcmIV8);
+			const gcm8Parts = [gcm8.update("short iv")];
+			gcm8Parts.push(gcm8.final());
+			const gcm8Encrypted = joinBuffers(gcm8Parts);
+			const dgcm8 = crypto.createDecipheriv("aes-256-gcm", gcmKey, gcmIV8);
+			dgcm8.setAuthTag(gcm8.getAuthTag());
+			const dgcm8Parts = [dgcm8.update(gcm8Encrypted)];
+			dgcm8Parts.push(dgcm8.final());
+			if (joinBuffers(dgcm8Parts).toString() !== "short iv") return "gcm iv8";
+			// GCM with authTagLength 12.
+			const gcm12 = crypto.createCipheriv("aes-256-gcm", gcmKey, gcmIV, { authTagLength: 12 });
+			gcm12.update("tag12");
+			gcm12.final();
+			if (gcm12.getAuthTag().length !== 12) return "gcm tag12";
+			// ChaCha20-Poly1305.
+			const chachaKey = Buffer.alloc(32, 6);
+			const chachaIV = Buffer.alloc(12, 7);
+			const chacha = crypto.createCipheriv("chacha20-poly1305", chachaKey, chachaIV);
+			const chachaParts = [chacha.update("chacha message")];
+			chachaParts.push(chacha.final());
+			const chachaEncrypted = joinBuffers(chachaParts);
+			const dchacha = crypto.createDecipheriv("chacha20-poly1305", chachaKey, chachaIV);
+			dchacha.setAuthTag(chacha.getAuthTag());
+			const dchachaParts = [dchacha.update(chachaEncrypted)];
+			dchachaParts.push(dchacha.final());
+			if (joinBuffers(dchachaParts).toString() !== "chacha message") return "chacha";
+			// Construction errors.
+			let unknownCipher = null;
+			try { crypto.createCipheriv("no-such-cipher", key, iv); } catch (error) { unknownCipher = error.code; }
+			let badKeyLen = null;
+			try { crypto.createCipheriv("aes-256-cbc", Buffer.alloc(15), iv); } catch (error) { badKeyLen = error.code; }
+			let badIV = null;
+			try { crypto.createCipheriv("aes-256-cbc", key, Buffer.alloc(8)); } catch (error) { badIV = error.code; }
+			let ecbIV = null;
+			try { crypto.createCipheriv("aes-256-ecb", key, iv); } catch (error) { ecbIV = error.code; }
+			let badTagLength = null;
+			try { crypto.createCipheriv("aes-256-gcm", gcmKey, gcmIV, { authTagLength: 8 }); } catch (error) { badTagLength = error.code; }
+			return unknownCipher === "ERR_CRYPTO_UNKNOWN_CIPHER" && badKeyLen === "ERR_CRYPTO_INVALID_KEYLEN" &&
+				badIV === "ERR_CRYPTO_INVALID_IV" && ecbIV === "ERR_CRYPTO_INVALID_IV" &&
+				badTagLength === "ERR_CRYPTO_INVALID_AUTH_TAG";
+		}
+	`)
+	if err := runtime.Call("verify"); err != nil {
+		t.Fatalf("crypto cipher verification failed: %v", err)
+	}
+}
+
+func pemTestKeys(t *testing.T) (rsaPriv, rsaPub, ecPriv, ecPub, edPriv, edPub string) {
+	t.Helper()
+	rsaKey, err := rsa.GenerateKey(rand.Reader, 2048)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rsaKeyDER, err := x509.MarshalPKCS8PrivateKey(rsaKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rsaPubDER, err := x509.MarshalPKIXPublicKey(&rsaKey.PublicKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	rsaPriv = string(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: rsaKeyDER}))
+	rsaPub = string(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: rsaPubDER}))
+
+	ecKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ecKeyDER, err := x509.MarshalPKCS8PrivateKey(ecKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ecPubDER, err := x509.MarshalPKIXPublicKey(&ecKey.PublicKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ecPriv = string(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: ecKeyDER}))
+	ecPub = string(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: ecPubDER}))
+
+	edPubKey, edPrivKey, err := ed25519.GenerateKey(rand.Reader)
+	if err != nil {
+		t.Fatal(err)
+	}
+	edKeyDER, err := x509.MarshalPKCS8PrivateKey(edPrivKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	edPubDER, err := x509.MarshalPKIXPublicKey(edPubKey)
+	if err != nil {
+		t.Fatal(err)
+	}
+	edPriv = string(pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: edKeyDER}))
+	edPub = string(pem.EncodeToMemory(&pem.Block{Type: "PUBLIC KEY", Bytes: edPubDER}))
+	return rsaPriv, rsaPub, ecPriv, ecPub, edPriv, edPub
+}
+
+func TestCryptoSignVerify(t *testing.T) {
+	rsaPriv, rsaPub, ecPriv, ecPub, edPriv, edPub := pemTestKeys(t)
+	script := `
+		async function verify(rsaPriv, rsaPub, ecPriv, ecPub, edPriv, edPub) {
+			const crypto = require("node:crypto");
+			const rsaSign = crypto.createSign("RSA-SHA256");
+			rsaSign.update("hello");
+			const rsaSignature = rsaSign.sign(rsaPriv);
+			if (rsaSignature.length !== 256) return "rsa sig length";
+			const rsaOK = crypto.createVerify("RSA-SHA256").update("hello").verify(rsaPub, rsaSignature);
+			const rsaTampered = crypto.createVerify("RSA-SHA256").update("hello").verify(rsaPub, Buffer.from(rsaSignature));
+			rsaSignature[0] ^= 0xff;
+			const rsaTamperedOK = crypto.createVerify("RSA-SHA256").update("hello").verify(rsaPub, rsaSignature);
+			if (!rsaOK || !rsaTampered || rsaTamperedOK) return "rsa verify";
+			const oneShotSig = crypto.sign("sha256", Buffer.from("hello"), rsaPriv);
+			if (!crypto.verify("sha256", Buffer.from("hello"), rsaPub, oneShotSig)) return "rsa oneshot";
+			const asyncSig = await new Promise((resolve, reject) =>
+				crypto.sign("sha256", Buffer.from("hello"), rsaPriv, (error, value) => error ? reject(error) : resolve(value)));
+			if (!crypto.verify("sha256", Buffer.from("hello"), rsaPub, asyncSig)) return "rsa async";
+			const ecSig = crypto.sign("sha256", Buffer.from("hello"), ecPriv);
+			if (!crypto.verify("sha256", Buffer.from("hello"), ecPub, ecSig)) return "ec verify";
+			if (crypto.verify("sha256", Buffer.from("hello"), ecPub, Buffer.alloc(70))) return "ec garbage";
+			const edSig = crypto.sign(null, Buffer.from("hello"), edPriv);
+			if (!crypto.verify(null, Buffer.from("hello"), edPub, edSig)) return "ed25519 verify";
+			const edSig2 = crypto.sign("ed25519", Buffer.from("hello"), edPriv);
+			if (!crypto.verify("ed25519", Buffer.from("hello"), edPub, edSig2)) return "ed25519 named";
+			let wrongKeyError = null;
+			try { crypto.sign("sha256", Buffer.from("x"), edPriv); } catch (error) { wrongKeyError = error.code; }
+			let nullAlgorithmError = null;
+			try { crypto.createSign(null); } catch (error) { nullAlgorithmError = error.name; }
+			let badAlgorithmError = null;
+			try { crypto.createSign("no-such-algo"); } catch (error) { badAlgorithmError = error.code; }
+			let badKeyError = null;
+			try { crypto.sign("sha256", Buffer.from("x"), "not a pem"); } catch (error) { badKeyError = error.code; }
+			return wrongKeyError === "ERR_OSSL_INVALID_DIGEST" &&
+				nullAlgorithmError === "TypeError" &&
+				badAlgorithmError === "ERR_CRYPTO_INVALID_DIGEST" &&
+				badKeyError === "ERR_OSSL_PEM_NO_START_LINE";
+		}
+	`
+	runtime := newCryptoTestRuntime(t, script)
+	if err := runtime.Call("verify", rsaPriv, rsaPub, ecPriv, ecPub, edPriv, edPub); err != nil {
+		t.Fatalf("crypto sign/verify failed: %v", err)
+	}
+}
@@ -0,0 +1,49 @@
+package events
+
+import (
+	_ "embed"
+	"fmt"
+
+	"github.com/dop251/goja"
+	"github.com/dop251/goja_nodejs/require"
+)
+
+func Load(vm *goja.Runtime, module *goja.Object) {
+	constructor, err := vm.RunString(eventEmitterSource)
+	if err != nil {
+		panic(vm.NewGoError(fmt.Errorf("load events module: %w", err)))
+	}
+	_ = constructor.ToObject(vm).Set("EventEmitter", constructor)
+	_ = constructor.ToObject(vm).Set("defaultMaxListeners", 10)
+	_ = module.Set("exports", constructor)
+}
+
+func NewEmitter(vm *goja.Runtime) *goja.Object {
+	constructor := require.Require(vm, "events")
+	object, err := vm.New(constructor)
+	if err != nil {
+		panic(err)
+	}
+	return object
+}
+
+func Emit(vm *goja.Runtime, emitter *goja.Object, name string, values ...any) error {
+	emit, ok := goja.AssertFunction(emitter.Get("emit"))
+	if !ok {
+		return fmt.Errorf("EventEmitter.emit is not callable")
+	}
+	arguments := make([]goja.Value, 1, len(values)+1)
+	arguments[0] = vm.ToValue(name)
+	for _, value := range values {
+		if jsValue, ok := value.(goja.Value); ok {
+			arguments = append(arguments, jsValue)
+		} else {
+			arguments = append(arguments, vm.ToValue(value))
+		}
+	}
+	_, err := emit(emitter, arguments...)
+	return err
+}
+
+//go:embed events.js
+var eventEmitterSource string
@@ -0,0 +1,56 @@
+(function () {
+	"use strict";
+	class EventEmitter {
+		constructor() { Object.defineProperty(this, "_events", { value: new Map(), writable: true }); this._maxListeners = 10; }
+		addListener(name, listener) { return this.on(name, listener); }
+		on(name, listener) {
+			if (typeof listener !== "function") throw new TypeError("listener must be a function");
+			const list = this._events.get(name) || [];
+			list.push(listener); this._events.set(name, list); return this;
+		}
+		once(name, listener) {
+			const wrapper = (...args) => { this.removeListener(name, wrapper); return listener.apply(this, args); };
+			wrapper.listener = listener; return this.on(name, wrapper);
+		}
+		prependListener(name, listener) {
+			if (typeof listener !== "function") throw new TypeError("listener must be a function");
+			const list = this._events.get(name) || []; list.unshift(listener); this._events.set(name, list); return this;
+		}
+		prependOnceListener(name, listener) {
+			const wrapper = (...args) => { this.removeListener(name, wrapper); return listener.apply(this, args); };
+			wrapper.listener = listener;
+			const list = this._events.get(name) || []; list.unshift(wrapper); this._events.set(name, list); return this;
+		}
+		emit(name, ...args) {
+			const list = (this._events.get(name) || []).slice();
+			if (name === "error" && list.length === 0) throw (args[0] instanceof Error ? args[0] : new Error(String(args[0])));
+			for (const listener of list) listener.apply(this, args);
+			return list.length > 0;
+		}
+		removeListener(name, listener) {
+			const list = this._events.get(name); if (!list) return this;
+			for (let i = list.length - 1; i >= 0; i--) {
+				if (list[i] === listener || list[i].listener === listener) { list.splice(i, 1); break; }
+			}
+			if (list.length === 0) this._events.delete(name); return this;
+		}
+		off(name, listener) { return this.removeListener(name, listener); }
+		removeAllListeners(name) { if (arguments.length === 0) this._events.clear(); else this._events.delete(name); return this; }
+		listeners(name) { return (this._events.get(name) || []).map((listener) => listener.listener || listener); }
+		rawListeners(name) { return (this._events.get(name) || []).slice(); }
+		listenerCount(name, listener) { const list = this.listeners(name); return listener === undefined ? list.length : list.filter((item) => item === listener).length; }
+		eventNames() { return Array.from(this._events.keys()); }
+		getMaxListeners() { return this._maxListeners; }
+		setMaxListeners(value) { value = Number(value); if (!Number.isFinite(value) || value < 0) throw new RangeError("Invalid max listeners"); this._maxListeners = value; return this; }
+		static listenerCount(emitter, name) { return emitter.listenerCount(name); }
+		static getEventListeners(emitter, name) { return emitter.listeners(name); }
+		static once(emitter, name) { return new Promise((resolve, reject) => { emitter.once(name, (...args) => resolve(args)); if (name !== "error") emitter.once("error", reject); }); }
+		static on(emitter, name) {
+			const queue = [], waiters = []; let done = false;
+			const listener = (...args) => { const waiter = waiters.shift(); if (waiter) waiter({ value: args, done: false }); else queue.push(args); };
+			emitter.on(name, listener);
+			return { next() { if (queue.length) return Promise.resolve({ value: queue.shift(), done: false }); if (done) return Promise.resolve({ done: true }); return new Promise((resolve) => waiters.push(resolve)); }, return() { done = true; emitter.off(name, listener); for (const resolve of waiters.splice(0)) resolve({ done: true }); return Promise.resolve({ done: true }); }, [Symbol.asyncIterator]() { return this; } };
+		}
+	}
+	return EventEmitter;
+})()
@@ -0,0 +1,8 @@
+package fetch
+
+import (
+	_ "embed"
+)
+
+//go:embed api.js
+var fetchAPISource string
@@ -0,0 +1,506 @@
+(function () {
+	"use strict";
+	const nativeBodyBuffer = globalThis.__komariBodyBuffer;
+	const nativeBodyText = globalThis.__komariBodyText;
+	const nativeEncodeFormData = globalThis.__komariEncodeFormData;
+	const nativeParseFormData = globalThis.__komariParseFormData;
+	const nativeNewAbortSignal = globalThis.__komariNewAbortSignal;
+	const nativeAbortSignal = globalThis.__komariAbortSignal;
+	const nativeFetch = globalThis.__komariFetch;
+	const nativeFetchSync = globalThis.__komariFetchSync;
+	const slots = new WeakMap();
+	const slot = (value) => slots.get(value);
+
+	function copyBuffer(buffer) {
+		const source = new Uint8Array(buffer);
+		const copy = new Uint8Array(source.length);
+		copy.set(source);
+		return copy.buffer;
+	}
+
+	function toBuffer(value) {
+		if (value == null) return new ArrayBuffer(0);
+		if (value instanceof Blob) return copyBuffer(slot(value).buffer);
+		if (value instanceof ArrayBuffer) return copyBuffer(value);
+		if (ArrayBuffer.isView(value)) {
+			const source = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+			const copy = new Uint8Array(source.length);
+			copy.set(source);
+			return copy.buffer;
+		}
+		return nativeBodyBuffer(String(value));
+	}
+
+	function normalizeHeaderName(name) {
+		name = String(name).toLowerCase();
+		if (!name || !/^[!#$%&'*+.^_`|~0-9a-z-]+$/.test(name)) {
+			throw new TypeError("Invalid HTTP header name");
+		}
+		return name;
+	}
+
+	function normalizeHeaderValue(value) {
+		value = String(value).replace(/^[\t\x20]+|[\t\x20]+$/g, "");
+		if (/[\0\r\n]/.test(value)) throw new TypeError("Invalid HTTP header value");
+		return value;
+	}
+	function sortedHeaderEntries(headers) {
+		return Array.from(slot(headers).values.keys()).sort().map((name) => [name, headers.get(name)]);
+	}
+
+	class Headers {
+		constructor(init) {
+			slots.set(this, { values: new Map() });
+			if (init == null) return;
+			if (init instanceof Headers) {
+				for (const [name, values] of slot(init).values) slot(this).values.set(name, values.slice());
+				return;
+			}
+			if (typeof init[Symbol.iterator] === "function") {
+				for (const pair of init) {
+					if (pair == null || typeof pair[Symbol.iterator] !== "function") {
+						throw new TypeError("Each header pair must be iterable");
+					}
+					const values = Array.from(pair);
+					if (values.length !== 2) throw new TypeError("Each header pair must contain two values");
+					this.append(values[0], values[1]);
+				}
+				return;
+			}
+			for (const name of Object.keys(Object(init))) this.append(name, init[name]);
+		}
+
+		append(name, value) {
+			name = normalizeHeaderName(name);
+			value = normalizeHeaderValue(value);
+			const values = slot(this).values.get(name);
+			if (values) values.push(value); else slot(this).values.set(name, [value]);
+		}
+
+		delete(name) { slot(this).values.delete(normalizeHeaderName(name)); }
+
+		get(name) {
+			const values = slot(this).values.get(normalizeHeaderName(name));
+			return values ? values.join(", ") : null;
+		}
+
+		getSetCookie() {
+			const values = slot(this).values.get("set-cookie");
+			return values ? values.slice() : [];
+		}
+
+		has(name) { return slot(this).values.has(normalizeHeaderName(name)); }
+
+		set(name, value) {
+			slot(this).values.set(normalizeHeaderName(name), [normalizeHeaderValue(value)]);
+		}
+
+		entries() { return sortedHeaderEntries(this)[Symbol.iterator](); }
+		keys() { return sortedHeaderEntries(this).map((entry) => entry[0])[Symbol.iterator](); }
+		values() { return sortedHeaderEntries(this).map((entry) => entry[1])[Symbol.iterator](); }
+		forEach(callback, thisArg) {
+			if (typeof callback !== "function") throw new TypeError("callback must be a function");
+			for (const [name, value] of sortedHeaderEntries(this)) callback.call(thisArg, value, name, this);
+		}
+		[Symbol.iterator]() { return this.entries(); }
+	}
+	Object.defineProperty(Headers.prototype, Symbol.toStringTag, { value: "Headers" });
+
+	class Event {
+		constructor(type, init) {
+			if (arguments.length === 0) throw new TypeError("Event type is required");
+			init = init || {};
+			this.type = String(type);
+			this.bubbles = Boolean(init.bubbles);
+			this.cancelable = Boolean(init.cancelable);
+			this.composed = Boolean(init.composed);
+			this.target = null;
+			this.currentTarget = null;
+			this.eventPhase = 0;
+			this.defaultPrevented = false;
+			this.timeStamp = Date.now();
+			this.isTrusted = false;
+			slots.set(this, { stopped: false, immediateStopped: false });
+		}
+		preventDefault() { if (this.cancelable) this.defaultPrevented = true; }
+		stopPropagation() { slot(this).stopped = true; }
+		stopImmediatePropagation() { slot(this).stopped = slot(this).immediateStopped = true; }
+		composedPath() { return this.target == null ? [] : [this.target]; }
+	}
+	Event.NONE = 0; Event.CAPTURING_PHASE = 1; Event.AT_TARGET = 2; Event.BUBBLING_PHASE = 3;
+	Object.assign(Event.prototype, { NONE: 0, CAPTURING_PHASE: 1, AT_TARGET: 2, BUBBLING_PHASE: 3 });
+
+	class ProgressEvent extends Event {
+		constructor(type, init) {
+			init = init || {};
+			super(type, init);
+			this.lengthComputable = Boolean(init.lengthComputable);
+			this.loaded = Number(init.loaded || 0);
+			this.total = Number(init.total || 0);
+		}
+	}
+
+	class EventTarget {
+		constructor() { slots.set(this, { listeners: new Map() }); }
+		addEventListener(type, callback, options) {
+			if (callback == null) return;
+			type = String(type);
+			const listeners = slot(this).listeners.get(type) || [];
+			if (!listeners.some((listener) => listener.callback === callback)) {
+				listeners.push({ callback, once: Boolean(options && typeof options === "object" && options.once) });
+				slot(this).listeners.set(type, listeners);
+			}
+		}
+		removeEventListener(type, callback) {
+			const listeners = slot(this).listeners.get(String(type));
+			if (!listeners) return;
+			slot(this).listeners.set(String(type), listeners.filter((listener) => listener.callback !== callback));
+		}
+		dispatchEvent(event) {
+			if (!(event instanceof Event)) throw new TypeError("event must be an Event");
+			event.target = this;
+			event.currentTarget = this;
+			event.eventPhase = Event.AT_TARGET;
+			const listeners = (slot(this).listeners.get(event.type) || []).slice();
+			for (const listener of listeners) {
+				if (slot(event).immediateStopped) break;
+				if (listener.once) this.removeEventListener(event.type, listener.callback);
+				if (typeof listener.callback === "function") listener.callback.call(this, event);
+				else if (listener.callback && typeof listener.callback.handleEvent === "function") listener.callback.handleEvent(event);
+			}
+			event.currentTarget = null;
+			event.eventPhase = Event.NONE;
+			return !event.defaultPrevented;
+		}
+	}
+	function defineEventHandler(target, type) {
+		let value = null;
+		const listener = (event) => { if (typeof value === "function") value.call(target, event); };
+		Object.defineProperty(target, "on" + type, {
+			configurable: true,
+			enumerable: true,
+			get() { return value; },
+			set(next) {
+				if (value != null) target.removeEventListener(type, listener);
+				value = next;
+				if (value != null) target.addEventListener(type, listener);
+			}
+		});
+	}
+
+	class DOMException extends Error {
+		constructor(message, name) {
+			super(message === undefined ? "" : String(message));
+			this.name = name === undefined ? "Error" : String(name);
+		}
+		get code() {
+			return { IndexSizeError: 1, HierarchyRequestError: 3, WrongDocumentError: 4,
+				InvalidCharacterError: 5, NoModificationAllowedError: 7, NotFoundError: 8,
+				NotSupportedError: 9, InUseAttributeError: 10, InvalidStateError: 11,
+				SyntaxError: 12, InvalidModificationError: 13, NamespaceError: 14,
+				InvalidAccessError: 15, TypeMismatchError: 17, SecurityError: 18,
+				NetworkError: 19, AbortError: 20, URLMismatchError: 21,
+				QuotaExceededError: 22, TimeoutError: 23, InvalidNodeTypeError: 24,
+				DataCloneError: 25 }[this.name] || 0;
+		}
+	}
+
+	class AbortSignal extends EventTarget {
+		constructor() {
+			super();
+			this.aborted = false;
+			this.reason = undefined;
+			defineEventHandler(this, "abort");
+			Object.assign(slot(this), { id: nativeNewAbortSignal() });
+		}
+		throwIfAborted() { if (this.aborted) throw this.reason; }
+		static abort(reason) { const controller = new AbortController(); controller.abort(reason); return controller.signal; }
+		static timeout(milliseconds) {
+			milliseconds = Number(milliseconds);
+			if (!Number.isFinite(milliseconds) || milliseconds < 0) throw new TypeError("Invalid timeout");
+			const controller = new AbortController();
+			setTimeout(() => controller.abort(new DOMException("The operation timed out", "TimeoutError")), milliseconds);
+			return controller.signal;
+		}
+		static any(signals) {
+			const controller = new AbortController();
+			for (const signal of signals) {
+				if (!(signal instanceof AbortSignal)) throw new TypeError("Expected AbortSignal");
+				if (signal.aborted) { controller.abort(signal.reason); break; }
+				signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+			}
+			return controller.signal;
+		}
+	}
+	function abortSignal(signal, reason) {
+		if (signal.aborted) return;
+		signal.aborted = true;
+		signal.reason = reason === undefined ? new DOMException("This operation was aborted", "AbortError") : reason;
+		nativeAbortSignal(slot(signal).id);
+		signal.dispatchEvent(new Event("abort"));
+	}
+
+	class AbortController {
+		constructor() { this.signal = new AbortSignal(); }
+		abort(reason) { abortSignal(this.signal, reason); }
+	}
+
+	class Blob {
+		constructor(parts, options) {
+			parts = parts === undefined ? [] : Array.from(parts);
+			const buffers = parts.map(toBuffer);
+			const total = buffers.reduce((size, buffer) => size + buffer.byteLength, 0);
+			const bytes = new Uint8Array(total);
+			let offset = 0;
+			for (const buffer of buffers) { bytes.set(new Uint8Array(buffer), offset); offset += buffer.byteLength; }
+			slots.set(this, { buffer: bytes.buffer });
+			const type = options && options.type !== undefined ? String(options.type).toLowerCase() : "";
+			this.type = /^[\x20-\x7e]*$/.test(type) ? type : "";
+			this.size = total;
+		}
+		slice(start, end, type) {
+			const size = this.size;
+			start = start === undefined ? 0 : Number(start);
+			end = end === undefined ? size : Number(end);
+			start = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+			end = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+			return new Blob([new Uint8Array(slot(this).buffer, Math.min(start, end), Math.max(end - start, 0))], { type });
+		}
+		arrayBuffer() { return Promise.resolve(copyBuffer(slot(this).buffer)); }
+		bytes() { return Promise.resolve(new Uint8Array(copyBuffer(slot(this).buffer))); }
+		text() { return Promise.resolve(nativeBodyText(slot(this).buffer)); }
+		stream() {
+			const value = new Uint8Array(copyBuffer(slot(this).buffer));
+			let consumed = false;
+			return {
+				getReader() { return { read() { if (consumed) return Promise.resolve({ done: true, value: undefined }); consumed = true; return Promise.resolve({ done: false, value }); }, cancel() { consumed = true; return Promise.resolve(); }, releaseLock() { throw new Error("Blob.stream().getReader().releaseLock is not supported by jsruntime"); } }; },
+				[Symbol.asyncIterator]() { return { next() { if (consumed) return Promise.resolve({ done: true }); consumed = true; return Promise.resolve({ done: false, value }); } }; }
+			};
+		}
+	}
+	Object.defineProperty(Blob.prototype, Symbol.toStringTag, { value: "Blob" });
+
+	class File extends Blob {
+		constructor(parts, name, options) {
+			super(parts, options);
+			this.name = String(name);
+			this.lastModified = options && options.lastModified !== undefined ? Number(options.lastModified) : Date.now();
+			this.webkitRelativePath = "";
+		}
+	}
+	Object.defineProperty(File.prototype, Symbol.toStringTag, { value: "File" });
+
+	class FormData {
+		constructor() { slots.set(this, { entries: [] }); }
+		append(name, value, filename) { slot(this).entries.push([String(name), normalizeFormValue(value, filename)]); }
+		delete(name) { name = String(name); slot(this).entries = slot(this).entries.filter((entry) => entry[0] !== name); }
+		get(name) { name = String(name); const entry = slot(this).entries.find((item) => item[0] === name); return entry ? entry[1] : null; }
+		getAll(name) { name = String(name); return slot(this).entries.filter((entry) => entry[0] === name).map((entry) => entry[1]); }
+		has(name) { name = String(name); return slot(this).entries.some((entry) => entry[0] === name); }
+		set(name, value, filename) {
+			name = String(name);
+			const normalized = normalizeFormValue(value, filename);
+			const index = slot(this).entries.findIndex((entry) => entry[0] === name);
+			this.delete(name);
+			if (index < 0) slot(this).entries.push([name, normalized]); else slot(this).entries.splice(index, 0, [name, normalized]);
+		}
+		entries() { return slot(this).entries.slice()[Symbol.iterator](); }
+		keys() { return slot(this).entries.map((entry) => entry[0])[Symbol.iterator](); }
+		values() { return slot(this).entries.map((entry) => entry[1])[Symbol.iterator](); }
+		forEach(callback, thisArg) { for (const [name, value] of slot(this).entries.slice()) callback.call(thisArg, value, name, this); }
+		[Symbol.iterator]() { return this.entries(); }
+	}
+	Object.defineProperty(FormData.prototype, Symbol.toStringTag, { value: "FormData" });
+	function normalizeFormValue(value, filename) {
+		if (value instanceof Blob) {
+			if (value instanceof File && filename === undefined) return value;
+			return new File([value], filename === undefined ? "blob" : filename, { type: value.type });
+		}
+		return String(value);
+	}
+	function encodeFormData(form) {
+		return nativeEncodeFormData(slot(form).entries.map(([name, value]) => value instanceof Blob ?
+			{ name, value: slot(value).buffer, file: true, filename: value.name || "blob", type: value.type } :
+			{ name, value, file: false }));
+	}
+	function formDataFrom(entries) {
+		const form = new FormData();
+		for (const entry of entries) {
+			if (entry.file) form.append(entry.name, new File([entry.value], entry.filename, { type: entry.type }));
+			else form.append(entry.name, entry.value);
+		}
+		return form;
+	}
+
+	class Body {
+		constructor() { slots.set(this, {}); }
+		get body() { return null; }
+		get bodyUsed() { return slot(this).bodyUsed; }
+		arrayBuffer() { return consumeBody(this, (buffer) => buffer); }
+		blob() { return consumeBody(this, (buffer) => new Blob([buffer], { type: slot(this).contentType })); }
+		bytes() { return consumeBody(this, (buffer) => new Uint8Array(buffer)); }
+		text() { return consumeBody(this, (buffer) => nativeBodyText(buffer)); }
+		json() { return consumeBody(this, (buffer) => JSON.parse(nativeBodyText(buffer))); }
+		formData() { return consumeBody(this, (buffer) => formDataFrom(nativeParseFormData(buffer, slot(this).contentType))); }
+	}
+	function initBody(target, body, contentType) {
+		Object.assign(slot(target), { bodyBuffer: body == null ? new ArrayBuffer(0) : toBuffer(body), bodyUsed: false, contentType: contentType || "" });
+	}
+	function consumeBody(target, transform) {
+		if (slot(target).bodyUsed) return Promise.reject(new TypeError("Body has already been consumed"));
+		slot(target).bodyUsed = true;
+		try { return Promise.resolve(transform(copyBuffer(slot(target).bodyBuffer))); }
+		catch (error) { return Promise.reject(error); }
+	}
+
+	const knownMethods = new Set(["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"]);
+	function normalizeMethod(method) {
+		method = String(method);
+		const upper = method.toUpperCase();
+		if (["CONNECT", "TRACE", "TRACK"].includes(upper)) throw new TypeError("Forbidden HTTP method");
+		if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(method)) throw new TypeError("Invalid HTTP method");
+		return knownMethods.has(upper) ? upper : method;
+	}
+
+	class Request extends Body {
+		constructor(input, init) {
+			super();
+			init = init == null ? {} : Object(init);
+			const source = input instanceof Request ? input : null;
+			Object.assign(slot(this), {
+				url: source ? source.url : String(input),
+				method: normalizeMethod(init.method !== undefined ? init.method : source ? source.method : "GET"),
+				headers: new Headers(init.headers !== undefined ? init.headers : source ? source.headers : undefined),
+				signal: init.signal !== undefined ? init.signal : source ? source.signal : new AbortController().signal,
+				cache: init.cache !== undefined ? String(init.cache) : source ? source.cache : "default",
+				credentials: init.credentials !== undefined ? String(init.credentials) : source ? source.credentials : "same-origin",
+				integrity: init.integrity !== undefined ? String(init.integrity) : source ? source.integrity : "",
+				keepalive: init.keepalive !== undefined ? Boolean(init.keepalive) : source ? source.keepalive : false,
+				mode: init.mode !== undefined ? String(init.mode) : source ? source.mode : "cors",
+				redirect: init.redirect !== undefined ? String(init.redirect) : source ? source.redirect : "follow",
+				referrer: init.referrer !== undefined ? String(init.referrer) : source ? source.referrer : "about:client",
+				referrerPolicy: init.referrerPolicy !== undefined ? String(init.referrerPolicy) : source ? source.referrerPolicy : ""
+			});
+			if (!(slot(this).signal instanceof AbortSignal)) throw new TypeError("signal must be an AbortSignal");
+			if (!["follow", "error", "manual"].includes(slot(this).redirect)) throw new TypeError("Invalid redirect mode");
+			let body = init.body !== undefined ? init.body : source ? slot(source).bodyBuffer : null;
+			if ((slot(this).method === "GET" || slot(this).method === "HEAD") && body != null && toBuffer(body).byteLength !== 0) {
+				throw new TypeError("GET and HEAD requests cannot have a body");
+			}
+			if (body instanceof FormData) {
+				const encoded = encodeFormData(body);
+				body = encoded.body;
+				if (!slot(this).headers.has("content-type")) slot(this).headers.set("content-type", encoded.contentType);
+			} else if (body instanceof Blob && body.type && !slot(this).headers.has("content-type")) {
+				slot(this).headers.set("content-type", body.type);
+			} else if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams && !slot(this).headers.has("content-type")) {
+				slot(this).headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+			} else if (typeof body === "string" && !slot(this).headers.has("content-type")) {
+				slot(this).headers.set("content-type", "text/plain;charset=UTF-8");
+			}
+			initBody(this, body, slot(this).headers.get("content-type") || "");
+		}
+		get cache() { return slot(this).cache; }
+		get credentials() { return slot(this).credentials; }
+		get destination() { return ""; }
+		get headers() { return slot(this).headers; }
+		get integrity() { return slot(this).integrity; }
+		get keepalive() { return slot(this).keepalive; }
+		get method() { return slot(this).method; }
+		get mode() { return slot(this).mode; }
+		get redirect() { return slot(this).redirect; }
+		get referrer() { return slot(this).referrer; }
+		get referrerPolicy() { return slot(this).referrerPolicy; }
+		get signal() { return slot(this).signal; }
+		get url() { return slot(this).url; }
+		get duplex() { return "half"; }
+		clone() { if (this.bodyUsed) throw new TypeError("Body has already been consumed"); return new Request(this); }
+	}
+	Object.defineProperty(Request.prototype, Symbol.toStringTag, { value: "Request" });
+	function nativeRequest(request) {
+		return { method: request.method, url: request.url, headers: Array.from(request.headers), body: slot(request).bodyBuffer,
+			signalId: slot(request.signal).id, redirect: request.redirect };
+	}
+
+	const responseInternal = Symbol("responseInternal");
+	class Response extends Body {
+		constructor(body, init) {
+			super();
+			init = init == null ? {} : Object(init);
+			const internal = init[responseInternal] === true;
+			const status = init.status === undefined ? 200 : Number(init.status);
+			if (!internal && (!Number.isInteger(status) || status < 200 || status > 599)) throw new RangeError("Invalid response status");
+			if (!internal && [101, 204, 205, 304].includes(status) && body != null) throw new TypeError("Response status cannot have a body");
+			Object.assign(slot(this), {
+				status,
+				statusText: init.statusText === undefined ? "" : String(init.statusText),
+				headers: new Headers(init.headers),
+				url: init.url === undefined ? "" : String(init.url),
+				redirected: Boolean(init.redirected),
+				type: init.type === undefined ? "default" : String(init.type)
+			});
+			if (/[\r\n]/.test(slot(this).statusText)) throw new TypeError("Invalid response statusText");
+			initBody(this, body, slot(this).headers.get("content-type") || "");
+		}
+		get headers() { return slot(this).headers; }
+		get ok() { return this.status >= 200 && this.status <= 299; }
+		get redirected() { return slot(this).redirected; }
+		get status() { return slot(this).status; }
+		get statusText() { return slot(this).statusText; }
+		get type() { return slot(this).type; }
+		get url() { return slot(this).url; }
+		clone() {
+			if (this.bodyUsed) throw new TypeError("Body has already been consumed");
+			return new Response(slot(this).bodyBuffer, { [responseInternal]: true, status: this.status, statusText: this.statusText, headers: this.headers, url: this.url, redirected: this.redirected, type: this.type });
+		}
+		static error() { return new Response(null, { [responseInternal]: true, status: 0, type: "error" }); }
+		static redirect(url, status) {
+			status = status === undefined ? 302 : Number(status);
+			if (![301, 302, 303, 307, 308].includes(status)) throw new RangeError("Invalid redirect status");
+			return new Response(null, { status, headers: { location: String(url) } });
+		}
+		static json(data, init) {
+			init = init == null ? {} : Object(init);
+			const serialized = JSON.stringify(data);
+			if (serialized === undefined) throw new TypeError("Value is not JSON serializable");
+			const headers = new Headers(init.headers);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+			return new Response(serialized, Object.assign({}, init, { headers }));
+		}
+	}
+	Object.defineProperty(Response.prototype, Symbol.toStringTag, { value: "Response" });
+
+	function rawToResponse(raw) {
+		return new Response(raw.body, { [responseInternal]: true, status: raw.status, statusText: raw.statusText,
+			headers: raw.headers, url: raw.url, redirected: raw.redirected, type: "basic" });
+	}
+
+	function fetch(input, init) {
+		let request;
+		const source = input instanceof Request ? input : null;
+		if (source && source.bodyUsed) return Promise.reject(new TypeError("Body has already been consumed"));
+		try { request = new Request(input, init); }
+		catch (error) { return Promise.reject(error); }
+		if (request.signal.aborted) return Promise.reject(request.signal.reason);
+		if (source && slot(source).bodyBuffer.byteLength !== 0) slot(source).bodyUsed = true;
+		return nativeFetch(nativeRequest(request)).then(rawToResponse, (error) => {
+			if (request.signal.aborted) throw request.signal.reason;
+			throw error;
+		});
+	}
+
+	Object.assign(globalThis, { Headers, Event, ProgressEvent, EventTarget, DOMException, AbortSignal, AbortController,
+		Blob, File, FormData, Request, Response, fetch });
+	Object.defineProperty(globalThis, "__komariXHRBridge", { configurable: true, value: {
+		nativeFetchSync, rawToResponse, bodyText: nativeBodyText, nativeRequest, defineEventHandler,
+		requestBodyLength: (request) => slot(request).bodyBuffer.byteLength
+	} });
+	delete globalThis.__komariBodyBuffer;
+	delete globalThis.__komariBodyText;
+	delete globalThis.__komariEncodeFormData;
+	delete globalThis.__komariParseFormData;
+	delete globalThis.__komariNewAbortSignal;
+	delete globalThis.__komariAbortSignal;
+	delete globalThis.__komariFetch;
+	delete globalThis.__komariFetchSync;
+})();
@@ -0,0 +1,482 @@
+package fetch
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"mime/multipart"
+	"net/http"
+	"net/textproto"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+
+	"github.com/dop251/goja"
+	"github.com/komari-monitor/komari/pkg/jsruntime/httpbody"
+	"github.com/komari-monitor/komari/pkg/jsruntime/internal/bridge"
+)
+
+type abortSignalState struct {
+	aborted  bool
+	requests map[int64]context.CancelFunc
+}
+
+type nativeRequest struct {
+	method   string
+	url      string
+	headers  [][2]string
+	body     []byte
+	signalID int64
+	redirect string
+}
+
+type httpResult struct {
+	statusCode int
+	statusText string
+	headers    http.Header
+	body       []byte
+	url        string
+	redirected bool
+}
+
+type formEntry struct {
+	Name     string
+	Value    string
+	Bytes    []byte
+	Filename string
+	Type     string
+	File     bool
+}
+
+type Module struct {
+	runtime      *bridge.Runtime
+	vm           *goja.Runtime
+	client       *http.Client
+	maxBodyBytes int64
+	abortMu      sync.Mutex
+	abortIDs     int64
+	abortState   map[int64]*abortSignalState
+}
+
+func New(runtime *bridge.Runtime, client *http.Client, maxBodyBytes int64) *Module {
+	return &Module{
+		runtime:      runtime,
+		client:       client,
+		maxBodyBytes: maxBodyBytes,
+		abortState:   make(map[int64]*abortSignalState),
+	}
+}
+
+func (m *Module) Inject(vm *goja.Runtime) error {
+	m.vm = vm
+	if err := vm.Set("__komariBodyBuffer", m.bodyBuffer); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariBodyText", m.bodyText); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariEncodeFormData", m.encodeFormData); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariParseFormData", m.parseFormData); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariNewAbortSignal", m.newAbortSignal); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariAbortSignal", m.abortSignal); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariFetch", m.createFetchFunction(false)); err != nil {
+		return err
+	}
+	if err := vm.Set("__komariFetchSync", m.createFetchFunction(true)); err != nil {
+		return err
+	}
+	if _, err := vm.RunString(fetchAPISource); err != nil {
+		return fmt.Errorf("inject Fetch API: %w", err)
+	}
+	return nil
+}
+
+func (m *Module) createFetchFunction(syncRequest bool) func(goja.FunctionCall) goja.Value {
+	return func(call goja.FunctionCall) goja.Value {
+		request, err := m.exportNativeRequest(call.Argument(0))
+		if err != nil {
+			panic(m.vm.NewTypeError("%s", err))
+		}
+		ctx, releaseSignal := m.requestContext(request.signalID)
+		ctx, cancelTimeout := context.WithTimeout(ctx, m.runtime.Timeout())
+		release := func() {
+			cancelTimeout()
+			releaseSignal()
+		}
+		if syncRequest {
+			defer release()
+			result, requestErr := m.doHTTPRequest(ctx, request)
+			if requestErr != nil {
+				panic(webAPIError(m.vm, "TypeError", fmt.Sprintf("fetch failed: %v", requestErr)))
+			}
+			return m.httpResultValue(m.vm, result)
+		}
+
+		promise, resolve, reject := m.vm.NewPromise()
+		go func() {
+			result, requestErr := m.doHTTPRequest(ctx, request)
+			if !m.runtime.RunOnLoop(func(vm *goja.Runtime) {
+				defer release()
+				m.runtime.RunJob(vm, "fetch", func() error {
+					if ctx.Err() != nil {
+						return reject(webAPIError(vm, "AbortError", fmt.Sprintf("fetch failed: %v", ctx.Err())))
+					}
+					if requestErr != nil {
+						name := "TypeError"
+						if errors.Is(requestErr, context.Canceled) {
+							name = "AbortError"
+						}
+						return reject(webAPIError(vm, name, fmt.Sprintf("fetch failed: %v", requestErr)))
+					}
+					return resolve(m.httpResultValue(vm, result))
+				})
+			}) {
+				release()
+			}
+		}()
+		return m.vm.ToValue(promise)
+	}
+}
+
+func (m *Module) exportNativeRequest(value goja.Value) (nativeRequest, error) {
+	if value == nil || goja.IsUndefined(value) || goja.IsNull(value) {
+		return nativeRequest{}, errors.New("missing request data")
+	}
+	object := value.ToObject(m.vm)
+	request := nativeRequest{
+		method:   object.Get("method").String(),
+		url:      object.Get("url").String(),
+		signalID: object.Get("signalId").ToInteger(),
+		redirect: object.Get("redirect").String(),
+	}
+	if request.method == "" {
+		request.method = http.MethodGet
+	}
+	if request.redirect == "" {
+		request.redirect = "follow"
+	}
+	if value := object.Get("headers"); value != nil && !goja.IsUndefined(value) {
+		var headers [][]string
+		if err := m.vm.ExportTo(value, &headers); err != nil {
+			return nativeRequest{}, fmt.Errorf("invalid request headers: %w", err)
+		}
+		for _, header := range headers {
+			if len(header) != 2 {
+				return nativeRequest{}, errors.New("invalid request header pair")
+			}
+			request.headers = append(request.headers, [2]string{header[0], header[1]})
+		}
+	}
+	if value := object.Get("body"); value != nil && !goja.IsUndefined(value) && !goja.IsNull(value) {
+		body, err := exportBytes(m.vm, value)
+		if err != nil {
+			return nativeRequest{}, fmt.Errorf("invalid request body: %w", err)
+		}
+		request.body = body
+	}
+	return request, nil
+}
+
+func (m *Module) doHTTPRequest(ctx context.Context, request nativeRequest) (httpResult, error) {
+	httpRequest, err := http.NewRequestWithContext(ctx, request.method, request.url, bytes.NewReader(request.body))
+	if err != nil {
+		return httpResult{}, fmt.Errorf("create request: %w", err)
+	}
+	for _, header := range request.headers {
+		if strings.EqualFold(header[0], "Host") {
+			httpRequest.Host = header[1]
+			continue
+		}
+		httpRequest.Header.Add(header[0], header[1])
+	}
+
+	client := *m.client
+	switch request.redirect {
+	case "manual":
+		client.CheckRedirect = func(*http.Request, []*http.Request) error {
+			return http.ErrUseLastResponse
+		}
+	case "error":
+		client.CheckRedirect = func(*http.Request, []*http.Request) error {
+			return errors.New("redirect mode is set to error")
+		}
+	case "follow":
+	default:
+		return httpResult{}, fmt.Errorf("unsupported redirect mode %q", request.redirect)
+	}
+
+	response, err := client.Do(httpRequest)
+	if err != nil {
+		return httpResult{}, err
+	}
+	defer response.Body.Close()
+	body, err := httpbody.ReadAll(response.Body, m.maxBodyBytes)
+	if err != nil {
+		return httpResult{}, fmt.Errorf("read response: %w", err)
+	}
+	responseURL := request.url
+	if response.Request != nil && response.Request.URL != nil {
+		responseURL = response.Request.URL.String()
+	}
+	statusText := strings.TrimSpace(strings.TrimPrefix(response.Status, strconv.Itoa(response.StatusCode)))
+	return httpResult{
+		statusCode: response.StatusCode,
+		statusText: statusText,
+		headers:    response.Header.Clone(),
+		body:       body,
+		url:        responseURL,
+		redirected: responseURL != request.url,
+	}, nil
+}
+
+func (m *Module) httpResultValue(vm *goja.Runtime, result httpResult) goja.Value {
+	object := vm.NewObject()
+	_ = object.Set("status", result.statusCode)
+	_ = object.Set("statusText", result.statusText)
+	_ = object.Set("url", result.url)
+	_ = object.Set("redirected", result.redirected)
+	_ = object.Set("body", vm.NewArrayBuffer(append([]byte(nil), result.body...)))
+	headers := make([][2]string, 0, len(result.headers))
+	for name, values := range result.headers {
+		for _, value := range values {
+			headers = append(headers, [2]string{name, value})
+		}
+	}
+	_ = object.Set("headers", headers)
+	return object
+}
+
+func (m *Module) bodyBuffer(call goja.FunctionCall) goja.Value {
+	data, err := exportBytes(m.vm, call.Argument(0))
+	if err != nil {
+		panic(m.vm.NewTypeError("unsupported body value: %v", err))
+	}
+	return m.vm.ToValue(m.vm.NewArrayBuffer(data))
+}
+
+func (m *Module) bodyText(call goja.FunctionCall) goja.Value {
+	data, err := exportBytes(m.vm, call.Argument(0))
+	if err != nil {
+		panic(m.vm.NewTypeError("invalid body buffer: %v", err))
+	}
+	return m.vm.ToValue(strings.ToValidUTF8(string(data), "\uFFFD"))
+}
+
+func exportBytes(vm *goja.Runtime, value goja.Value) ([]byte, error) {
+	if value == nil || goja.IsUndefined(value) || goja.IsNull(value) {
+		return nil, nil
+	}
+	if stringValue, ok := value.Export().(string); ok {
+		return []byte(stringValue), nil
+	}
+	if buffer, ok := value.Export().(goja.ArrayBuffer); ok {
+		return append([]byte(nil), buffer.Bytes()...), nil
+	}
+	var bytesValue []byte
+	if err := vm.ExportTo(value, &bytesValue); err != nil {
+		return nil, err
+	}
+	return append([]byte(nil), bytesValue...), nil
+}
+
+func (m *Module) newAbortSignal(goja.FunctionCall) goja.Value {
+	m.abortMu.Lock()
+	defer m.abortMu.Unlock()
+	m.abortIDs++
+	return m.vm.ToValue(m.abortIDs)
+}
+
+func (m *Module) abortSignal(call goja.FunctionCall) goja.Value {
+	id := call.Argument(0).ToInteger()
+	m.abortMu.Lock()
+	state := m.abortState[id]
+	if state == nil {
+		state = &abortSignalState{requests: make(map[int64]context.CancelFunc)}
+		m.abortState[id] = state
+	}
+	state.aborted = true
+	for _, cancel := range state.requests {
+		cancel()
+	}
+	m.abortMu.Unlock()
+	return goja.Undefined()
+}
+
+func (m *Module) requestContext(signalID int64) (context.Context, context.CancelFunc) {
+	ctx, cancel := context.WithCancel(context.Background())
+	if signalID <= 0 {
+		return ctx, cancel
+	}
+
+	m.abortMu.Lock()
+	state := m.abortState[signalID]
+	if state != nil && state.aborted {
+		m.abortMu.Unlock()
+		cancel()
+		return ctx, cancel
+	}
+	if state == nil {
+		state = &abortSignalState{requests: make(map[int64]context.CancelFunc)}
+		m.abortState[signalID] = state
+	}
+	m.abortIDs++
+	requestID := m.abortIDs
+	state.requests[requestID] = cancel
+	m.abortMu.Unlock()
+
+	return ctx, func() {
+		m.abortMu.Lock()
+		if current := m.abortState[signalID]; current != nil {
+			delete(current.requests, requestID)
+			if !current.aborted && len(current.requests) == 0 {
+				delete(m.abortState, signalID)
+			}
+		}
+		m.abortMu.Unlock()
+		cancel()
+	}
+}
+
+func (m *Module) Close() {
+	m.abortMu.Lock()
+	defer m.abortMu.Unlock()
+	for _, state := range m.abortState {
+		state.aborted = true
+		for _, cancel := range state.requests {
+			cancel()
+		}
+	}
+}
+
+func webAPIError(vm *goja.Runtime, name, message string) *goja.Object {
+	object := vm.NewGoError(errors.New(message))
+	_ = object.Set("name", name)
+	return object
+}
+
+func (m *Module) encodeFormData(call goja.FunctionCall) goja.Value {
+	var entries []formEntry
+	array := call.Argument(0).ToObject(m.vm)
+	length := int(array.Get("length").ToInteger())
+	for index := 0; index < length; index++ {
+		entryObject := array.Get(strconv.Itoa(index)).ToObject(m.vm)
+		entry := formEntry{Name: entryObject.Get("name").String()}
+		value := entryObject.Get("value")
+		if entryObject.Get("file").ToBoolean() {
+			entry.File = true
+			entry.Filename = entryObject.Get("filename").String()
+			entry.Type = entryObject.Get("type").String()
+			data, err := exportBytes(m.vm, value)
+			if err != nil {
+				panic(m.vm.NewTypeError("invalid FormData file: %v", err))
+			}
+			entry.Bytes = data
+		} else {
+			entry.Value = value.String()
+		}
+		entries = append(entries, entry)
+	}
+
+	var output bytes.Buffer
+	writer := multipart.NewWriter(&output)
+	for _, entry := range entries {
+		if !entry.File {
+			_ = writer.WriteField(entry.Name, entry.Value)
+			continue
+		}
+		header := make(textproto.MIMEHeader)
+		header.Set("Content-Disposition", fmt.Sprintf(`form-data; name=%q; filename=%q`, entry.Name, entry.Filename))
+		if entry.Type != "" {
+			header.Set("Content-Type", entry.Type)
+		}
+		part, err := writer.CreatePart(header)
+		if err != nil {
+			panic(m.vm.NewGoError(err))
+		}
+		_, _ = part.Write(entry.Bytes)
+	}
+	if err := writer.Close(); err != nil {
+		panic(m.vm.NewGoError(err))
+	}
+	result := m.vm.NewObject()
+	_ = result.Set("body", m.vm.NewArrayBuffer(output.Bytes()))
+	_ = result.Set("contentType", writer.FormDataContentType())
+	return result
+}
+
+func (m *Module) parseFormData(call goja.FunctionCall) goja.Value {
+	data, err := exportBytes(m.vm, call.Argument(0))
+	if err != nil {
+		panic(m.vm.NewTypeError("invalid FormData body: %v", err))
+	}
+	mediaType, parameters, err := mime.ParseMediaType(call.Argument(1).String())
+	if err != nil {
+		panic(m.vm.NewTypeError("invalid form content type: %v", err))
+	}
+	entries := make([]map[string]any, 0)
+	switch mediaType {
+	case "application/x-www-form-urlencoded":
+		for _, field := range strings.Split(string(data), "&") {
+			if field == "" {
+				continue
+			}
+			nameValue := strings.SplitN(field, "=", 2)
+			name, parseErr := url.QueryUnescape(nameValue[0])
+			if parseErr != nil {
+				panic(m.vm.NewTypeError("invalid form field name: %v", parseErr))
+			}
+			value := ""
+			if len(nameValue) == 2 {
+				value, parseErr = url.QueryUnescape(nameValue[1])
+				if parseErr != nil {
+					panic(m.vm.NewTypeError("invalid form field value: %v", parseErr))
+				}
+			}
+			entries = append(entries, map[string]any{"name": name, "value": value})
+		}
+	case "multipart/form-data":
+		boundary := parameters["boundary"]
+		if boundary == "" {
+			panic(m.vm.NewTypeError("multipart form data has no boundary"))
+		}
+		reader := multipart.NewReader(bytes.NewReader(data), boundary)
+		for {
+			part, partErr := reader.NextPart()
+			if errors.Is(partErr, io.EOF) {
+				break
+			}
+			if partErr != nil {
+				panic(m.vm.NewTypeError("invalid multipart body: %v", partErr))
+			}
+			partBytes, readErr := io.ReadAll(part)
+			if readErr != nil {
+				panic(m.vm.NewTypeError("read multipart body: %v", readErr))
+			}
+			entry := map[string]any{"name": part.FormName()}
+			if part.FileName() == "" {
+				entry["value"] = strings.ToValidUTF8(string(partBytes), "\uFFFD")
+			} else {
+				entry["file"] = true
+				entry["filename"] = part.FileName()
+				entry["type"] = part.Header.Get("Content-Type")
+				entry["value"] = m.vm.NewArrayBuffer(partBytes)
+			}
+			entries = append(entries, entry)
+		}
+	default:
+		panic(m.vm.NewTypeError("unsupported form content type %q", mediaType))
+	}
+	return m.vm.ToValue(entries)
+}
@@ -0,0 +1,66 @@
+//go:build !windows
+
+package fs
+
+import (
+	"os"
+	"syscall"
+)
+
+func checkNodeAccess(info os.FileInfo, mode int) error {
+	if mode == 0 {
+		return nil
+	}
+
+	permissions := int(info.Mode().Perm())
+	if os.Geteuid() == 0 {
+		if mode&4 != 0 && permissions&0444 == 0 {
+			return syscall.EACCES
+		}
+		if mode&2 != 0 && permissions&0222 == 0 {
+			return syscall.EACCES
+		}
+		if mode&1 != 0 && permissions&0111 == 0 {
+			return syscall.EACCES
+		}
+		return nil
+	}
+	if stat, ok := info.Sys().(*syscall.Stat_t); ok {
+		uid := uint32(os.Geteuid())
+		gid := uint32(os.Getegid())
+		switch {
+		case uid == stat.Uid:
+			permissions = (permissions >> 6) & 7
+		case gid == stat.Gid || nodeSupplementaryGroup(stat.Gid):
+			permissions = (permissions >> 3) & 7
+		default:
+			permissions &= 7
+		}
+	} else {
+		permissions &= 7
+	}
+
+	if mode&4 != 0 && permissions&4 == 0 {
+		return syscall.EACCES
+	}
+	if mode&2 != 0 && permissions&2 == 0 {
+		return syscall.EACCES
+	}
+	if mode&1 != 0 && permissions&1 == 0 {
+		return syscall.EACCES
+	}
+	return nil
+}
+
+func nodeSupplementaryGroup(group uint32) bool {
+	groups, err := os.Getgroups()
+	if err != nil {
+		return false
+	}
+	for _, candidate := range groups {
+		if uint32(candidate) == group {
+			return true
+		}
+	}
+	return false
+}
@@ -0,0 +1,19 @@
+//go:build windows
+
+package fs
+
+import (
+	"os"
+	"syscall"
+)
+
+func checkNodeAccess(info os.FileInfo, mode int) error {
+	if mode&4 != 0 && info.Mode().Perm()&0444 == 0 {
+		return syscall.EACCES
+	}
+	if mode&2 != 0 && info.Mode().Perm()&0222 == 0 {
+		return syscall.EACCES
+	}
+	// Windows does not expose a portable executable/search permission bit.
+	return nil
+}
@@ -0,0 +1,412 @@
+package fs
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"io/fs"
+	"os"
+
+	"github.com/dop251/goja"
+	"github.com/dop251/goja_nodejs/buffer"
+)
+
+type fsAsyncOperation struct {
+	run    func() (any, error)
+	values func(*goja.Runtime, any) []goja.Value
+}
+
+type fsReadFileResult struct {
+	data     []byte
+	encoding string
+}
+
+type fsReadDirResult struct {
+	entries   []fs.DirEntry
+	withTypes bool
+}
+
+type fsReadResult struct {
+	count  int
+	data   []byte
+	target goja.Value
+	offset int
+}
+
+type fsWriteResult struct {
+	count  int
+	target goja.Value
+}
+
+func fsArgument(arguments []goja.Value, index int) goja.Value {
+	if index < 0 || index >= len(arguments) {
+		return goja.Undefined()
+	}
+	return arguments[index]
+}
+
+func fsNoValues(*goja.Runtime, any) []goja.Value { return nil }
+
+func fsSingleValue(vm *goja.Runtime, result any) []goja.Value {
+	return []goja.Value{vm.ToValue(result)}
+}
+
+func (m *Module) prepareFSAsync(vm *goja.Runtime, name string, arguments []goja.Value) fsAsyncOperation {
+	cwd := m.Cwd()
+	follow := func(path string, allowMissing bool) (string, error) {
+		return m.resolveNodePathAt(path, cwd, allowMissing, nodePathFollowFinal)
+	}
+	noFollow := func(path string, allowMissing bool) (string, error) {
+		return m.resolveNodePathAt(path, cwd, allowMissing, nodePathNoFollowFinal)
+	}
+
+	switch name {
+	case "readFile":
+		pathName := fsArgument(arguments, 0).String()
+		encoding := fsEncoding(fsArgument(arguments, 1))
+		return fsAsyncOperation{
+			run: func() (any, error) {
+				path, err := follow(pathName, false)
+				if err != nil {
+					return nil, err
+				}
+				data, err := m.nodeReadFile(path)
+				return fsReadFileResult{data: data, encoding: encoding}, err
+			},
+			values: func(vm *goja.Runtime, result any) []goja.Value {
+				value := result.(fsReadFileResult)
+				return []goja.Value{encodeFSData(vm, value.data, value.encoding)}
+			},
+		}
+	case "writeFile", "appendFile":
+		pathName := fsArgument(arguments, 0).String()
+		data := append([]byte(nil), buffer.Bytes(vm, fsArgument(arguments, 1))...)
+		mode := fsMode(fsArgument(arguments, 2), 0o666)
+		appendMode := name == "appendFile"
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, true)
+			if err != nil {
+				return nil, err
+			}
+			flags := os.O_CREATE | os.O_WRONLY | os.O_TRUNC
+			if appendMode {
+				flags = os.O_CREATE | os.O_WRONLY | os.O_APPEND
+			}
+			file, err := m.nodeOpenFile(path, flags, mode)
+			if err != nil {
+				return nil, err
+			}
+			_, writeErr := file.Write(data)
+			return nil, errors.Join(writeErr, file.Close())
+		}, values: fsNoValues}
+	case "access":
+		pathName := fsArgument(arguments, 0).String()
+		mode := fsAccessMode(fsArgument(arguments, 1))
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, false)
+			if err == nil {
+				err = m.nodeAccess(path, mode)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "stat", "lstat":
+		pathName := fsArgument(arguments, 0).String()
+		isLstat := name == "lstat"
+		return fsAsyncOperation{run: func() (any, error) {
+			var path string
+			var err error
+			if isLstat {
+				path, err = noFollow(pathName, false)
+			} else {
+				path, err = follow(pathName, false)
+			}
+			if err != nil {
+				return nil, err
+			}
+			if isLstat {
+				return m.nodeStat(path, false)
+			}
+			return m.nodeStat(path, true)
+		}, values: func(vm *goja.Runtime, result any) []goja.Value {
+			return []goja.Value{fsStatObject(vm, result.(os.FileInfo))}
+		}}
+	case "readdir":
+		pathName := fsArgument(arguments, 0).String()
+		withTypes := fsWithFileTypes(fsArgument(arguments, 1))
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, false)
+			if err != nil {
+				return nil, err
+			}
+			entries, err := m.nodeReadDir(path)
+			return fsReadDirResult{entries: entries, withTypes: withTypes}, err
+		}, values: func(vm *goja.Runtime, result any) []goja.Value {
+			value := result.(fsReadDirResult)
+			entries := make([]any, 0, len(value.entries))
+			for _, entry := range value.entries {
+				if value.withTypes {
+					entries = append(entries, fsDirent(vm, entry))
+				} else {
+					entries = append(entries, entry.Name())
+				}
+			}
+			return []goja.Value{vm.ToValue(entries)}
+		}}
+	case "mkdir":
+		pathName := fsArgument(arguments, 0).String()
+		options := fsArgument(arguments, 1)
+		recursive, mode := fsBooleanOption(options, "recursive"), fsMode(options, 0o777)
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := noFollow(pathName, true)
+			if err != nil {
+				return nil, err
+			}
+			if recursive {
+				err = m.nodeMkdir(path, mode, true)
+			} else {
+				err = m.nodeMkdir(path, mode, false)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "rm":
+		pathName := fsArgument(arguments, 0).String()
+		options := fsArgument(arguments, 1)
+		recursive, force := fsBooleanOption(options, "recursive"), fsBooleanOption(options, "force")
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := noFollow(pathName, true)
+			if err != nil {
+				return nil, err
+			}
+			if recursive {
+				err = m.nodeRemove(path, true)
+			} else {
+				err = m.nodeRemove(path, false)
+			}
+			if force && os.IsNotExist(err) {
+				err = nil
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "unlink", "rmdir":
+		pathName := fsArgument(arguments, 0).String()
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := noFollow(pathName, false)
+			if err == nil {
+				err = m.nodeRemove(path, false)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "rename":
+		oldName, newName := fsArgument(arguments, 0).String(), fsArgument(arguments, 1).String()
+		return fsAsyncOperation{run: func() (any, error) {
+			oldPath, err := noFollow(oldName, false)
+			if err != nil {
+				return nil, err
+			}
+			newPath, err := noFollow(newName, true)
+			if err == nil {
+				err = m.nodeRename(oldPath, newPath)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "copyFile":
+		sourceName, targetName := fsArgument(arguments, 0).String(), fsArgument(arguments, 1).String()
+		return fsAsyncOperation{run: func() (any, error) {
+			source, err := follow(sourceName, false)
+			if err != nil {
+				return nil, err
+			}
+			target, err := follow(targetName, true)
+			if err != nil {
+				return nil, err
+			}
+			input, err := m.nodeOpenFile(source, os.O_RDONLY, 0)
+			if err != nil {
+				return nil, err
+			}
+			defer input.Close()
+			output, err := m.nodeOpenFile(target, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o666)
+			if err != nil {
+				return nil, err
+			}
+			_, copyErr := io.Copy(output, input)
+			return nil, errors.Join(copyErr, output.Close())
+		}, values: fsNoValues}
+	case "realpath", "readlink":
+		pathName := fsArgument(arguments, 0).String()
+		readLink := name == "readlink"
+		return fsAsyncOperation{run: func() (any, error) {
+			if readLink {
+				path, err := noFollow(pathName, false)
+				if err != nil {
+					return nil, err
+				}
+				return m.nodeReadlink(path)
+			}
+			return follow(pathName, false)
+		}, values: fsSingleValue}
+	case "symlink":
+		targetName, linkName := fsArgument(arguments, 0).String(), fsArgument(arguments, 1).String()
+		return fsAsyncOperation{run: func() (any, error) {
+			target, err := follow(targetName, true)
+			if err != nil {
+				return nil, err
+			}
+			link, err := noFollow(linkName, true)
+			if err == nil {
+				err = m.nodeSymlink(target, link)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "truncate":
+		pathName, size := fsArgument(arguments, 0).String(), fsArgument(arguments, 1).ToInteger()
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, false)
+			if err == nil {
+				err = m.nodeTruncate(path, size)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "chmod":
+		pathName := fsArgument(arguments, 0).String()
+		mode := os.FileMode(fsArgument(arguments, 1).ToInteger())
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, false)
+			if err == nil {
+				err = m.nodeChmod(path, mode)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "utimes":
+		pathName := fsArgument(arguments, 0).String()
+		accessTime, modifyTime := fsTime(fsArgument(arguments, 1).Export()), fsTime(fsArgument(arguments, 2).Export())
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, false)
+			if err == nil {
+				err = m.nodeChtimes(path, accessTime, modifyTime)
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "mkdtemp":
+		prefix := fsArgument(arguments, 0).String()
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := noFollow(prefix, true)
+			if err != nil {
+				return nil, err
+			}
+			return m.nodeMkdirTemp(path)
+		}, values: fsSingleValue}
+	case "open":
+		pathName := fsArgument(arguments, 0).String()
+		flags := fsArgument(arguments, 1).String()
+		mode := fsMode(fsArgument(arguments, 2), 0o666)
+		return fsAsyncOperation{run: func() (any, error) {
+			path, err := follow(pathName, true)
+			if err != nil {
+				return nil, err
+			}
+			return m.fsOpenPath(path, flags, mode)
+		}, values: fsSingleValue}
+	case "close":
+		fd := int(fsArgument(arguments, 0).ToInteger())
+		return fsAsyncOperation{run: func() (any, error) { return nil, m.fsClose(fd) }, values: fsNoValues}
+	case "fstat":
+		fd := int(fsArgument(arguments, 0).ToInteger())
+		return fsAsyncOperation{run: func() (any, error) {
+			file, err := m.fsFile(fd)
+			if err != nil {
+				return nil, err
+			}
+			return file.Stat()
+		}, values: func(vm *goja.Runtime, result any) []goja.Value {
+			return []goja.Value{fsStatObject(vm, result.(os.FileInfo))}
+		}}
+	case "fsync":
+		fd := int(fsArgument(arguments, 0).ToInteger())
+		return fsAsyncOperation{run: func() (any, error) {
+			file, err := m.fsFile(fd)
+			if err == nil {
+				err = file.Sync()
+			}
+			return nil, err
+		}, values: fsNoValues}
+	case "read":
+		fd := int(fsArgument(arguments, 0).ToInteger())
+		target := fsArgument(arguments, 1)
+		offset := int(fsArgument(arguments, 2).ToInteger())
+		length := int(fsArgument(arguments, 3).ToInteger())
+		positionValue := fsArgument(arguments, 4)
+		hasPosition := !goja.IsNull(positionValue) && !goja.IsUndefined(positionValue)
+		position := positionValue.ToInteger()
+		bufferLength := len(buffer.Bytes(vm, target))
+		if offset < 0 || length < 0 || offset+length > bufferLength {
+			panic(vm.NewTypeError("buffer range is out of bounds"))
+		}
+		return fsAsyncOperation{run: func() (any, error) {
+			file, err := m.fsFile(fd)
+			if err != nil {
+				return nil, err
+			}
+			data := make([]byte, length)
+			var count int
+			if hasPosition {
+				count, err = file.ReadAt(data, position)
+			} else {
+				count, err = file.Read(data)
+			}
+			if errors.Is(err, io.EOF) {
+				err = nil
+			}
+			return fsReadResult{count: count, data: data[:count], target: target, offset: offset}, err
+		}, values: func(vm *goja.Runtime, result any) []goja.Value {
+			value := result.(fsReadResult)
+			copy(buffer.Bytes(vm, value.target)[value.offset:], value.data)
+			return []goja.Value{vm.ToValue(value.count), value.target}
+		}}
+	case "write":
+		fd := int(fsArgument(arguments, 0).ToInteger())
+		target := fsArgument(arguments, 1)
+		data := append([]byte(nil), buffer.Bytes(vm, target)...)
+		positionValue := fsArgument(arguments, 4)
+		if _, isString := target.Export().(string); !isString {
+			offset := int(fsArgument(arguments, 2).ToInteger())
+			length := int(fsArgument(arguments, 3).ToInteger())
+			if offset < 0 || length < 0 || offset+length > len(data) {
+				panic(vm.NewTypeError("buffer range is out of bounds"))
+			}
+			data = data[offset : offset+length]
+		} else {
+			positionValue = fsArgument(arguments, 2)
+		}
+		hasPosition := !goja.IsNull(positionValue) && !goja.IsUndefined(positionValue)
+		position := positionValue.ToInteger()
+		return fsAsyncOperation{run: func() (any, error) {
+			file, err := m.fsFile(fd)
+			if err != nil {
+				return nil, err
+			}
+			var count int
+			if hasPosition {
+				count, err = file.WriteAt(data, position)
+			} else {
+				count, err = file.Write(data)
+			}
+			return fsWriteResult{count: count, target: target}, err
+		}, values: func(vm *goja.Runtime, result any) []goja.Value {
+			value := result.(fsWriteResult)
+			return []goja.Value{vm.ToValue(value.count), value.target}
+		}}
+	default:
+		return fsAsyncOperation{run: func() (any, error) {
+			return nil, fmt.Errorf("unsupported fs operation: %s", name)
+		}, values: fsNoValues}
+	}
+}
+
+func (m *Module) fsOpenPath(path, flags string, mode os.FileMode) (int, error) {
+	file, err := m.nodeOpenFile(path, fsOpenFlags(flags), mode)
+	if err != nil {
+		return 0, err
+	}
+	return m.registerFile(file)
+}
Author	SHA1	Message	Date
Akizon77	f0cc0fba38	fix: pin 1.5.1 frontend release source	2026-09-24 23:21:05 +08:00
Akizon77	1d972c42dc	fix: pin 1.5.1-rc1 frontend version	2026-09-24 17:25:06 +08:00
Akizon	f089b08b3a	裁剪1下	2026-09-24 17:21:44 +08:00
Akizon	6e70263c50	重定向旧版本的主题接口？	2026-09-24 17:21:37 +08:00
Akizon77	0ca87aafd1	移除流量通知	2026-09-14 21:13:26 +08:00
Akizon	f18ad72c17	Merge pull request #669 from MousseC/fix/upgrade-request-detection fix(plugin): 仅当 Connection 与 Upgrade 头同时存在时判定协议升级请求	2026-09-14 13:44:49 +08:00
Akizon	8e4a3f8709	Merge pull request #672 from MiaM1ku/fix/latest-status-gpu-usage fix: getNodesLatestStatus 写入实时 GPU 占用	2026-09-14 13:43:40 +08:00
Nya	80add06a12	fix: getNodeRecentStatus 同样写入 GPU 占用该接口扁平化近期上报时 Gpu 也被写死为 0，与 getNodesLatestStatus 同类问题。	2026-09-11 23:56:18 +08:00
Nya	1333d63ce0	fix: getNodesLatestStatus 写入实时 GPU 占用此前 recordLike.Gpu 被写死为 0，主题实时 GPU 一直显示 0，而历史 gpu.usage 正常。改为使用 report.GPU.AverageUsage，并附带 gpu_count / gpu_average_usage / gpu_detailed_info。	2026-09-11 23:52:18 +08:00
MousseC	44ed3035f1	chore(plugin): shorten isUpgradeRequest doc comment	2026-09-08 20:34:23 +08:00
MousseC	7ec36157d5	test(plugin): cover upgrade detection and injection behind bare Connection header	2026-09-08 18:41:58 +08:00
MousseC	360fd5f50b	fix(plugin): detect protocol upgrades only when both headers are present isUpgradeRequest previously flagged any request carrying a bare `Connection: upgrade` header -- or a bare `Upgrade: websocket` header -- as a protocol upgrade, bypassing plugin HTML injection and request/response hooks. Some reverse-proxy templates (e.g. sites created by 1Panel) set `proxy_set_header Connection upgrade;` unconditionally, so every proxied page request skipped the plugin middleware silently while plugins still reported as loaded. Per RFC 9110 section 7.8 a valid upgrade request carries both headers: Connection lists the upgrade token and Upgrade names the target protocol. Require the Upgrade header to be present and the Connection list to contain the upgrade token, and accept any upgrade protocol rather than only websocket.	2026-09-08 18:41:55 +08:00
Akizon77	b11ffd3aa7	使用zstd压缩前端，节约空间！	2026-09-04 16:16:41 +08:00
Akizon77	d7d6135c49	让SSRF策略可以调整1下！	2026-09-04 13:59:37 +08:00
Akizon77	ac037f2177	换了1个更好的按安装脚本！	2026-09-04 11:43:42 +08:00
Akizon77	5405bdf377	使用人类友好的时间格式	2026-09-02 16:09:16 +08:00
Akizon	f754f01f53	Merge pull request #652 from YZoiu/fix/metric-store-remote-write-timeout fix(metricstore): break report counter restore retry loop on slow remote databases	2026-09-02 15:41:27 +08:00
Akizon77	434ba108e1	后续版本将不再支持v1协议了捏	2026-09-02 15:30:30 +08:00
Yuzhong ZhangandAkizon77	24254749b5	现在只剩v2了 (#653 ) Co-authored-by: Akizon77 <hytf233g@gmail.com>	2026-09-02 15:01:04 +08:00
Akizon	c6b02af000	感谢新的金主喵	2026-09-01 15:50:56 +08:00
Akizon	b28ac9d42c	感谢新的金主喵	2026-09-01 15:50:03 +08:00
Akizon77	2ff7c11db0	refactor: remove v1 protocol and stabilize file transfer	2026-08-29 19:03:53 +08:00
Akizon77	46fd2af44c	feat: 自动推断分片大小	2026-08-29 15:03:14 +08:00
Akizon77	4d2eb70c62	fix: 分片文件操作过早关闭io导致502	2026-08-29 12:38:32 +08:00
Akizon77	7a6692b79a	pref: 文件上传下载链路	2026-08-29 11:24:22 +08:00
Akizon77	63d78b6ed4	pref: 下载速度优化	2026-08-28 23:41:27 +08:00
Akizon77	2319ea77f6	fix: 上传大小限制	2026-08-28 22:02:27 +08:00
Akizon77	0c39a52e0b	feat: file access / editor	2026-08-28 20:11:18 +08:00
Akizon77	e31a032d89	feat(terminal): support session reattachment on WebSocket reconnect	2026-08-26 14:40:01 +08:00
Akizon77	da4d5187c1	docs: update Rainyun deployment descriptions	2026-08-17 14:59:36 +08:00
Akizon77	bf6b45ec3a	fix(metricstore): #646 skip traffic deltas on agent restart or counter reset	2026-08-13 17:10:59 +08:00
Akizon77	4a3400bee6	feat(notifier): warn users to migrate before traffic report removal	2026-08-13 15:45:56 +08:00
Akizon77	4caa067556	feat(plugin): reload plugin after config update	2026-08-13 14:28:32 +08:00
Akizon77	2f3959adde	fix(child_process): stop inheriting runtime timeout for child processes Replace default runtime timeout with explicit timeout only, avoiding unexpected termination of long-running child processes when a runtime-level timeout is configured.	2026-08-13 14:13:26 +08:00
Akizon77	63a7ffddcf	fix(plugin): normalize RPC results before resolving promises RPC results were passed directly to goja's resolve, which could fail for non-JSON-compatible Go types. Add normalizeRPCValue to round-trip the result through JSON, ensuring it becomes plain data structures. Handle serialization errors properly by rejecting the promise.	2026-08-13 13:05:12 +08:00
Akizon77	92d679ffdb	feat(console): format values as JSON and error messages Improve console output by replacing fmt.Sprint with a dedicated value formatter that renders null, strings, errors, and JSON-serializable objects more intuitively for JavaScript runtime users.	2026-08-13 11:45:10 +08:00
Akizon77	7c30fc4dc9	feat: #635 add historical backup cleanup and harden upgrade rollback	2026-08-13 09:43:05 +08:00
Akizon77	773a3715dc	feat(upload): add chunked upload store for themes/plugins	2026-08-12 22:38:07 +08:00
Akizon77	75d7b6c7a3	feat(migration): cap structure upgrade progress at 80%	2026-08-12 20:38:31 +08:00
Akizon77	c294c17642	feat: add managed configuration selectors	2026-08-12 16:46:05 +08:00
Akizon77	2883bf6295	feat: add raw SQL query and exec RPC methods	2026-08-11 17:41:46 +08:00
Akizon77	14bf8bde7c	build: use COPY --chmod in Dockerfile	2026-08-07 16:57:13 +08:00
Akizon77	f043f2890c	docs: update README	2026-08-07 16:23:31 +08:00
Akizon77	057108a2f3	docs: update README	2026-08-07 16:13:50 +08:00
Akizon77	5879d4b3da	pref: mem alloc	2026-08-07 13:31:05 +08:00
Akizon77	16769d5687	pref: reduce cpu usage while querying metrics	2026-08-06 23:14:31 +08:00
Akizon77	5ea32c48b6	remove undefined metrics before reclaiming space	2026-08-06 20:25:36 +08:00
Akizon77	a06d922d78	fix(metricstore): do not delete metric history during startup	2026-08-06 20:06:38 +08:00
Akizon77	0ed14fc73d	pref: 减少重复查询	2026-08-06 19:53:19 +08:00
Akizon77	61bd0c8bdd	perf(metric): reduce SQLite memory usage and make mmap opt-in Lower default cache size from 16MB to 4MB and journal size limit from 16MB to 4MB. Change MMapSizeBytes handling so 0 explicitly disables mmap instead of being overwritten with a 32MB default; negative values are normalized to 0. Update tests to match the new default journal size limit.	2026-08-05 21:13:19 +08:00
Akizon77	e5d67686db	feat(plugin): add WebSocket hook support to server.hook Implement wsConnect, wsMessage, wsSend, and wsClose hook kinds so plugins can intercept WebSocket connections and frames. Refactor the hook matcher to match paths independently of HTTP requests and add runHookTurnTimeout so WebSocket hook turns that exceed the runtime timeout can fall back to passing the message through without blocking the caller.	2026-08-05 15:44:08 +08:00
Akizon77	96462528c8	feat(metricstore): make rollup retention configurable Add configuration options for 1-minute, 5-minute, and 1-hour rollup retention windows, replacing the fixed default policy. Zero values fall back to sensible defaults, and invalid negative values are rejected. Also guard against nil metric store configs to avoid panics during config building.	2026-08-04 12:33:59 +08:00
Akizon77	d92f60f757	fix(oauth): redirect to admin dashboard after OAuth login	2026-08-04 11:07:28 +08:00
Akizon77	cba8153d4a	feat:metrics zstd compress & fix pingtask order	2026-08-03 20:58:05 +08:00
Akizon77	08067bc8f8	pref: metrics db IO Read/Write	2026-08-03 14:53:20 +08:00
Akizon77	a714637fee	fix(notifier): skip load notification when no clients to notify	2026-08-02 23:25:15 +08:00
Akizon77	956b9334d0	fix(jsruntime/fs): allow no-follow operations on confined root Operations such as mkdirSync(root, {recursive:true}) resolve to the root itself, whose parent is outside the sandbox. The parent symlink check would reject these valid paths. Skip the check when the resolved path is exactly a confined root (BaseDir or extra root).	2026-08-02 23:03:37 +08:00
Akizon77	996dd90386	feat: add SendNotification and support any event payload fields	2026-08-02 21:21:16 +08:00
Akizon77	28abafb5b2	fix(rpc): make registered methods discoverable via rpc.help Ensure every registered method gets metadata, populating missing names with the qualified method. This fixes plugin methods without explicit metadata not appearing in rpc.help and ensures consistent fully-qualified names.	2026-08-02 16:20:01 +08:00
Akizon77	5488189e5f	feat(plugin): add server.cron scheduled task support	2026-08-02 13:27:34 +08:00
Akizon77	d9713aa696	fix: hook 过滤 + 按插件 body 上限	2026-08-02 13:14:15 +08:00
Akizon77	eab03a1da5	feat(plugin): add server.static for serving plugin static folders	2026-08-02 13:04:16 +08:00
Akizon77	1f139ba3bf	feat: add HTML injection permission and support for plugins	2026-08-02 12:09:16 +08:00
Akizon77	4040a5d9c7	feat: add plugin data storage and remove preview field - Create ./data/plugin-data directory during bootstrap for plugin-owned persistent storage. - Document ExtraRoots and StorageDir in jsruntime README, including __storageDir__ global injection. - Drop Preview field from plugin market API and its validation as no longer used.	2026-08-02 11:51:30 +08:00
Akizon77	01c4816d1c	feat(plugin): add persistent storage dir for plugins Add StorageDir (data/plugin-data/<short>) exposed to plugin runtimes as __storageDir__, giving plugins a location for long-term data that survives plugin updates. The existing DataDir/<short> remains the install/code directory and is replaced on update, while storage is preserved and only removed when the plugin is deleted. Update filesystem path handling to support plugin storage roots, reset StorageDir in tests, and drop the unused golang.org/x/image dependency.	2026-08-02 00:43:59 +08:00
Akizon77	c27c21d5c9	fix(plugin): limit response hook buffering and safely reinstall	2026-08-01 22:40:53 +08:00
Akizon77	f967ba07f9	feat(plugin): set official plugin market as default source Default the plugin market to the official komari-monitor/plugin-market catalog (raw v1.json), mirroring the theme market. Adds plugin_market_test.go coverage for catalog parsing, validation and the default source.	2026-08-01 20:57:12 +08:00
Akizon77	91d5f92c55	feat: crypto module support	2026-08-01 20:21:04 +08:00
Akizon77	965afb3f77	feat(jsruntime): add node:stream module and embed nexttick JS	2026-08-01 19:04:13 +08:00
Akizon77	68bf4ed148	feat(plugin): enforce server module permission gates Update plugin permissions to separate admin-approved capabilities from runtime settings. Add AllowSystemRPC, AllowRoutes, and AllowHooks to control server.call, server.route, and server.hook respectively. Registering RPC methods, reading own config, and accessing plugin-local files remain always allowed, so plugins without dangerous permissions can be enabled without approval. Add tests covering server module enforcement and default-granted capabilities.	2026-08-01 17:47:47 +08:00
Akizon77	8985adcf67	feat: add plugin system and refactor jsruntime deadline handling	2026-08-01 15:24:50 +08:00
Akizon77	91cbeb3f82	fix(jsruntime): treat process.exit(0) as normal termination and improve error reporting	2026-07-31 16:55:00 +08:00
Akizon77	91ae9eda1a	docs(jsruntime): clarify unsupported methods throw instead of no-op	2026-07-31 16:18:50 +08:00
Akizon77	54851bd1cf	docs(jsruntime): add API and compatibility documentation	2026-07-31 15:07:38 +08:00
Akizon77	3c5838283e	refactor(jsruntime): modularize built-ins	2026-07-31 15:02:30 +08:00
Akizon77	df6ffba18c	refactor: javascript runtime	2026-07-30 23:17:06 +08:00
Akizon77	4077201f09	style: 移除没有使用的旧版本兼容代码，移动 database/metricstore 到 internal/metricstore 并拆分组件	2026-07-30 14:41:27 +08:00
Akizon77	05a91adc53	fix: #626 CPU占用过大	2026-07-30 11:14:18 +08:00
Akizon77	1c75cb8be0	perf: preallocate slice capacity based on queue length in drain functions	2026-07-29 10:09:28 +08:00