更新 npm 版本 v2.20.0

移除 init_nginx
更新 pipeline
2026-11-03 16:19:11 +08:00 · 2025-12-11 01:57:01 +08:00 · 2025-12-11 01:56:52 +08:00 · 2025-12-11 01:53:51 +08:00 · 2025-12-11 01:53:51 +08:00 · 2025-12-11 01:53:51 +08:00
615 changed files with 7374 additions and 79410 deletions
@@ -1,13 +0,0 @@
-.git
-.gitnexus
-.claude
-.codex
-.env*
-node_modules
-data
-audit
-docs
-test
-src/.umi*
-**/__pycache__
-**/*.log
@@ -1,18 +1,6 @@
 GRPC_PORT=5500
 BACK_PORT=5700

-# 服务绑定地址，默认 ::（IPv6 通配，双栈系统同时支持 IPv4/IPv6）
-# 纯 IPv4 环境自动 fallback 到 0.0.0.0，也可手动指定
-# BIND_HOST=0.0.0.0
-# BIND_HOST_GRPC=0.0.0.0
-
-# 可信反向代理。未设置时可在「系统设置 → 客户端 IP」中配置和诊断。
-# 环境变量优先级高于系统设置。支持固定层数、IP、CIDR 或逗号分隔列表：
-# QL_TRUST_PROXY=1
-# QL_TRUST_PROXY=loopback,172.18.0.0/16,10.20.0.8/32
-# 仅在面板端口绝对无法绕过代理直接访问时使用 true。
-# QL_TRUST_PROXY=loopback
-
 LOG_LEVEL='info'

 JWT_SECRET=
@@ -21,6 +9,3 @@ JWT_EXPIRES_IN=
 QINIU_AK=
 QINIU_SK=
 QINIU_SCOPE=
-
-# Python 虚拟环境路径，留空则使用系统 Python
-# PYTHON_VENV_DIR=./.venv
@@ -2,272 +2,155 @@ name: Build And Push Docker Image

 on:
  push:
-    paths:
-      - "**"
-      - "!*.md"
-      # CLI is verified separately; its shared Bash upgrade engine ships in images.
-      - "!cli/**"
-      - "cli/src/internal/maintenance/upgradeArtifacts.cjs"
-      - "cli/src/internal/maintenance/platformBundle.cjs"
-      - "cli/src/internal/maintenance/upgradePrestart.cjs"
-      - "cli/src/internal/maintenance/panelUpgrade.cjs"
-      - "cli/src/internal/maintenance/nodeRuntime.cjs"
-      - "!.github/workflows/cli-package.yml"
+    paths-ignore:
+      - "*.md"
    branches:
      - "master"
      - "develop"
+      - "debian"
+      - "debian-dev"
    tags:
      - "v*"
+  schedule:
+    - cron: "00 20 * * *"
  workflow_dispatch:
-    inputs:
-      static_sync_only:
-        description: Synchronize an existing static snapshot to GitLab and verify Gitee
-        type: boolean
-        default: false
-      static_ref:
-        description: Static branch or version name, for example v2.22.0
-        type: string
-        default: ''
-      static_ref_type:
-        description: Synchronize a branch, or a version branch and Git tag
-        type: choice
-        options: [branch, tag]
-        default: branch
-
-permissions:
-  contents: read
-
-# Keep master image tags and their bundle indexes in one serialized release.
-# A rerun may intentionally replace a version, including from the same commit.
-# Develop image builds and their shared bundle index serialize separately.
-# Git-tag builds and static synchronization remain independent.
-concurrency:
-  group: version-images-${{ github.ref == 'refs/heads/master' && 'master' || (github.ref == 'refs/heads/develop' && !inputs.static_sync_only && 'develop') || format('{0}-{1}', github.run_id, github.run_attempt) }}
-  cancel-in-progress: false

 jobs:
-  validate:
-    if: ${{ !inputs.static_sync_only }}
-    uses: ./.github/workflows/validate.yml
-
  code_gitlab:
-    if: ${{ !inputs.static_sync_only }}
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
-      - name: Push to GitLab
-        run: |
-          set +e
-          mkdir -p ~/.ssh
-          printf '%s\n' "${{ secrets.GITLAB_SSH_PK }}" > ~/.ssh/id_rsa
-          chmod 600 ~/.ssh/id_rsa
-          ssh-keyscan -T 10 gitlab.com >> ~/.ssh/known_hosts 2>/dev/null
-          git remote add gitlab git@gitlab.com:whyour/qinglong.git 2>/dev/null
-          git push --force --all gitlab 2>&1 || echo "::warning::GitLab push failed"
-          git push --force --tags gitlab 2>&1 || echo "::warning::GitLab tags push failed"
+      - uses: Yikun/hub-mirror-action@master
+        with:
+          src: github/whyour
+          dst: gitlab/whyour
+          dst_key: ${{ secrets.GITLAB_SSH_PK }}
+          dst_token: ${{ secrets.GITLAB_TOKEN }}
+          static_list: "qinglong"
+          force_update: true

-  build-static:
-    if: ${{ !inputs.static_sync_only }}
-    needs: validate
+  code_gitee:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v6
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: Yikun/hub-mirror-action@master
+        with:
+          src: github/whyour
+          dst: gitee/whyour
+          dst_key: ${{ secrets.GITLAB_SSH_PK }}
+          dst_token: ${{ secrets.GITEE_TOKEN }}
+          static_list: "qinglong"
+          force_update: true
+
+  build-static:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
        with:
          version: "8.3.1"

-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@v4
        with:
-          node-version-file: ".nvmrc"
          cache: "pnpm"
-          cache-dependency-path: pnpm-lock.yaml

      - name: build front and back
        run: |
          pnpm install --frozen-lockfile
          pnpm build:front
          pnpm build:back
-          pnpm build:info
-
-      - name: Pack the npm panel archive from the verified build
-        run: node scripts/verify-panel-package.cjs pack "$RUNNER_TEMP/npm-panel"
-
-      - uses: actions/upload-artifact@v6
-        with:
-          name: qinglong-static-${{ github.sha }}
-          path: static/
-          if-no-files-found: error
-          include-hidden-files: true
-
-      - uses: actions/upload-artifact@v6
-        with:
-          name: qinglong-npm-${{ github.sha }}
-          path: ${{ runner.temp }}/npm-panel/
-          if-no-files-found: error
-          retention-days: 14

      - name: copy to static repo
        env:
          GITHUB_REPO: github.com/${{ github.repository_owner }}/qinglong-static
          GITHUB_BRANCH: ${{ github.ref_name }}
-          GITHUB_REF_TYPE: ${{ github.ref_type }}
-          STATIC_TOKEN: ${{ secrets.API_TOKEN }}
+          REPO_GITEE: git@gitee.com:whyour/qinglong-static.git
+          REPO_GITLAB: git@gitlab.com:whyour/qinglong-static.git
+          PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PK }}
        run: |
-          : "${STATIC_TOKEN:?Missing static repository token}"
-          bash scripts/publish-static.sh "https://x-access-token:${STATIC_TOKEN}@${GITHUB_REPO}.git" "$GITHUB_BRANCH" "$GITHUB_REF_TYPE"
-
-      - name: publish verified upgrade download sizes
-        env:
-          GITHUB_REPO: github.com/${{ github.repository_owner }}/qinglong-static
-          GITHUB_BRANCH: ${{ github.ref_name }}
-          STATIC_TOKEN: ${{ secrets.API_TOKEN }}
-        run: |
-          : "${STATIC_TOKEN:?Missing static repository token}"
-          node scripts/publish-upgrade-info.cjs "https://x-access-token:${STATIC_TOKEN}@${GITHUB_REPO}.git" "$GITHUB_BRANCH" "$GITHUB_SHA"
+          mkdir -p tmp
+          cd ./tmp
+          cp -rf ../static/* ./
+          git init -b ${GITHUB_BRANCH} && git add .
+          git config --local user.name 'github-actions[bot]'
+          git config --local user.email 'github-actions[bot]@users.noreply.github.com'
+          git commit --allow-empty -m "copy static at $(date +'%Y-%m-%d %H:%M:%S')"
+          git push --force --quiet "https://${{ secrets.API_TOKEN }}@${GITHUB_REPO}.git" ${GITHUB_BRANCH}:${GITHUB_BRANCH}

  static_gitlab:
    needs: build-static
    runs-on: ubuntu-latest
-    concurrency:
-      group: static-gitlab-${{ github.ref_name }}
-      cancel-in-progress: false
    steps:
-      - uses: actions/checkout@v6
-      - name: Push qinglong-static to GitLab
-        env:
-          STATIC_BRANCH: ${{ github.ref_name }}
-          STATIC_REF_TYPE: ${{ github.ref_type }}
-          MIRROR_SSH_KEY: ${{ secrets.GITLAB_SSH_PK }}
-        run: |
-          set -euo pipefail
-          mkdir -p ~/.ssh
-          printf '%s\n' "$MIRROR_SSH_KEY" > ~/.ssh/id_rsa
-          chmod 600 ~/.ssh/id_rsa
-          ssh-keyscan -T 10 gitlab.com >> ~/.ssh/known_hosts 2>/dev/null
-          bash scripts/sync-static.sh git@gitlab.com:whyour/qinglong-static.git "$STATIC_BRANCH" "$STATIC_REF_TYPE"
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: Yikun/hub-mirror-action@master
+        with:
+          src: github/whyour
+          dst: gitlab/whyour
+          dst_key: ${{ secrets.GITLAB_SSH_PK }}
+          dst_token: ${{ secrets.GITLAB_TOKEN }}
+          static_list: "qinglong-static"
+          force_update: true

-  verify-gitee-mirrors:
+  static_gitee:
    needs: build-static
    runs-on: ubuntu-latest
-    timeout-minutes: 14
-    permissions:
-      contents: write
-    strategy:
-      fail-fast: false
-      matrix:
-        repository: [qinglong, qinglong-static]
    steps:
-      - uses: actions/checkout@v6
-      # Gitee Pull mirrors and GitHub push webhooks own synchronization.
-      # Verification runs alongside Docker builds and needs no Gitee credentials.
-      - name: Wait for Gitee Pull mirror
-        if: ${{ matrix.repository == 'qinglong' }}
-        env:
-          GH_TOKEN: ${{ github.token }}
-          QL_MIRROR_NOTIFY_REPO: whyour/qinglong
-          MIRROR_REPOSITORY: ${{ matrix.repository }}
-          MIRROR_REF: ${{ github.ref_name }}
-          MIRROR_REF_TYPE: ${{ github.ref_type }}
-          QL_MIRROR_INCLUDE_VERSION_BRANCH: ${{ matrix.repository == 'qinglong-static' }}
-          QL_MIRROR_NOTIFY_ON_START: 'false'
-        run: |
-          bash scripts/wait-for-mirror.sh "https://github.com/whyour/$MIRROR_REPOSITORY.git" "https://gitee.com/whyour/$MIRROR_REPOSITORY.git" "$MIRROR_REF" "$MIRROR_REF_TYPE"
-      - name: Notify and wait for Gitee static mirror
-        if: ${{ matrix.repository == 'qinglong-static' }}
-        env:
-          GH_TOKEN: ${{ secrets.API_TOKEN }}
-          QL_MIRROR_NOTIFY_REPO: whyour/qinglong-static
-          MIRROR_REF: ${{ github.ref_name }}
-          MIRROR_REF_TYPE: ${{ github.ref_type }}
-          QL_MIRROR_INCLUDE_VERSION_BRANCH: 'true'
-        run: |
-          bash scripts/wait-for-mirror.sh https://github.com/whyour/qinglong-static.git https://gitee.com/whyour/qinglong-static.git "$MIRROR_REF" "$MIRROR_REF_TYPE"
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: Yikun/hub-mirror-action@master
+        with:
+          src: github/whyour
+          dst: gitee/whyour
+          dst_key: ${{ secrets.GITLAB_SSH_PK }}
+          dst_token: ${{ secrets.GITEE_TOKEN }}
+          static_list: "qinglong-static"
+          force_update: true

-  sync-existing-static:
-    if: ${{ github.event_name == 'workflow_dispatch' && inputs.static_sync_only }}
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        mirror: [gitlab]
-    concurrency:
-      group: static-${{ matrix.mirror }}-${{ inputs.static_ref }}
-      cancel-in-progress: false
-    steps:
-      - uses: actions/checkout@v6
-      - name: Synchronize existing static snapshot
-        env:
-          STATIC_REF: ${{ inputs.static_ref }}
-          STATIC_REF_TYPE: ${{ inputs.static_ref_type }}
-          MIRROR_HOST: ${{ matrix.mirror }}.com
-          MIRROR_SSH_KEY: ${{ secrets.GITLAB_SSH_PK }}
-        run: |
-          set -euo pipefail
-          mkdir -p ~/.ssh
-          printf '%s\n' "$MIRROR_SSH_KEY" > ~/.ssh/id_rsa
-          chmod 600 ~/.ssh/id_rsa
-          ssh-keyscan -T 10 "$MIRROR_HOST" >> ~/.ssh/known_hosts 2>/dev/null
-          bash scripts/sync-static.sh "git@$MIRROR_HOST:whyour/qinglong-static.git" "$STATIC_REF" "$STATIC_REF_TYPE"
-
-  verify-existing-static-gitee:
-    if: ${{ github.event_name == 'workflow_dispatch' && inputs.static_sync_only }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 14
-    steps:
-      - uses: actions/checkout@v6
-      - name: Wait for existing Gitee static snapshot
-        env:
-          GH_TOKEN: ${{ secrets.API_TOKEN }}
-          QL_MIRROR_NOTIFY_REPO: whyour/qinglong-static
-          MIRROR_REF: ${{ inputs.static_ref }}
-          MIRROR_REF_TYPE: ${{ inputs.static_ref_type }}
-          QL_MIRROR_INCLUDE_VERSION_BRANCH: 'true'
-        run: |
-          bash scripts/wait-for-mirror.sh https://github.com/whyour/qinglong-static.git https://gitee.com/whyour/qinglong-static.git "$MIRROR_REF" "$MIRROR_REF_TYPE"
-
-  build-alpine:
-    if: ${{ !startsWith(github.ref, 'refs/tags/') }}
+  build:
    needs: build-static
-    outputs:
-      image-digest: ${{ steps.image.outputs.digest }}
+
    runs-on: ubuntu-22.04
+
    permissions:
      packages: write
      contents: read
+
    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/download-artifact@v7
-        with:
-          name: qinglong-static-${{ github.sha }}
-          path: static/
-      - uses: pnpm/action-setup@v6
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
        with:
          version: "8.3.1"
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@v4
        with:
-          node-version: "20"
          cache: "pnpm"
-          cache-dependency-path: pnpm-lock.yaml

      - name: Read version from version.yaml
        id: version
        run: |
          VERSION=$(grep '^version:' version.yaml | awk '{print $2}')
          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Version: $VERSION"

      - name: Setup timezone
-        run: sudo timedatectl set-timezone Asia/Shanghai
+        uses: szenius/set-timezone@v2.0
+        with:
+          timezoneLinux: Asia/Shanghai

      - name: Login to DockerHub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Login to GHCR
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
@@ -275,7 +158,7 @@ jobs:

      - name: Extract metadata (tags, labels) for Docker
        id: meta
-        uses: docker/metadata-action@v6
+        uses: docker/metadata-action@v5
        with:
          images: |
            ${{ github.repository }}
@@ -283,471 +166,134 @@ jobs:
          flavor: |
            latest=false
          tags: |
-            type=ref,event=branch,enable=${{ github.ref == format('refs/heads/{0}', 'develop') }}
+            type=ref,event=branch,enable=${{ github.ref == format('refs/heads/{0}', 'debian-dev') }}
            type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'master') }}
-            type=raw,value=${{ steps.version.outputs.version }},enable=${{ github.ref == format('refs/heads/{0}', 'master') }}
+            type=raw,value=${{ steps.version.outputs.version }}-debian,enable=${{ github.ref == format('refs/heads/{0}', 'debian') }}
            type=semver,pattern={{version}}

      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
+        uses: docker/setup-qemu-action@v3

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3

-      - name: Build and push (Alpine)
-        id: image
-        uses: docker/build-push-action@v7
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v6
        with:
          build-args: |
-            QL_MAINTAINER=${{ github.repository_owner }}
+            MAINTAINER=${{ github.repository_owner }}
            QL_BRANCH=${{ github.ref_name }}
            SOURCE_COMMIT=${{ github.sha }}
          network: host
-          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386
+          platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
          context: .
          file: ./docker/Dockerfile
          push: true
-          provenance: mode=max
-          sbom: true
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=registry,ref=whyour/qinglong:cache-alpine
-          cache-to: type=registry,ref=whyour/qinglong:cache-alpine,mode=max
-
-  build-debian:
-    if: ${{ !startsWith(github.ref, 'refs/tags/') }}
-    needs: build-static
-    outputs:
-      image-digest: ${{ steps.image.outputs.digest }}
-    runs-on: ubuntu-22.04
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/download-artifact@v7
-        with:
-          name: qinglong-static-${{ github.sha }}
-          path: static/
-      - uses: pnpm/action-setup@v6
-        with:
-          version: "8.3.1"
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "20"
-          cache: "pnpm"
-          cache-dependency-path: pnpm-lock.yaml
-
-      - name: Read version from version.yaml
-        id: version
-        run: |
-          VERSION=$(grep '^version:' version.yaml | awk '{print $2}')
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-
-      - name: Setup timezone
-        run: sudo timedatectl set-timezone Asia/Shanghai
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v4
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Login to GHCR
-        uses: docker/login-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata (tags, labels) for Docker
-        id: meta
-        uses: docker/metadata-action@v6
-        with:
-          images: |
-            ${{ github.repository }}
-            ghcr.io/${{ github.repository }}
-          flavor: |
-            latest=false
-          tags: |
-            type=raw,value=debian-dev,enable=${{ github.ref == format('refs/heads/{0}', 'develop') }}
-            type=raw,value=debian,enable=${{ github.ref == format('refs/heads/{0}', 'master') }}
-            type=raw,value=${{ steps.version.outputs.version }}-debian,enable=${{ github.ref == format('refs/heads/{0}', 'master') }}
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-
-      - name: Build and push (Debian)
-        id: image
-        uses: docker/build-push-action@v7
-        with:
-          build-args: |
-            QL_MAINTAINER=${{ github.repository_owner }}
-            QL_BRANCH=${{ github.ref_name }}
-            SOURCE_COMMIT=${{ github.sha }}
-          network: host
-          # Keep s390x on Debian: npm can hang under QEMU with Alpine (nodejs/docker-node#1973).
-          platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
-          context: .
-          file: ./docker/Dockerfile.debian
-          push: true
-          provenance: mode=max
-          sbom: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=registry,ref=whyour/qinglong:cache-debian
          cache-to: type=registry,ref=whyour/qinglong:cache-debian,mode=max

-  build-alpine310:
-    if: ${{ github.ref_name == 'master' }}
+      - name: Image digest
+        run: |
+          echo ${{ steps.docker_build.outputs.digest }}
+
+  build310:
+    if: ${{ github.ref_name == 'debian' }}
    needs: build-static
+
    runs-on: ubuntu-22.04
+
    permissions:
      packages: write
      contents: read
+
    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/download-artifact@v7
-        with:
-          name: qinglong-static-${{ github.sha }}
-          path: static/
-      - uses: pnpm/action-setup@v6
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
        with:
          version: "8.3.1"
-      - uses: actions/setup-node@v6
+      - uses: actions/setup-node@v4
        with:
-          node-version: "20"
          cache: "pnpm"
-          cache-dependency-path: pnpm-lock.yaml

      - name: Read version from version.yaml
        id: version
        run: |
          VERSION=$(grep '^version:' version.yaml | awk '{print $2}')
          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Version: $VERSION"

      - name: Setup timezone
-        run: sudo timedatectl set-timezone Asia/Shanghai
+        uses: szenius/set-timezone@v2.0
+        with:
+          timezoneLinux: Asia/Shanghai

      - name: Login to DockerHub
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}

      - name: Login to GHCR
-        uses: docker/login-action@v4
+        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.repository_owner }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
+        uses: docker/setup-qemu-action@v3

      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
+        uses: docker/setup-buildx-action@v3

-      - name: Build and push (Alpine Python 3.10)
-        uses: docker/build-push-action@v7
+      - name: Build and push python3.10
+        id: docker_build_310
+        uses: docker/build-push-action@v6
        with:
          build-args: |
-            QL_MAINTAINER=${{ github.repository_owner }}
+            MAINTAINER=${{ github.repository_owner }}
            QL_BRANCH=${{ github.ref_name }}
            SOURCE_COMMIT=${{ github.sha }}
          network: host
-          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386
-          context: .
-          file: ./docker/Dockerfile.310
-          push: true
-          provenance: mode=max
-          sbom: true
-          tags: |
-            whyour/qinglong:python3.10
-            whyour/qinglong:${{ steps.version.outputs.version }}-python3.10
-          cache-from: type=registry,ref=whyour/qinglong:cache-alpine-python3.10
-          cache-to: type=registry,ref=whyour/qinglong:cache-alpine-python3.10,mode=max
-
-  build-debian310:
-    if: ${{ github.ref_name == 'master' }}
-    needs: build-static
-    runs-on: ubuntu-22.04
-    permissions:
-      packages: write
-      contents: read
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/download-artifact@v7
-        with:
-          name: qinglong-static-${{ github.sha }}
-          path: static/
-      - uses: pnpm/action-setup@v6
-        with:
-          version: "8.3.1"
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "20"
-          cache: "pnpm"
-          cache-dependency-path: pnpm-lock.yaml
-
-      - name: Read version from version.yaml
-        id: version
-        run: |
-          VERSION=$(grep '^version:' version.yaml | awk '{print $2}')
-          echo "version=$VERSION" >> $GITHUB_OUTPUT
-
-      - name: Setup timezone
-        run: sudo timedatectl set-timezone Asia/Shanghai
-
-      - name: Login to DockerHub
-        uses: docker/login-action@v4
-        with:
-          username: ${{ secrets.DOCKER_USERNAME }}
-          password: ${{ secrets.DOCKER_PASSWORD }}
-
-      - name: Login to GHCR
-        uses: docker/login-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-
-      - name: Build and push (Debian Python 3.10)
-        uses: docker/build-push-action@v7
-        with:
-          build-args: |
-            QL_MAINTAINER=${{ github.repository_owner }}
-            QL_BRANCH=${{ github.ref_name }}
-            SOURCE_COMMIT=${{ github.sha }}
-          network: host
-          # Keep s390x on Debian: npm can hang under QEMU with Alpine (nodejs/docker-node#1973).
          platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
          context: .
-          file: ./docker/Dockerfile.debian310
+          file: ./docker/310.Dockerfile
          push: true
-          provenance: mode=max
-          sbom: true
          tags: |
            whyour/qinglong:debian-python3.10
            whyour/qinglong:${{ steps.version.outputs.version }}-debian-python3.10
          cache-from: type=registry,ref=whyour/qinglong:cache-debian-python3.10
          cache-to: type=registry,ref=whyour/qinglong:cache-debian-python3.10,mode=max

-  # Unmodified amd64 packages for glibc and musl migration acceptance. This does not
-  # publish bundles or advance development/formal channel indexes.
-  build-npm-migration-bundle:
-    needs: [build-debian, build-alpine]
-    strategy:
-      fail-fast: false
-      matrix:
-        libc: [glibc, musl]
-    runs-on: ubuntu-latest
-    timeout-minutes: 20
-    steps:
-      - uses: actions/checkout@v6
-      - uses: docker/setup-buildx-action@v4
-      - name: Export the official platform package from this run's image digest
-        env:
-          IMAGE_DIGEST: ${{ matrix.libc == 'musl' && needs.build-alpine.outputs.image-digest || needs.build-debian.outputs.image-digest }}
+      - name: Image digest
        run: |
-          set -euo pipefail
-          [[ "$IMAGE_DIGEST" =~ ^sha256:[a-f0-9]{64}$ ]]
-          image="ghcr.io/${GITHUB_REPOSITORY}@${IMAGE_DIGEST}"
-          docker buildx build --platform linux/amd64 --build-arg "BASE_IMAGE=$image" --file docker/Dockerfile.upgrade-bundle --output "type=local,dest=$RUNNER_TEMP/npm-migration-bundle" .
-      - uses: actions/upload-artifact@v6
-        with:
-          name: npm-migration-bundle-${{ matrix.libc }}-${{ github.sha }}
-          path: ${{ runner.temp }}/npm-migration-bundle/*
-          if-no-files-found: error
-          retention-days: 3
-
-  verify-npm-package:
-    needs: [build-static, build-npm-migration-bundle, build-alpine]
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    strategy:
-      fail-fast: false
-      matrix:
-        node: ['20.18.1', '22.17.0', '24', 'alpine']
-    container:
-      image: ${{ matrix.node == 'alpine' && format('ghcr.io/{0}@{1}', github.repository, needs.build-alpine.outputs.image-digest) || format('node:{0}-bookworm', matrix.node) }}
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/download-artifact@v6
-        with:
-          name: qinglong-npm-${{ github.sha }}
-          path: ${{ runner.temp }}/npm-panel/
-      - uses: actions/download-artifact@v6
-        with:
-          name: npm-migration-bundle-${{ matrix.node == 'alpine' && 'musl' || 'glibc' }}-${{ github.sha }}
-          path: ${{ runner.temp }}/npm-migration-bundle/
-      - name: Install isolated service test tools
-        run: |
-          if [ -f /etc/alpine-release ]; then
-            apk add --no-cache python3 openssl curl jq nginx procps make g++
-          else
-            apt-get update
-            apt-get install -y --no-install-recommends python3 openssl curl jq nginx procps
-          fi
-          # The published legacy launcher resets PATH to standard directories.
-          # /usr/local is confined to this disposable job container; PM2_HOME
-          # remains private to each verification run.
-          npm install --global --prefix /usr/local --no-audit --no-fund pm2@6.0.14
-      - name: Install and upgrade the exact npm archive
-        if: matrix.node != '20.18.1'
-        env:
-          QL_PANEL_PACKAGE_TEST_ISOLATED: '1'
-          QL_PANEL_TEST_PM2: /usr/local/bin/pm2
-          QL_PANEL_TEST_BUNDLE_DIR: ${{ runner.temp }}/npm-migration-bundle
-        run: node scripts/verify-panel-package.cjs verify "$RUNNER_TEMP/npm-panel" "$RUNNER_TEMP/npm-panel-results"
-      - name: Reject an unsupported runtime while preserving the old installation
-        if: matrix.node == '20.18.1'
-        run: node scripts/verify-panel-runtime-floor.cjs "$RUNNER_TEMP/npm-panel" "$RUNNER_TEMP/npm-panel-results"
-      - uses: actions/upload-artifact@v6
-        with:
-          name: qinglong-npm-verification-${{ matrix.node }}-${{ github.sha }}
-          path: ${{ runner.temp }}/npm-panel-results/
-          if-no-files-found: error
-          retention-days: 14
+          echo ${{ steps.docker_build_310.outputs.digest }}

  publish:
-    if: ${{ github.repository == 'whyour/qinglong' && github.ref == 'refs/heads/master' }}
-    needs: [build-alpine, build-debian, build-alpine310, build-debian310, verify-npm-package]
+    if: ${{ github.ref_name == 'debian' }}
+    needs: build
+
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
    steps:
-      - name: Set up Node for trusted publishing
-        uses: actions/setup-node@v6
+      - uses: actions/checkout@v4
+      - uses: pnpm/action-setup@v3
        with:
-          node-version: '24'
-          registry-url: https://registry.npmjs.org
-          package-manager-cache: false
+          version: "8.3.1"

-      - uses: actions/download-artifact@v6
+      - uses: actions/setup-node@v3
        with:
-          name: qinglong-npm-${{ github.sha }}
-          path: npm-panel/
+          cache: "pnpm"

-      - name: Publish npm package with OIDC
-        shell: bash
+      - name: build front and back
        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          archives=(npm-panel/*.tgz)
-          if [ "${#archives[@]}" -ne 1 ]; then
-            echo '::error::Expected exactly one verified panel npm archive.'
-            exit 1
-          fi
-          archive="${archives[0]}"
-          metadata=$(tar -xOf "$archive" package/package.json)
-          name=$(jq -er '.name | select(. == "@whyour/qinglong")' <<< "$metadata")
-          version=$(jq -er '.version | select(type == "string")' <<< "$metadata")
-          if npm view "$name@$version" version --json --registry=https://registry.npmjs.org > "$RUNNER_TEMP/npm-version.json" 2> "$RUNNER_TEMP/npm-version-error.log"; then
-            jq -e --arg version "$version" '. == $version' "$RUNNER_TEMP/npm-version.json" > /dev/null
-            echo "::notice::$name@$version is already published; skipping npm publication for this image rebuild."
-          elif jq -e '.error.code == "E404"' "$RUNNER_TEMP/npm-version.json" > /dev/null; then
-            npm publish "$archive" --ignore-scripts --access public --registry=https://registry.npmjs.org
-          else
-            echo '::error::Could not check the published npm version; refusing to publish.'
-            exit 1
-          fi
+          pnpm install --frozen-lockfile
+          pnpm build:front
+          pnpm build:back

-  build-upgrade-bundles:
-    # Both channels publish packages from this run's immutable image digests.
-    if: ${{ !inputs.static_sync_only && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop') }}
-    needs: [build-alpine, build-debian]
-    runs-on: ubuntu-22.04
-    timeout-minutes: 90
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { platform: linux/amd64, libc: musl, name: x64-musl }
-          - { platform: linux/arm/v6, libc: musl, name: armv6-musl }
-          - { platform: linux/arm/v7, libc: musl, name: armv7-musl }
-          - { platform: linux/arm64, libc: musl, name: arm64-musl }
-          - { platform: linux/ppc64le, libc: musl, name: ppc64-musl }
-          - { platform: linux/s390x, libc: musl, name: s390x-musl }
-          - { platform: linux/386, libc: musl, name: ia32-musl }
-          - { platform: linux/amd64, libc: glibc, name: x64-glibc }
-          - { platform: linux/arm/v7, libc: glibc, name: armv7-glibc }
-          - { platform: linux/arm64, libc: glibc, name: arm64-glibc }
-          - { platform: linux/ppc64le, libc: glibc, name: ppc64-glibc }
-          - { platform: linux/s390x, libc: glibc, name: s390x-glibc }
-    steps:
-      - uses: actions/checkout@v6
-      - uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
-      - uses: docker/setup-buildx-action@v4
-      - name: Build and probe the immutable platform package
-        env:
-          ALPINE_DIGEST: ${{ needs.build-alpine.outputs.image-digest }}
-          DEBIAN_DIGEST: ${{ needs.build-debian.outputs.image-digest }}
-          BUNDLE_LIBC: ${{ matrix.libc }}
-          BUNDLE_PLATFORM: ${{ matrix.platform }}
+      - name: publich npm package
        run: |
-          set -euo pipefail
-          digest="$ALPINE_DIGEST"
-          if [ "$BUNDLE_LIBC" = glibc ]; then digest="$DEBIAN_DIGEST"; fi
-          test -n "$digest"
-          image="ghcr.io/${GITHUB_REPOSITORY}@${digest}"
-          legacy=$(node -p "require('./docker/migration-bridge-images.json')['$BUNDLE_LIBC']")
-          docker buildx build --platform "$BUNDLE_PLATFORM" --build-arg "BASE_IMAGE=$image" --build-arg "LEGACY_IMAGE=$legacy" --file docker/Dockerfile.upgrade-bridge --output type=local,dest=output/upgrade .
-      - uses: actions/upload-artifact@v6
-        with:
-          name: upgrade-${{ matrix.name }}-${{ github.sha }}
-          path: output/upgrade/*
-          if-no-files-found: error
-
-  publish-upgrade-bundles:
-    if: ${{ !inputs.static_sync_only && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/develop') }}
-    needs: build-upgrade-bundles
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    concurrency:
-      group: upgrade-channel-${{ github.ref_name }}
-      cancel-in-progress: false
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '24'
-      - uses: pnpm/action-setup@v6
-        with:
-          version: '8.3.1'
-      - run: pnpm install --prod --frozen-lockfile
-      - run: npm --prefix cli ci
-      - uses: actions/download-artifact@v7
-        with:
-          pattern: upgrade-*-${{ github.sha }}
-          path: output/upgrade
-          merge-multiple: true
-      - run: node scripts/build-bundle-installer.cjs output/upgrade/install-bundle.cjs
-      - name: Publish complete packages before advancing the channel
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: node scripts/publish-upgrade-bundles.cjs output/upgrade "$GITHUB_SHA" "$GITHUB_REPOSITORY" "$GITHUB_REF_NAME"
+          echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" >> ~/.npmrc
+          npm publish
@@ -1,161 +0,0 @@
-name: CLI package
-
-on:
-  pull_request:
-    paths:
-      - 'cli/**'
-      - 'shell/**'
-      - 'back/api/**'
-      - 'back/loaders/deps.ts'
-      - 'package.json'
-      - '.github/workflows/cli-package.yml'
-  push:
-    branches: [develop, master]
-    paths:
-      - 'cli/**'
-      - 'shell/**'
-      - 'back/api/**'
-      - 'back/loaders/deps.ts'
-      - 'package.json'
-      - '.github/workflows/cli-package.yml'
-  workflow_dispatch:
-    inputs:
-      publish:
-        description: Publish the verified CLI package (master stable / develop prerelease)
-        type: boolean
-        default: false
-      prerelease_version:
-        description: Develop only, e.g. 0.1.2-beta.0 (alpha/beta/rc)
-        type: string
-        default: ''
-
-permissions:
-  contents: read
-
-concurrency:
-  # Keep validation runs separate from releases; never interrupt a running release.
-  # Master push releases share the same group as manually requested releases.
-  group: >-
-    cli-package-${{ github.workflow }}-${{ github.ref }}-${{
-      ((github.event_name == 'workflow_dispatch' && inputs.publish) ||
-       (github.event_name == 'push' && github.ref == 'refs/heads/master')) && 'publish' || 'check' }}
-  cancel-in-progress: >-
-    ${{ github.ref != 'refs/heads/master' &&
-        !(github.event_name == 'workflow_dispatch' && inputs.publish) }}
-
-jobs:
-  package:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    strategy:
-      fail-fast: false
-      matrix:
-        node: ['22.12.0', '24']
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node }}
-          cache: npm
-          cache-dependency-path: cli/package-lock.json
-      - name: Install test interpreters and tools
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends bash ca-certificates curl git jq perl procps python3 unzip zip
-          npm install --global --ignore-scripts --no-audit --no-fund ts-node@10.9.2 typescript@5.2.2
-      - name: Set requested prerelease version before verification
-        if: github.event_name == 'workflow_dispatch' && inputs.prerelease_version != ''
-        working-directory: cli
-        env:
-          PRERELEASE_VERSION: ${{ inputs.prerelease_version }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          if [[ "$GITHUB_REF" != refs/heads/develop ||
-                ! "$PRERELEASE_VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+-(alpha|beta|rc)\.[0-9]+$ ]]; then
-            echo '::error::Prereleases require develop and an explicit alpha/beta/rc version.'
-            exit 1
-          fi
-          npm version "$PRERELEASE_VERSION" --no-git-tag-version --ignore-scripts
-      - run: npm ci --prefix cli --no-audit --no-fund
-      - run: npm run check:cli
-      - run: npm run test:cli
-      - name: Verify offline package installation
-        env:
-          QL_CLI_PACKAGE_OUTPUT: ${{ runner.temp }}/cli-package
-        run: node cli/scripts/verify-package.cjs
-      - name: Upload verified npm archive
-        if: matrix.node == '24'
-        uses: actions/upload-artifact@v6
-        with:
-          name: qinglong-cli-${{ github.sha }}
-          path: ${{ runner.temp }}/cli-package/*.tgz
-          if-no-files-found: error
-          retention-days: 14
-
-  publish:
-    needs: package
-    if: >-
-      github.repository == 'whyour/qinglong' &&
-      ((github.ref == 'refs/heads/master' &&
-        (github.event_name == 'push' ||
-         (github.event_name == 'workflow_dispatch' && inputs.publish))) ||
-       (github.ref == 'refs/heads/develop' && github.event_name == 'workflow_dispatch' &&
-        inputs.publish && inputs.prerelease_version != ''))
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '24'
-          package-manager-cache: false
-          registry-url: https://registry.npmjs.org
-      - uses: actions/download-artifact@v7
-        with:
-          name: qinglong-cli-${{ github.sha }}
-          path: cli-package
-      - name: Publish verified npm archive
-        env:
-          PRERELEASE_VERSION: ${{ inputs.prerelease_version }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          archives=(cli-package/*.tgz)
-          if [ "${#archives[@]}" -ne 1 ]; then
-            echo '::error::Expected exactly one verified CLI archive.'
-            exit 1
-          fi
-          archive="${archives[0]}"
-          metadata=$(tar -xOf "$archive" package/package.json)
-          name=$(jq -er '.name | select(. == "@whyour/qinglong-cli")' <<< "$metadata")
-          version=$(jq -er '.version | select(type == "string")' <<< "$metadata")
-          if [[ "$GITHUB_REF" == refs/heads/develop ]]; then
-            if [[ "$version" != "$PRERELEASE_VERSION" ||
-                  ! "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+-(alpha|beta|rc)\.[0-9]+$ ]]; then
-              echo '::error::Archive version does not match the requested prerelease.'
-              exit 1
-            fi
-            tag="${BASH_REMATCH[1]}"
-          elif [[ "$GITHUB_REF" == refs/heads/master && "$version" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            tag=latest
-          else
-            echo '::error::Refusing to publish this branch/version combination.'
-            exit 1
-          fi
-          if npm view "$name@$version" version --json --registry=https://registry.npmjs.org > version.json 2> version-error.log; then
-            jq -e --arg version "$version" '. == $version' version.json > /dev/null
-            if [[ "$tag" != latest ]]; then
-              echo '::error::Prerelease version already exists; choose a new version to test this build.'
-              exit 1
-            fi
-            echo "::notice::$name@$version is already published; bump cli/package.json and its lockfile to release changes."
-            exit 0
-          elif ! jq -e '.error.code == "E404"' version.json > /dev/null; then
-            echo '::error::Could not check the published CLI version; refusing to publish.'
-            exit 1
-          fi
-          npm publish "./$archive" --access public --tag "$tag" --ignore-scripts --registry=https://registry.npmjs.org
@@ -1,136 +0,0 @@
-name: Release readiness
-
-on:
-  pull_request:
-    paths:
-      - '.github/workflows/release-readiness.yml'
-      - 'package.json'
-      - 'pnpm-lock.yaml'
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: release-readiness-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  regression:
-    uses: ./.github/workflows/validate.yml
-
-  static:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ github.event.pull_request.head.sha || github.sha }}
-      - uses: pnpm/action-setup@v6
-        with:
-          version: '8.3.1'
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '22'
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: pnpm build:front && pnpm build:back && pnpm build:info
-      - uses: actions/upload-artifact@v6
-        with:
-          name: release-readiness-static
-          path: static/
-          include-hidden-files: true
-          if-no-files-found: error
-
-  images:
-    needs: [regression, static]
-    runs-on: ubuntu-22.04
-    timeout-minutes: 60
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - image: alpine
-            file: docker/Dockerfile
-            cache: alpine
-            platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386
-          - image: debian
-            file: docker/Dockerfile.debian
-            cache: debian
-            platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
-          - image: alpine-python3.10
-            file: docker/Dockerfile.310
-            cache: alpine-python3.10
-            platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386
-          - image: debian-python3.10
-            file: docker/Dockerfile.debian310
-            cache: debian-python3.10
-            platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ github.event.pull_request.head.sha || github.sha }}
-      - name: Record source
-        id: source
-        env:
-          SOURCE_URL: ${{ github.event.pull_request.head.repo.clone_url || format('https://github.com/{0}.git', github.repository) }}
-          SOURCE_BRANCH: ${{ github.head_ref || github.ref_name }}
-        run: |
-          echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT"
-          echo "url=$SOURCE_URL" >> "$GITHUB_OUTPUT"
-          echo "branch=$SOURCE_BRANCH" >> "$GITHUB_OUTPUT"
-      - uses: actions/download-artifact@v7
-        with:
-          name: release-readiness-static
-          path: static/
-      - uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
-      - uses: docker/setup-buildx-action@v4
-      - name: Build every release architecture
-        uses: docker/build-push-action@v7
-        with:
-          context: .
-          file: ${{ matrix.file }}
-          platforms: ${{ matrix.platforms }}
-          build-args: |
-            QL_URL=${{ steps.source.outputs.url }}
-            QL_BRANCH=${{ steps.source.outputs.branch }}
-            SOURCE_COMMIT=${{ steps.source.outputs.sha }}
-          push: false
-          provenance: false
-          sbom: false
-          cache-from: type=registry,ref=whyour/qinglong:cache-${{ matrix.cache }}
-      - name: Load native image for runtime verification
-        uses: docker/build-push-action@v7
-        with:
-          context: .
-          file: ${{ matrix.file }}
-          platforms: linux/amd64
-          build-args: |
-            QL_URL=${{ steps.source.outputs.url }}
-            QL_BRANCH=${{ steps.source.outputs.branch }}
-            SOURCE_COMMIT=${{ steps.source.outputs.sha }}
-          tags: qinglong-readiness:${{ matrix.image }}
-          load: true
-          push: false
-          provenance: false
-          sbom: false
-      - name: Verify native production runtime without external networking
-        run: |
-          docker run --rm --network none --entrypoint node \
-            qinglong-readiness:${{ matrix.image }} \
-            -e 'const assert=require("node:assert/strict"); const {createRequire}=require("node:module"); for(const [name,want] of Object.entries({"@grpc/grpc-js":"1.14.5",compression:"1.8.2",multer:"2.4.0"}))assert.equal(require(name+"/package.json").version,want); const expressRequire=createRequire(require.resolve("express")); assert.equal(expressRequire("proxy-addr/package.json").version,"2.0.8"); const sockRequire=createRequire(require.resolve("sockjs")); assert.equal(sockRequire("websocket-driver/package.json").version,"0.7.5"); assert.equal(typeof require("@mikro-orm/sql").NodeSqliteDialect,"function"); const db=new (require("node:sqlite").DatabaseSync)(":memory:"); assert.equal(db.prepare("SELECT 42 AS value").get().value,42); db.close(); require("nodemailer"); require("undici"); console.log("Minimal production patches and runtime imports verified")'
-      - name: Export native Debian image for isolated dev validation
-        if: matrix.image == 'debian'
-        run: |
-          docker save qinglong-readiness:debian | gzip -1 > release-readiness-debian-image.tar.gz
-          sha256sum release-readiness-debian-image.tar.gz > release-readiness-debian-image.sha256
-          docker image inspect qinglong-readiness:debian > release-readiness-debian-image.json
-      - uses: actions/upload-artifact@v6
-        if: matrix.image == 'debian'
-        with:
-          name: release-readiness-debian-image
-          path: release-readiness-debian-image.*
-          compression-level: 0
-          if-no-files-found: error
@@ -1,201 +0,0 @@
-name: SQLite migration candidate
-
-on:
-  pull_request:
-    branches: [develop]
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-concurrency:
-  group: sqlite-migration-candidate-${{ github.event.pull_request.number || github.ref }}
-  cancel-in-progress: true
-
-env:
-  SOURCE_COMMIT: ${{ github.event.pull_request.head.sha || github.sha }}
-
-jobs:
-  build-static:
-    if: ${{ (github.event_name == 'pull_request' && github.head_ref == 'codex/sqlite-runtime-migration' && github.event.pull_request.head.repo.full_name == github.repository) || (github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/codex/sqlite-runtime-migration') }}
-    runs-on: ubuntu-latest
-    timeout-minutes: 25
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ env.SOURCE_COMMIT }}
-      - uses: pnpm/action-setup@v6
-        with:
-          version: '8.3.1'
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '22.17.0'
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: cp .env.example .env
-      - run: npm test
-      - run: npm run build:front && npm run build:back && npm run build:info
-      - uses: actions/upload-artifact@v6
-        with:
-          name: migration-static-${{ env.SOURCE_COMMIT }}
-          path: static/
-          include-hidden-files: true
-          if-no-files-found: error
-          retention-days: 7
-
-  test-node24:
-    needs: build-static
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ env.SOURCE_COMMIT }}
-      - uses: pnpm/action-setup@v6
-        with:
-          version: '8.3.1'
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '24'
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: cp .env.example .env
-      - run: npm test
-
-  build-images:
-    needs: build-static
-    runs-on: ubuntu-22.04
-    timeout-minutes: 90
-    permissions:
-      contents: read
-      packages: write
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - libc: musl
-            file: docker/Dockerfile
-            platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386
-          - libc: glibc
-            file: docker/Dockerfile.debian
-            platforms: linux/amd64,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ env.SOURCE_COMMIT }}
-      - uses: actions/download-artifact@v6
-        with:
-          name: migration-static-${{ env.SOURCE_COMMIT }}
-          path: static/
-      - uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
-      - uses: docker/setup-buildx-action@v4
-      - uses: docker/login-action@v4
-        with:
-          registry: ghcr.io
-          username: ${{ github.repository_owner }}
-          password: ${{ github.token }}
-      - uses: docker/build-push-action@v7
-        id: image
-        with:
-          context: .
-          file: ${{ matrix.file }}
-          platforms: ${{ matrix.platforms }}
-          build-args: |
-            QL_BRANCH=codex/sqlite-runtime-migration
-            SOURCE_COMMIT=${{ env.SOURCE_COMMIT }}
-          push: true
-          tags: ghcr.io/${{ github.repository }}:migration-candidate-${{ env.SOURCE_COMMIT }}-${{ matrix.libc }}
-          cache-from: type=registry,ref=whyour/qinglong:cache-${{ matrix.libc == 'musl' && 'alpine' || 'debian' }}
-      - name: Record the immutable candidate image
-        env:
-          IMAGE_DIGEST: ${{ steps.image.outputs.digest }}
-          BUNDLE_LIBC: ${{ matrix.libc }}
-        run: |
-          [[ "$IMAGE_DIGEST" =~ ^sha256:[a-f0-9]{64}$ ]]
-          printf '%s\n' "ghcr.io/$GITHUB_REPOSITORY@$IMAGE_DIGEST" > "$BUNDLE_LIBC-image.txt"
-      - uses: actions/upload-artifact@v6
-        with:
-          name: migration-${{ matrix.libc }}-image-${{ env.SOURCE_COMMIT }}
-          path: ${{ matrix.libc }}-image.txt
-          retention-days: 7
-
-  build-bundles:
-    needs: build-images
-    runs-on: ubuntu-22.04
-    timeout-minutes: 90
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { platform: linux/amd64, libc: musl, name: x64-musl }
-          - { platform: linux/arm/v6, libc: musl, name: armv6-musl }
-          - { platform: linux/arm/v7, libc: musl, name: armv7-musl }
-          - { platform: linux/arm64, libc: musl, name: arm64-musl }
-          - { platform: linux/ppc64le, libc: musl, name: ppc64-musl }
-          - { platform: linux/s390x, libc: musl, name: s390x-musl }
-          - { platform: linux/386, libc: musl, name: ia32-musl }
-          - { platform: linux/amd64, libc: glibc, name: x64-glibc }
-          - { platform: linux/arm/v7, libc: glibc, name: armv7-glibc }
-          - { platform: linux/arm64, libc: glibc, name: arm64-glibc }
-          - { platform: linux/ppc64le, libc: glibc, name: ppc64-glibc }
-          - { platform: linux/s390x, libc: glibc, name: s390x-glibc }
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ env.SOURCE_COMMIT }}
-      - uses: actions/download-artifact@v6
-        with:
-          name: migration-${{ matrix.libc }}-image-${{ env.SOURCE_COMMIT }}
-      - uses: docker/setup-qemu-action@v4
-        with:
-          cache-image: false
-      - uses: docker/setup-buildx-action@v4
-      - name: Build and verify both online hops using the unchanged legacy client
-        env:
-          BUNDLE_PLATFORM: ${{ matrix.platform }}
-          BUNDLE_LIBC: ${{ matrix.libc }}
-        run: |
-          set -euo pipefail
-          image=$(cat "$BUNDLE_LIBC-image.txt")
-          legacy=$(node -p "require('./docker/migration-bridge-images.json')['$BUNDLE_LIBC']")
-          docker buildx build --platform "$BUNDLE_PLATFORM" --build-arg "BASE_IMAGE=$image" --build-arg "LEGACY_IMAGE=$legacy" --file docker/Dockerfile.upgrade-bridge --output type=local,dest=output/upgrade .
-      - uses: actions/upload-artifact@v6
-        with:
-          name: migration-bundles-${{ matrix.name }}-${{ env.SOURCE_COMMIT }}
-          path: output/upgrade/*
-          if-no-files-found: error
-          retention-days: 7
-
-  verify-index:
-    needs: [build-bundles, test-node24]
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          ref: ${{ env.SOURCE_COMMIT }}
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '24'
-      - uses: pnpm/action-setup@v6
-        with:
-          version: '8.3.1'
-      - run: pnpm install --prod --frozen-lockfile && npm --prefix cli ci
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: migration-bundles-*-${{ env.SOURCE_COMMIT }}
-          path: output/upgrade/
-          merge-multiple: true
-      - run: node scripts/build-bundle-installer.cjs output/upgrade/install-bundle.cjs
-      - name: Validate every platform without publishing a channel
-        run: |
-          node -e "const fs=require('fs'),{releaseIndex}=require('./scripts/publish-upgrade-bundles.cjs'); const index=releaseIndex('output/upgrade',process.env.SOURCE_COMMIT,process.env.GITHUB_REPOSITORY,{migration:true}); fs.writeFileSync('output/upgrade/candidate-index.json',JSON.stringify(index));"
-      - uses: actions/upload-artifact@v6
-        with:
-          name: migration-candidate-index-${{ env.SOURCE_COMMIT }}
-          path: |
-            output/upgrade/candidate-index.json
-            output/upgrade/install-bundle.cjs
-          retention-days: 7
@@ -1,31 +0,0 @@
-name: Validate
-
-on:
-  pull_request:
-  workflow_dispatch:
-  workflow_call:
-
-permissions:
-  contents: read
-
-jobs:
-  regression:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v6
-        with:
-          version: '8.3.1'
-      - uses: actions/setup-node@v6
-        with:
-          node-version: '24'
-          cache: pnpm
-      - run: pnpm install --frozen-lockfile
-      - run: cp .env.example .env
-      - run: pnpm test
-      - run: pnpm build:back
-      - run: pnpm benchmark:execution -- --runs=10 --output=execution-baseline.json
-      - uses: actions/upload-artifact@v6
-        with:
-          name: execution-baseline
-          path: execution-baseline.json
@@ -28,23 +28,3 @@ __pycache__
 /shell/preload/notify.*
 /shell/preload/*-notify.json
 /shell/preload/__ql_notify__.*
-/shell/preload/lang_env.sh
-/shell/upgrade-lock.yaml
-
-.deepseek/
-.claude/
-
-# local Kubernetes overlays
-/deploy/kubernetes/overlays/local/
-
-# Local security audit artifacts
-/audit/
-
-# Local browser tests, screenshots, reports, and temporary test output
-/.playwright-cli/
-/output/
-/playwright-report/
-/test-results/
-/blob-report/
-/coverage/
-/.nyc_output/
@@ -0,0 +1,22 @@
+/.tmp/
+/.github/
+/.vscode/
+/.history/
+/back/**/*.ts
+/back/**/*.json
+/cli/
+/data/
+/src/
+/static/**/*.js.map
+/static/**/*.gz
+/.editorconfig
+/.gitignore
+/.prettierignore
+/.prettierrc
+/.umirc.ts
+/nodemon.json
+/pnpm-lock.yaml
+/tsconfig.back.json
+/tsconfig.json
+/typings.d.ts
+/.env
@@ -1 +0,0 @@
-22
@@ -1,43 +0,0 @@
-<!-- gitnexus:start -->
-# GitNexus — Code Intelligence
-
-This project is indexed by GitNexus as **qinglong** (2778 symbols, 6698 relationships, 233 execution flows). Use the GitNexus MCP tools to understand code, assess impact, and navigate safely.
-
-> Index stale? Run `node .gitnexus/run.cjs analyze` from the project root — it auto-selects an available runner. No `.gitnexus/run.cjs` yet? `npx gitnexus analyze` (npm 11 crash → `npm i -g gitnexus`; #1939).
-
-## Always Do
-
- **MUST run impact analysis before editing any symbol.** Before modifying a function, class, or method, run `impact({target: "symbolName", direction: "upstream"})` and report the blast radius (direct callers, affected processes, risk level) to the user.
- **MUST run `detect_changes()` before committing** to verify your changes only affect expected symbols and execution flows. For regression review, compare against the default branch: `detect_changes({scope: "compare", base_ref: "develop"})`.
- **MUST warn the user** if impact analysis returns HIGH or CRITICAL risk before proceeding with edits.
- When exploring unfamiliar code, use `query({query: "concept"})` to find execution flows instead of grepping. It returns process-grouped results ranked by relevance.
- When you need full context on a specific symbol — callers, callees, which execution flows it participates in — use `context({name: "symbolName"})`.
-
-## Never Do
-
- NEVER edit a function, class, or method without first running `impact` on it.
- NEVER ignore HIGH or CRITICAL risk warnings from impact analysis.
- NEVER rename symbols with find-and-replace — use `rename` which understands the call graph.
- NEVER commit changes without running `detect_changes()` to check affected scope.
-
-## Resources
-
-| Resource | Use for |
-|----------|---------|
-| `gitnexus://repo/qinglong/context` | Codebase overview, check index freshness |
-| `gitnexus://repo/qinglong/clusters` | All functional areas |
-| `gitnexus://repo/qinglong/processes` | All execution flows |
-| `gitnexus://repo/qinglong/process/{name}` | Step-by-step execution trace |
-
-## CLI
-
-| Task | Read this skill file |
-|------|---------------------|
-| Understand architecture / "How does X work?" | `.claude/skills/gitnexus/gitnexus-exploring/SKILL.md` |
-| Blast radius / "What breaks if I change X?" | `.claude/skills/gitnexus/gitnexus-impact-analysis/SKILL.md` |
-| Trace bugs / "Why is X failing?" | `.claude/skills/gitnexus/gitnexus-debugging/SKILL.md` |
-| Rename / extract / split / refactor | `.claude/skills/gitnexus/gitnexus-refactoring/SKILL.md` |
-| Tools, resources, schema reference | `.claude/skills/gitnexus/gitnexus-guide/SKILL.md` |
-| Index, status, clean, wiki CLI commands | `.claude/skills/gitnexus/gitnexus-cli/SKILL.md` |
-
-<!-- gitnexus:end -->
@@ -1,12 +0,0 @@
-# Node.js 原生部署与 Python venv
-
-面板要求 Node.js >=22.17，推荐 Node.js 24，并要求该 Node 构建提供 `node:sqlite`。应用升级保留现有 Node；旧 Node 20 环境需先升级运行时。远程管理 CLI 的最低版本要求独立于面板。
-
-设置 `QL_DIR` 为安装目录，`QL_DATA_DIR` 为以 `/data` 结尾的绝对持久化数据路径。
-如需隔离 Python，请在启动进程的环境中显式设置 `PYTHON_VENV_DIR`（绝对路径或相对 `QL_DIR` 的路径），例如 `export PYTHON_VENV_DIR=/srv/qinglong/.venv`。未设置时保留现有 Python prefix 行为。
-
- `qinglong`（`shell/start.sh`）安装系统依赖和 Node 工具，并安装 Python requests，然后调用公共启动脚本。
- `npm run start:simple`（`shell/start-simplify.sh`）使用已准备的 Node、pm2、nginx、jq 等依赖，不安装系统包、全局 npm 包或 requests；显式指定的 venv 不存在时仍会创建。请先在 venv 中安装 requests 和任务所需依赖。
- 两种启动方式均保留已有 `.env`；使用 venv 时清除继承的 `PYTHONPATH`/`PYTHONUSERBASE`，依赖查询、安装和卸载使用该 venv 的 Python。
-
-该模式需具备现有启动流程所要求的 nginx 配置和 pm2 服务权限。生产环境设置变量应通过 systemd 的 `Environment` 或相应进程配置完成。已有系统 Python 依赖不自动迁移至 venv，需在 venv 中重新安装。
@@ -34,7 +34,6 @@ Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 - Support system level notification
 - Support dark mode
 - Support cell phone operation
- Manage panels through the [remote CLI and Agent Skill](#remote-cli-and-agent-skill)

 ## Version

@@ -49,17 +48,6 @@ docker pull whyour/qinglong:latest
 docker pull whyour/qinglong:debian
 ```

-When running the `debian` image as a non-root user, specify `--user qinglong`:
-
-```bash
-docker run -d \
-  -v /path/to/ql/data:/ql/data \
-  -p 5700:5700 \
-  --user qinglong \
-  --name qinglong \
-  whyour/qinglong:debian
-```
-
 ### npm

 The npm version supports `debian/ubuntu/alpine` systems and requires `node/npm/python3/pip3/pnpm` to be installed.
@@ -80,29 +68,6 @@ npm i @whyour/qinglong

 [View Documentation](https://qinglong.online/guide/user-guide/basic-explanation)

-## Remote CLI and Agent Skill
-
-Use the standalone npm package [@whyour/qinglong-cli](https://www.npmjs.com/package/@whyour/qinglong-cli) to manage a remote QingLong panel from your terminal or automation workflows. Create, update and run tasks and subscriptions, inspect logs, and manage applications, environment variables, scripts, configuration, dependencies and other OpenAPI resources. JSON output supports scripts and AI agents.
-
-Requires Node.js >=22.12; Node.js 24 is recommended. Install the package to use `ql`:
-
-```bash
-npm install -g @whyour/qinglong-cli
-ql login --url https://ql.example.com
-ql auth status --json
-ql task list --json
-ql subscription list --json
-ql --help
-```
-
-Create an application in the panel's System Settings → Application Settings and grant the required permissions. Enter its Client ID/Secret when prompted during login. Existing tokens are also supported through `QL_URL` and `QL_ACCESS_TOKEN`. Each command supports `--help`; set `QL_LANG=en` for English help.
-
-The npm CLI manages remote panels. The panel's built-in executable is also named `ql`; use a separate installation directory on panel hosts to avoid replacing it. For local script execution and maintenance, see [panel-internal tools](cli/LOCAL.en.md).
-
-[CLI guide](cli/README.en.md) · [简体中文](cli/README.md) · [Full command reference](cli/skills/qinglong-cli/references/openapi.md)
-
-The package includes a [remote management skill](cli/skills/qinglong-cli/SKILL.md) covering authentication, command selection and result verification for AI agents. Local execution and maintenance have a separate [internal skill](cli/skills/qinglong-local/SKILL.md).
-
 ## Development

 ```bash
@@ -36,7 +36,6 @@ Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 - 支持系统级通知
 - 支持暗黑模式
 - 支持手机端操作
- 支持通过 [远程 CLI 与 Agent Skill](#远程-cli-与-agent-skill) 管理面板

 ## 版本

@@ -51,17 +50,6 @@ docker pull whyour/qinglong:latest
 docker pull whyour/qinglong:debian
 ```

-使用 `debian` 镜像以非 root 用户运行时，需指定 `--user qinglong`：
-
-```bash
-docker run -d \
-  -v /path/to/ql/data:/ql/data \
-  -p 5700:5700 \
-  --user qinglong \
-  --name qinglong \
-  whyour/qinglong:debian
-```
-
 ### npm

 npm 版本支持 `debian/ubuntu/alpine` 系统，需要自行安装 `node/npm/python3/pip3/pnpm`
@@ -82,29 +70,6 @@ npm i @whyour/qinglong

 [查看文档](https://qinglong.online/guide/user-guide/basic-explanation)

-## 远程 CLI 与 Agent Skill
-
-使用独立 npm 包 [@whyour/qinglong-cli](https://www.npmjs.com/package/@whyour/qinglong-cli)，可以从本机终端或自动化流程管理远程青龙面板。支持任务与订阅的创建、修改、运行和日志查看，以及应用、环境变量、脚本、配置、依赖等 OpenAPI 资源；JSON 输出便于脚本和 AI Agent 使用。
-
-需要 Node.js >=22.12，推荐 Node.js 24。安装后使用 `ql` 命令：
-
-```bash
-npm install -g @whyour/qinglong-cli
-ql login --url https://ql.example.com
-ql auth status --json
-ql task list --json
-ql subscription list --json
-ql --help
-```
-
-在面板「系统设置 → 应用设置」创建应用并授予所需权限，登录时按提示输入 Client ID/Secret；也支持通过 `QL_URL` 和 `QL_ACCESS_TOKEN` 使用已有令牌。各命令支持 `--help`，`QL_LANG=en` 可切换英文帮助。
-
-npm CLI 用于远程管理。面板内置 `ql` 同样使用这个命令名，已有面板的机器请使用独立安装目录，避免覆盖内置命令。本机脚本执行和运维见 [面板内部工具](cli/LOCAL.md)。
-
-[CLI 中文说明](cli/README.md) · [English guide](cli/README.en.md) · [完整命令参考](cli/skills/qinglong-cli/references/openapi.md)
-
-包内附带 [远程管理 Skill](cli/skills/qinglong-cli/SKILL.md)，涵盖认证、命令选择和操作结果检查，可供 AI Agent 使用。本机执行与运维另见 [内部 Skill](cli/skills/qinglong-local/SKILL.md)。
-
 ## 开发

 ```bash
@@ -1,56 +0,0 @@
-import { NextFunction, Request, Response, Router } from 'express';
-import { celebrate, Joi } from 'celebrate';
-import { t } from '../shared/i18n';
-import {
-  diagnoseClientIp,
-  getTrustProxyConfig,
-  updateTrustProxy,
-} from '../shared/trustProxy';
-
-const route = Router();
-
-export default (app: Router) => {
-  app.use('/system/client-ip', route);
-
-  route.get(
-    '/config',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        res.send({ code: 200, data: await getTrustProxyConfig() });
-      } catch (error) {
-        next(error);
-      }
-    },
-  );
-
-  route.put(
-    '/config',
-    celebrate({
-      body: Joi.object({
-        trustProxy: Joi.string().max(500).required(),
-      }),
-    }),
-    async (req: Request, res: Response) => {
-      try {
-        const data = await updateTrustProxy(req.body.trustProxy);
-        res.send({ code: 200, data });
-      } catch (error) {
-        res.send({
-          code: 400,
-          message: error instanceof Error ? error.message : t('配置更新失败'),
-        });
-      }
-    },
-  );
-
-  route.get(
-    '/diagnose',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        res.send({ code: 200, data: await diagnoseClientIp(req) });
-      } catch (error) {
-        next(error);
-      }
-    },
-  );
-};
@@ -4,11 +4,10 @@ import { Logger } from 'winston';
 import config from '../config';
 import * as fs from 'fs/promises';
 import { celebrate, Joi } from 'celebrate';
+import { join } from 'path';
 import { SAMPLE_FILES } from '../config/const';
-import { t } from '../shared/i18n';
 import ConfigService from '../services/config';
 import { writeFileWithLock } from '../shared/utils';
-import { resolveFileAccess } from '../shared/fileAccess';
 const route = Router();

 export default (app: Router) => {
@@ -72,29 +71,30 @@ export default (app: Router) => {
      const logger: Logger = Container.get('logger');
      try {
        const { name, content } = req.body;
+        if (config.blackFileList.includes(name)) {
+          res.send({ code: 403, message: '文件无法访问' });
+        }
+        let path = join(config.configPath, name);
        if (name.startsWith('data/scripts/')) {
-          return res.send({ code: 403, message: t('文件无法访问') });
+          path = join(config.rootPath, name);
        }
-        const normalized = resolveFileAccess(
-          config.configPath,
-          [name],
-          config.blackFileList,
-        );
-        if (!normalized) {
-          return res.send({ code: 403, message: t('文件无法访问') });
-        }
-        await writeFileWithLock(normalized, content);
-        res.send({ code: 200, message: t('保存成功') });
+        await writeFileWithLock(path, content);
+        res.send({ code: 200, message: '保存成功' });
      } catch (e) {
        return next(e);
      }
    },
  );

-  route.get('/:file', (req: Request, res: Response) => {
-    return res.send({
-      code: 410,
-      message: t('接口已下线，请使用 /configs/detail 接口'),
-    });
-  });
+  route.get(
+    '/:file',
+    async (req: Request, res: Response, next: NextFunction) => {
+      try {
+        const configService = Container.get(ConfigService);
+        await configService.getFile(req.params.file, res);
+      } catch (e) {
+        return next(e);
+      }
+    },
+  );
 };
@@ -5,37 +5,12 @@ import CronService from '../services/cron';
 import CronViewService from '../services/cronView';
 import { celebrate, Joi } from 'celebrate';
 import { commonCronSchema } from '../validation/schedule';
-import { RunningInstanceModel, InstanceStatus } from '../data/runningInstance';
-import { t } from '../shared/i18n';
-import cronClient from '../schedule/client';

 const route = Router();

 export default (app: Router) => {
  app.use('/crons', route);

-  route.use(async (req, res, next) => {
-    // Keep stop/status callbacks available even when the scheduler is down.
-    if (
-      ['POST', 'PUT', 'DELETE'].includes(req.method) &&
-      [
-        '/',
-        '/run',
-        '/enable',
-        '/disable',
-        '/views/enable',
-        '/views/disable',
-      ].includes(req.path)
-    ) {
-      try {
-        await cronClient.readiness.ensureReady();
-      } catch (error) {
-        return next(error);
-      }
-    }
-    return next();
-  });
-
  route.get(
    '/views',
    async (req: Request, res: Response, next: NextFunction) => {
@@ -85,7 +60,7 @@ export default (app: Router) => {
      try {
        const cronViewService = Container.get(CronViewService);
        if (req.body.type === 1) {
-          return res.send({ code: 400, message: t('参数错误') });
+          return res.send({ code: 400, message: '参数错误' });
        } else {
          const data = await cronViewService.update(req.body);
          return res.send({ code: 200, data });
@@ -327,35 +302,13 @@ export default (app: Router) => {
      params: Joi.object({
        id: Joi.number().required(),
      }),
-      query: Joi.object({
-        offset: Joi.number().integer().min(0).optional(),
-        limit: Joi.number()
-          .integer()
-          .min(1)
-          .max(1024 * 1024)
-          .optional(),
-        tail: Joi.boolean().optional(),
-        t: Joi.string().optional(),
-      }).unknown(true),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
-        const result = await cronService.log(req.params.id, {
-          offset: req.query.offset as unknown as number,
-          limit: req.query.limit as unknown as number,
-          tail: req.query.tail as unknown as boolean,
-        });
-        return res.send({
-          code: 200,
-          data: result.content,
-          logStatus: result.status,
-          offset: result.offset,
-          nextOffset: result.nextOffset,
-          total: result.total,
-          truncated: result.truncated,
-        });
+        const data = await cronService.log(req.params.id);
+        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
@@ -476,7 +429,6 @@ export default (app: Router) => {
        log_path: Joi.string().optional().allow(null),
        last_running_time: Joi.number().optional().allow(null),
        last_execution_time: Joi.number().optional().allow(null),
-        exit_code: Joi.number().optional().allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -494,49 +446,6 @@ export default (app: Router) => {
    },
  );

-  route.get(
-    '/:id/instances',
-    celebrate({
-      params: Joi.object({
-        id: Joi.number().required(),
-      }),
-    }),
-    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
-      try {
-        const instances = await RunningInstanceModel.find(
-          { cron_id: req.params.id },
-          { orderBy: [{ started_at: 'desc' }] },
-        );
-        return res.send({ code: 200, data: instances });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
-  route.post(
-    '/:id/instances/:instanceId/stop',
-    celebrate({
-      params: Joi.object({
-        id: Joi.number().required(),
-        instanceId: Joi.number().required(),
-      }),
-    }),
-    async (
-      req: Request<{ id: number; instanceId: number }>,
-      res: Response,
-      next: NextFunction,
-    ) => {
-      try {
-        const cronService = Container.get(CronService);
-        const data = await cronService.stopInstance(req.params.instanceId);
-        return res.send(data);
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
  route.get(
    '/:id/logs',
    celebrate({
@@ -1,373 +0,0 @@
-import { statistics } from '../data/statistics';
-import { Query, QuerySpec, orderBy } from '../data/queries';
-import { Router, Request, Response, NextFunction } from 'express';
-import { Container } from 'typedi';
-import { CrontabModel } from '../data/cron';
-import { CrontabStatModel } from '../data/cronStats';
-import { RunningInstanceModel, InstanceStatus } from '../data/runningInstance';
-import dayjs from 'dayjs';
-import os from 'os';
-import { isEmpty } from 'lodash';
-import { t, tf } from '../shared/i18n';
-const route = Router();
-export default (app: Router) => {
-  app.use('/dashboard', route);
-  route.post('/record', async (req: Request, res: Response) => {
-    try {
-      const { ref_id, code, elapsed } = req.body;
-      if (!ref_id) return res.send({ code: 400, message: 'ref_id required' });
-      const today = dayjs().format('YYYY-MM-DD');
-      const isSuccess = code === 0 ? 1 : 0;
-      const isFail = code !== 0 ? 1 : 0;
-      const elapsedMs = (Number(elapsed) || 0) * 1000;
-      const existing = await CrontabStatModel.findOne(
-        { ref_id: Number(ref_id), date: today },
-        {},
-      );
-      if (existing) {
-        await CrontabStatModel.nativeUpdate(
-          { id: existing.id },
-          {
-            run_count: (existing.run_count || 0) + 1,
-            success_count: (existing.success_count || 0) + isSuccess,
-            fail_count: (existing.fail_count || 0) + isFail,
-            total_time: (existing.total_time || 0) + elapsedMs,
-            max_time: Math.max(existing.max_time || 0, elapsedMs),
-          },
-        );
-      } else {
-        await CrontabStatModel.insert({
-          ref_id: Number(ref_id),
-          date: today,
-          run_count: 1,
-          success_count: isSuccess,
-          fail_count: isFail,
-          total_time: elapsedMs,
-          max_time: elapsedMs,
-        });
-      }
-      res.send({ code: 200 });
-    } catch (e) {
-      res.send({ code: 500 });
-    }
-  });
-  route.get(
-    '/overview',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const today = dayjs().format('YYYY-MM-DD');
-        const [total, enabled, disabled, stats] = await Promise.all([
-          CrontabModel.count({}),
-          CrontabModel.count({ isDisabled: 0 }),
-          CrontabModel.count({ isDisabled: 1 }),
-          statistics.totals(today),
-        ]);
-        const row = stats as any;
-        const totalRuns = Number(row?.total_runs) || 0;
-        const totalSuccess = Number(row?.total_success) || 0;
-        const totalFail = Number(row?.total_fail) || 0;
-        const totalTime = Number(row?.total_time) || 0;
-        res.send({
-          code: 200,
-          data: {
-            total,
-            enabled,
-            disabled,
-            todayRuns: totalRuns,
-            todaySuccess: totalSuccess,
-            todayFail: totalFail,
-            successRate:
-              totalRuns > 0
-                ? ((totalSuccess / totalRuns) * 100).toFixed(1)
-                : '0',
-            avgTime: totalRuns > 0 ? Math.round(totalTime / totalRuns) : 0,
-          },
-        });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-  for (const isSuccess of [false, true]) {
-    route.get(
-      isSuccess ? '/successes' : '/failures',
-      async (req: Request, res: Response, next: NextFunction) => {
-        try {
-          const countColumn = isSuccess ? 'success_count' : 'fail_count';
-          const rows = (await statistics.results(
-            dayjs().format('YYYY-MM-DD'),
-            countColumn,
-          )) as any[];
-          const crons =
-            rows.length > 0
-              ? await CrontabModel.find(
-                  { id: { ['$in']: rows.map((row) => Number(row.ref_id)) } },
-                  {
-                    fields: ['id', 'name', 'command'],
-                  },
-                )
-              : [];
-          const cronMap = new Map(crons.map((cron) => [cron.id, cron]));
-          res.send({
-            code: 200,
-            data: rows.map((row) => {
-              const id = Number(row.ref_id);
-              const cron = cronMap.get(id);
-              return {
-                id,
-                name: cron?.name || cron?.command || tf('任务#%s', id),
-                command: cron?.command || '',
-                [isSuccess ? 'successCount' : 'failCount']: Number(
-                  row.result_count,
-                ),
-                deleted: !cron,
-              };
-            }),
-          });
-        } catch (e) {
-          next(e);
-        }
-      },
-    );
-  }
-  route.get(
-    '/trend',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const days = parseInt(req.query.days as string) || 7;
-        const dates: string[] = [];
-        for (let i = days - 1; i >= 0; i--) {
-          dates.push(dayjs().subtract(i, 'day').format('YYYY-MM-DD'));
-        }
-        const rows = (await statistics.trend(dates)) as any[];
-        const dataMap: Record<string, any> = {};
-        rows.forEach((r: any) => {
-          dataMap[r.date] = {
-            total: Number(r.total_runs) || 0,
-            success: Number(r.total_success) || 0,
-            fail: Number(r.total_fail) || 0,
-          };
-        });
-        const data = dates.map((d) => ({
-          date: dayjs(d).format('MM-DD'),
-          ...(dataMap[d] || { total: 0, success: 0, fail: 0 }),
-        }));
-        res.send({ code: 200, data });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-  route.get(
-    '/top-time',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const today = dayjs().format('YYYY-MM-DD');
-        const rows = (await statistics.ranking(today, 'total_time')) as any[];
-        const ids = rows.map((r) => Number(r.ref_id));
-        const crons = await CrontabModel.find({ id: { ['$in']: ids } }, {});
-        const nameMap: Record<number, string> = {};
-        crons.forEach((c: any) => {
-          nameMap[c.id] = c.name || c.command;
-        });
-        const data = rows.map((r: any, i) => ({
-          rank: i + 1,
-          name: nameMap[Number(r.ref_id)] || tf('任务#%s', r.ref_id),
-          avgTime: Math.round(Number(r.total_time) / Number(r.run_count)),
-          maxTime: Number(r.max_time),
-        }));
-        res.send({ code: 200, data });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-  route.get(
-    '/top-count',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const today = dayjs().format('YYYY-MM-DD');
-        const rows = (await statistics.ranking(today, 'run_count')) as any[];
-        const ids = rows.map((r) => Number(r.ref_id));
-        const crons = await CrontabModel.find({ id: { ['$in']: ids } }, {});
-        const nameMap: Record<number, string> = {};
-        crons.forEach((c: any) => {
-          nameMap[c.id] = c.name || c.command;
-        });
-        const data = rows.map((r: any, i) => ({
-          rank: i + 1,
-          name: nameMap[Number(r.ref_id)] || tf('任务#%s', r.ref_id),
-          runCount: Number(r.run_count),
-          avgTime: Math.round(Number(r.total_time) / Number(r.run_count)),
-          successRate:
-            Number(r.run_count) > 0
-              ? ((Number(r.success_count) / Number(r.run_count)) * 100).toFixed(
-                  1,
-                )
-              : '0',
-        }));
-        res.send({ code: 200, data });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-  route.get(
-    '/runtime',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const runningInstances = await RunningInstanceModel.find(
-          {
-            status: InstanceStatus.running,
-          },
-          {},
-        );
-        const queuedCrons = await CrontabModel.find(
-          {
-            status: 3, // queued
-          },
-          {},
-        );
-        // Fetch cron names for running instances
-        const cronIds = [
-          ...new Set(runningInstances.map((i: any) => i.cron_id)),
-        ];
-        const crons =
-          cronIds.length > 0
-            ? await CrontabModel.find({ id: cronIds }, {})
-            : [];
-        const cronMap = new Map(crons.map((c: any) => [c.id, c]));
-        const now = dayjs().unix();
-        const running = runningInstances.map((inst: any) => {
-          const cron = cronMap.get(inst.cron_id);
-          return {
-            instanceId: inst.id,
-            id: inst.cron_id,
-            name: cron?.name || cron?.command || tf('任务#%s', inst.cron_id),
-            pid: inst.pid,
-            elapsed: inst.started_at ? now - inst.started_at : 0,
-            logPath: inst.log_path,
-          };
-        });
-        const dayAgo = dayjs().subtract(24, 'hour').unix();
-        const idleTasks = await CrontabModel.find(
-          {
-            isDisabled: 0,
-            status: 1,
-            last_execution_time: { ['$lt']: dayAgo },
-          },
-          {
-            orderBy: orderBy([['last_execution_time', 'ASC']]),
-            limit: 5,
-          },
-        );
-        res.send({
-          code: 200,
-          data: {
-            runningCount: running.length,
-            queuedCount: queuedCrons.length,
-            running,
-            idleTasks: idleTasks.map((c: any) => ({
-              id: c.id,
-              name: c.name || c.command || tf('任务#%s', c.id),
-              lastRun: c.last_execution_time
-                ? dayjs.unix(c.last_execution_time).format('MM-DD HH:mm')
-                : '-',
-            })),
-          },
-        });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-  route.get(
-    '/labels',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const today = dayjs().format('YYYY-MM-DD');
-        const [crons, stats] = await Promise.all([
-          CrontabModel.find({ isDisabled: 0 }, {}),
-          CrontabStatModel.find({ date: today }, {}),
-        ]);
-        const statMap: Record<number, any> = {};
-        stats.forEach((s: any) => {
-          statMap[s.ref_id] = s;
-        });
-        const labelMap: Record<
-          string,
-          {
-            count: number;
-            runs: number;
-            success: number;
-            totalTime: number;
-          }
-        > = {};
-        crons.forEach((c) => {
-          let rawLabels = c.labels;
-          if (typeof rawLabels === 'string') rawLabels = JSON.parse(rawLabels);
-          const labels: string[] = Array.isArray(rawLabels)
-            ? [
-                ...new Set(
-                  (rawLabels as string[]).filter((l: string) => !isEmpty(l)),
-                ),
-              ]
-            : [];
-          if (labels.length === 0) {
-            labels.push(t('未分类'));
-          }
-          const st = statMap[c.id!];
-          labels.forEach((label: string) => {
-            if (!labelMap[label])
-              labelMap[label] = { count: 0, runs: 0, success: 0, totalTime: 0 };
-            labelMap[label].count += 1;
-            if (st) {
-              labelMap[label].runs += Number(st.run_count) || 0;
-              labelMap[label].success += Number(st.success_count) || 0;
-              labelMap[label].totalTime += Number(st.total_time) || 0;
-            }
-          });
-        });
-        const data = Object.entries(labelMap)
-          .map(([label, v]) => ({
-            label,
-            count: v.count,
-            todayRuns: v.runs,
-            successRate:
-              v.runs > 0 ? ((v.success / v.runs) * 100).toFixed(1) : '0',
-            avgTime: v.runs > 0 ? Math.round(v.totalTime / v.runs) : 0,
-          }))
-          .sort((a, b) => b.todayRuns - a.todayRuns);
-        res.send({ code: 200, data });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-  route.get(
-    '/system',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const memUsage = process.memoryUsage();
-        res.send({
-          code: 200,
-          data: {
-            platform: os.platform(),
-            uptime: Math.floor(process.uptime()),
-            memTotal: os.totalmem(),
-            memFree: os.freemem(),
-            memUsagePercent: ((1 - os.freemem() / os.totalmem()) * 100).toFixed(
-              1,
-            ),
-            heapUsed: Math.round(memUsage.heapUsed / 1024 / 1024),
-            heapTotal: Math.round(memUsage.heapTotal / 1024 / 1024),
-            loadAvg: os.loadavg().map((v) => Number(v.toFixed(2))),
-            cpus: os.cpus().length,
-          },
-        });
-      } catch (e) {
-        next(e);
-      }
-    },
-  );
-};
@@ -16,7 +16,7 @@ export default (app: Router) => {
          searchValue: Joi.string().optional().allow(''),
          type: Joi.string().optional().allow(''),
          status: Joi.string().optional().allow(''),
-        }).unknown(true),
+        }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -1,20 +1,23 @@
 import { Joi, celebrate } from 'celebrate';
 import { NextFunction, Request, Response, Router } from 'express';
+import fs from 'fs';
 import multer from 'multer';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
-import { t } from '../shared/i18n';
+import config from '../config';
+import { safeJSONParse } from '../config/util';
 import EnvService from '../services/env';
 const route = Router();

-const upload = multer({
-  storage: multer.memoryStorage(),
-  limits: { fileSize: 5 * 1024 * 1024, files: 1 },
+const storage = multer.diskStorage({
+  destination: function (req, file, cb) {
+    cb(null, config.scriptPath);
+  },
+  filename: function (req, file, cb) {
+    cb(null, file.originalname);
+  },
 });
-const labelSchema = Joi.array()
-  .items(Joi.string().trim().required())
-  .min(1)
-  .required();
+const upload = multer({ storage: storage });

 export default (app: Router) => {
  app.use('/envs', route);
@@ -41,7 +44,6 @@ export default (app: Router) => {
            .required()
            .pattern(/^[a-zA-Z_][0-9a-zA-Z_]*$/),
          remarks: Joi.string().optional().allow(''),
-          labels: Joi.array().items(Joi.string().trim()).optional().allow(null),
        }),
      ),
    }),
@@ -50,7 +52,7 @@ export default (app: Router) => {
      try {
        const envService = Container.get(EnvService);
        if (!req.body?.length) {
-          return res.send({ code: 400, message: t('参数不正确') });
+          return res.send({ code: 400, message: '参数不正确' });
        }
        const data = await envService.create(req.body);
        return res.send({ code: 200, data });
@@ -68,7 +70,6 @@ export default (app: Router) => {
        name: Joi.string().required(),
        remarks: Joi.string().optional().allow('').allow(null),
        id: Joi.number().required(),
-        labels: Joi.array().items(Joi.string().trim()).optional().allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -229,44 +230,6 @@ export default (app: Router) => {
    },
  );

-  route.post(
-    '/labels',
-    celebrate({
-      body: Joi.object({
-        ids: Joi.array().items(Joi.number().required()).min(1).required(),
-        labels: labelSchema,
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const envService = Container.get(EnvService);
-        const data = await envService.addLabels(req.body.ids, req.body.labels);
-        return res.send({ code: 200, data });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
-  route.delete(
-    '/labels',
-    celebrate({
-      body: Joi.object({
-        ids: Joi.array().items(Joi.number().required()).min(1).required(),
-        labels: labelSchema,
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const envService = Container.get(EnvService);
-        const data = await envService.removeLabels(req.body.ids, req.body.labels);
-        return res.send({ code: 200, data });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
  route.post(
    '/upload',
    upload.single('env'),
@@ -274,36 +237,24 @@ export default (app: Router) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
-        let parseContent: unknown;
-        try {
-          parseContent = JSON.parse(req.file?.buffer.toString('utf8') || '');
-        } catch {
-          return res.status(400).send({ code: 400, message: t('参数错误') });
-        }
+        const fileContent = await fs.promises.readFile(req!.file!.path, 'utf8');
+        const parseContent = safeJSONParse(fileContent);
        const data = Array.isArray(parseContent)
          ? parseContent
          : [parseContent];
-        if (
-          data.length > 0 &&
-          data.every((x) =>
-            x && typeof x.name === 'string' &&
-            /^[a-zA-Z_][0-9a-zA-Z_]*$/.test(x.name) &&
-            typeof x.value === 'string' && x.value.length > 0,
-          )
-        ) {
+        if (data.every((x) => x.name && x.value)) {
          const result = await envService.create(
            data.map((x) => ({
              name: x.name,
              value: x.value,
              remarks: x.remarks,
-              labels: x.labels,
            })),
          );
          return res.send({ code: 200, data: result });
        } else {
          return res.send({
            code: 400,
-            message: t('每条数据 name 或者 value 字段不能为空，参考导出文件格式'),
+            message: '每条数据 name 或者 value 字段不能为空，参考导出文件格式',
          });
        }
      } catch (e) {
@@ -11,8 +11,8 @@ export default (app: Router) => {
    try {
      const healthService = Container.get(HealthService);
      const health = await healthService.check();
-      res.status(health.status === 'ok' ? 200 : 503).send({
-        code: health.status === 'ok' ? 200 : 503,
+      res.status(200).send({
+        code: 200,
        data: health,
      });
    } catch (err: any) {
@@ -10,10 +10,7 @@ import dependence from './dependence';
 import system from './system';
 import subscription from './subscription';
 import update from './update';
-import dashboard from './dashboard';
 import health from './health';
-import clientIp from './clientIp';
-import retention from './retention';

 export default () => {
  const app = Router();
@@ -28,10 +25,7 @@ export default () => {
  system(app);
  subscription(app);
  update(app);
-  dashboard(app);
  health(app);
-  clientIp(app);
-  retention(app);

  return app;
 };
@@ -3,15 +3,13 @@ import { NextFunction, Request, Response, Router } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import config from '../config';
-import { t } from '../shared/i18n';
 import {
+  getFileContentByName,
  readDirs,
  removeAnsi,
  rmPath,
 } from '../config/util';
 import LogService from '../services/log';
-import { InstanceStatus, RunningInstanceModel } from '../data/runningInstance';
-import { MAX_LOG_CHUNK_BYTES, readLogChunk } from '../shared/logReader';
 const route = Router();
 const blacklist = ['.tmp'];

@@ -34,20 +32,6 @@ export default (app: Router) => {

  route.get(
    '/detail',
-    celebrate({
-      query: Joi.object({
-        path: Joi.string().allow('').optional(),
-        file: Joi.string().required(),
-        offset: Joi.number().integer().min(0).optional(),
-        limit: Joi.number()
-          .integer()
-          .min(1)
-          .max(MAX_LOG_CHUNK_BYTES)
-          .optional(),
-        tail: Joi.boolean().optional(),
-        t: Joi.string().optional(),
-      }).unknown(true),
-    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const logService = Container.get(LogService);
@@ -58,28 +42,11 @@ export default (app: Router) => {
        if (!finalPath || blacklist.includes(req.query.path as string)) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }
-        const logPath = `${req.query.path as string}/${req.query.file as string}`;
-        const runningInstance = await RunningInstanceModel.findOne({
-          where: { log_path: logPath, status: InstanceStatus.running },
-        });
-
-        const chunk = await readLogChunk(finalPath, {
-          offset: req.query.offset as unknown as number,
-          limit: req.query.limit as unknown as number,
-          tail: req.query.tail as unknown as boolean,
-        });
-        res.send({
-          code: 200,
-          data: removeAnsi(chunk.content),
-          logStatus: runningInstance ? 'running' : undefined,
-          offset: chunk.offset,
-          nextOffset: chunk.nextOffset,
-          total: chunk.total,
-          truncated: chunk.truncated,
-        });
+        const content = await getFileContentByName(finalPath);
+        res.send({ code: 200, data: removeAnsi(content) });
      } catch (e) {
        return next(e);
      }
@@ -88,11 +55,24 @@ export default (app: Router) => {

  route.get(
    '/:file',
-    (req: Request, res: Response) => {
-      return res.send({
-        code: 410,
-        message: t('接口已下线，请使用 /logs/detail 接口'),
-      });
+    async (req: Request, res: Response, next: NextFunction) => {
+      try {
+        const logService = Container.get(LogService);
+        const finalPath = logService.checkFilePath(
+          (req.query.path as string) || '',
+          (req.params.file as string) || '',
+        );
+        if (!finalPath || blacklist.includes(req.query.path as string)) {
+          return res.send({
+            code: 403,
+            message: '暂无权限',
+          });
+        }
+        const content = await getFileContentByName(finalPath);
+        res.send({ code: 200, data: content });
+      } catch (e) {
+        return next(e);
+      }
    },
  );

@@ -116,7 +96,7 @@ export default (app: Router) => {
        if (!finalPath || blacklist.includes(path)) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }
        await rmPath(finalPath);
@@ -146,7 +126,7 @@ export default (app: Router) => {
        if (!filePath) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }
        return res.download(filePath, filename, (err) => {
@@ -3,7 +3,6 @@ import { Container } from 'typedi';
 import OpenService from '../services/open';
 import { Logger } from 'winston';
 import { celebrate, Joi } from 'celebrate';
-import { rateLimit } from 'express-rate-limit';
 const route = Router();

 export default (app: Router) => {
@@ -101,7 +100,6 @@ export default (app: Router) => {

  route.get(
    '/auth/token',
-    rateLimit({ windowMs: 15 * 60 * 1000, limit: 100 }),
    celebrate({
      query: {
        client_id: Joi.string().required(),
@@ -1,78 +0,0 @@
-import { NextFunction, Request, Response, Router } from 'express';
-import { celebrate, Joi } from 'celebrate';
-import { Container } from 'typedi';
-import RetentionService from '../services/retention';
-import { MAX_RETENTION_DAYS } from '../shared/retention';
-
-const route = Router();
-const policySchema = {
-  runningInstanceRetentionDays: Joi.number()
-    .integer()
-    .min(0)
-    .max(MAX_RETENTION_DAYS)
-    .required(),
-  cronStatRetentionDays: Joi.number()
-    .integer()
-    .min(0)
-    .max(MAX_RETENTION_DAYS)
-    .required(),
-};
-const cleanupSchema = {
-  ...policySchema,
-  dependenceCacheTypes: Joi.array()
-    .items(Joi.string().valid('node', 'python3'))
-    .unique()
-    .default([]),
-  compactDatabase: Joi.boolean().default(false),
-};
-
-export default (app: Router) => {
-  app.use('/system/storage-retention', route);
-
-  route.put(
-    '/config',
-    celebrate({ body: Joi.object(policySchema) }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const service = Container.get(RetentionService);
-        const data = await service.updatePolicy(req.body);
-        res.send({ code: 200, data });
-      } catch (error) {
-        next(error);
-      }
-    },
-  );
-
-  route.post(
-    '/preview',
-    celebrate({ body: Joi.object(cleanupSchema) }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const service = Container.get(RetentionService);
-        const data = await service.preview(req.body);
-        res.send({ code: 200, data });
-      } catch (error) {
-        next(error);
-      }
-    },
-  );
-
-  route.post(
-    '/cleanup',
-    celebrate({
-      body: Joi.object({
-        ...cleanupSchema,
-        confirmation: Joi.string().valid('CLEAN').required(),
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const service = Container.get(RetentionService);
-        const data = await service.cleanup(req.body);
-        res.send({ code: 200, data });
-      } catch (error) {
-        next(error);
-      }
-    },
-  );
-};
@@ -1,5 +1,3 @@
-import { randomUUID } from 'crypto';
-import { resolveFileAccess } from '../shared/fileAccess';
 import { fileExist, readDirs, readDir, rmPath, IFile } from '../config/util';
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
@@ -7,68 +5,18 @@ import { Logger } from 'winston';
 import config from '../config';
 import * as fs from 'fs/promises';
 import { celebrate, Joi } from 'celebrate';
-import path, { dirname, join, parse, resolve, sep } from 'path';
+import path, { join, parse } from 'path';
 import ScriptService from '../services/script';
-import ScriptHistoryService from '../services/scriptHistory';
-import { t } from '../shared/i18n';
 import multer from 'multer';
 import { writeFileWithLock } from '../shared/utils';
-import {
-  ScriptHistoryError,
-  HistoryUnavailableError,
-} from '../shared/scriptHistory';
 const route = Router();

-function isPathAllowed(targetPath: string): boolean {
-  const resolved = path.resolve(targetPath);
-  return config.writePathList.some((x) =>
-    Boolean(
-      resolveFileAccess(
-        x,
-        [resolved],
-        // Panel configuration secrets must not restrict user script filenames.
-        path.resolve(x) === path.resolve(config.configPath)
-          ? config.blackFileList
-          : [],
-      ),
-    ),
-  );
-}
-
-async function existingWritableRealPath(targetPath: string): Promise<string> {
-  if (!isPathAllowed(targetPath)) {
-    throw new ScriptHistoryError(403, '暂无权限');
-  }
-  const resolved = resolve(targetPath);
-  for (const writableRoot of config.writePathList) {
-    const root = resolve(writableRoot);
-    const rootPrefix = root.endsWith(sep) ? root : root + sep;
-    // Keep an explicit normalized boundary check at the filesystem operation.
-    if (!resolved.startsWith(rootPrefix)) continue;
-    const realPath = await fs.realpath(resolved);
-    const realRoot = await fs.realpath(root);
-    const realRootPrefix = realRoot.endsWith(sep) ? realRoot : realRoot + sep;
-    if (
-      !realPath.startsWith(realRootPrefix) ||
-      !resolveFileAccess(
-        realRoot,
-        [realPath],
-        root === resolve(config.configPath) ? config.blackFileList : [],
-      )
-    ) {
-      throw new ScriptHistoryError(403, '暂无权限');
-    }
-    return realPath;
-  }
-  throw new ScriptHistoryError(403, '暂无权限');
-}
-
 const storage = multer.diskStorage({
  destination: function (req, file, cb) {
-    cb(null, config.tmpPath);
+    cb(null, config.scriptPath);
  },
  filename: function (req, file, cb) {
-    cb(null, randomUUID());
+    cb(null, file.originalname);
  },
 });
 const upload = multer({ storage: storage });
@@ -81,7 +29,7 @@ export default (app: Router) => {
    celebrate({
      query: Joi.object({
        path: Joi.string().optional().allow(''),
-      }).unknown(true),
+      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -96,11 +44,6 @@ export default (app: Router) => {
          'package-lock.json',
        ];
        if (req.query.path) {
-          if (
-            !resolveFileAccess(config.scriptPath, [req.query.path as string])
-          ) {
-            return res.send({ code: 403, message: t('暂无权限') });
-          }
          result = await readDir(
            req.query.path as string,
            config.scriptPath,
@@ -128,8 +71,7 @@ export default (app: Router) => {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
-    },
-  );
+    });

  route.get(
    '/detail',
@@ -137,13 +79,13 @@ export default (app: Router) => {
      query: Joi.object({
        path: Joi.string().optional().allow(''),
        file: Joi.string().required(),
-      }).unknown(true),
+      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scriptService = Container.get(ScriptService);
        const content = await scriptService.getFile(
-          (req.query?.path as string) || '',
+          req.query?.path as string || '',
          req.query.file as string,
        );
        res.send({ code: 200, data: content });
@@ -153,112 +95,42 @@ export default (app: Router) => {
    },
  );

-  const historyError = (error: unknown, res: Response, next: NextFunction) => {
-    if (error instanceof ScriptHistoryError) {
-      return res.status(error.status).send({
-        code: error.status,
-        message: t(error.message),
-        ...(error instanceof HistoryUnavailableError
-          ? { historyUnavailable: true, currentHash: error.currentHash }
-          : {}),
-      });
-    }
-    return next(error);
-  };
-  const historyQuery = {
-    filename: Joi.string().required(),
-    path: Joi.string().optional().allow(''),
-  };
-
  route.get(
-    '/history',
-    celebrate({ query: Joi.object(historyQuery).unknown(true) }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const service = Container.get(ScriptHistoryService);
-        const data = await service.list(
-          (req.query.path as string) || '',
-          req.query.filename as string,
-        );
-        res.send({ code: 200, data });
-      } catch (error) {
-        historyError(error, res, next);
-      }
-    },
-  );
-  route.get(
-    '/history/detail',
+    '/:file',
    celebrate({
+      params: Joi.object({
+        file: Joi.string().required(),
+      }),
      query: Joi.object({
-        ...historyQuery,
-        id: Joi.string().uuid().required(),
-      }).unknown(true),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const service = Container.get(ScriptHistoryService);
-        const data = await service.detail(
-          (req.query.path as string) || '',
-          req.query.filename as string,
-          req.query.id as string,
-        );
-        res.send({ code: 200, data });
-      } catch (error) {
-        historyError(error, res, next);
-      }
-    },
-  );
-  route.put(
-    '/history/restore',
-    celebrate({
-      body: Joi.object({
-        ...historyQuery,
-        id: Joi.string().uuid().required(),
-        expectedHash: Joi.string().hex().length(64).required(),
+        path: Joi.string().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
-        const { path = '', filename, id, expectedHash } = req.body;
-        const service = Container.get(ScriptHistoryService);
-        const data = await service.restore(path, filename, id, expectedHash);
-        res.send({ code: 200, data });
-      } catch (error) {
-        historyError(error, res, next);
+        const scriptService = Container.get(ScriptService);
+        const content = await scriptService.getFile(
+          req.query?.path as string || '',
+          req.params.file,
+        );
+        res.send({ code: 200, data: content });
+      } catch (e) {
+        return next(e);
      }
    },
  );

-  route.get('/:file', (req: Request, res: Response) => {
-    return res.send({
-      code: 410,
-      message: t('接口已下线，请使用 /scripts/detail 接口'),
-    });
-  });
-
  route.post(
    '/',
-    (req: Request, res: Response, next: NextFunction) => {
-      res.on('finish', () => {
-        if (req.file?.path) fs.unlink(req.file.path).catch(() => undefined);
-      });
-      next();
-    },
    upload.single('file'),
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().optional().allow(''),
        content: Joi.string().optional().allow(''),
-        skipHistory: Joi.boolean().optional(),
-        expectedHash: Joi.string()
-          .hex()
-          .length(64)
-          .when('skipHistory', { is: true, then: Joi.required() }),
        originFilename: Joi.string().optional().allow(''),
        directory: Joi.string().optional().allow(''),
        file: Joi.string().optional().allow(''),
-      }).unknown(true),
+      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
@@ -283,87 +155,30 @@ export default (app: Router) => {
        if (config.writePathList.every((x) => !path.startsWith(x))) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }

        if (req.file) {
-          const uploadPath = join(path, filename);
-          if (!isPathAllowed(uploadPath)) {
-            return res.send({ code: 403, message: t('暂无权限') });
-          }
-          await fs.copyFile(req.file.path, uploadPath);
-          await fs.unlink(req.file.path);
+          await fs.rename(req.file.path, join(path, filename));
          return res.send({ code: 200 });
        }

        if (directory) {
-          const dirPath = join(path, directory);
-          if (!isPathAllowed(dirPath)) {
-            return res.send({ code: 403, message: t('暂无权限') });
-          }
-          await fs.mkdir(dirPath, { recursive: true });
+          await fs.mkdir(join(path, directory), { recursive: true });
          return res.send({ code: 200 });
        }

        if (!originFilename) {
          originFilename = filename;
        }
-        const originFilePath = join(path, originFilename);
-        const filePath = join(path, filename);
-        if (!isPathAllowed(filePath) || !isPathAllowed(originFilePath)) {
-          return res.send({ code: 403, message: t('暂无权限') });
-        }
-        // Check the canonical parent directly at the directory creation boundary.
-        const parentPath = resolve(dirname(filePath));
-        let parentCreated = false;
-        for (const writableRoot of config.writePathList) {
-          const root = resolve(writableRoot);
-          const rootPrefix = root.endsWith(sep) ? root : root + sep;
-          if (parentPath === root) {
-            await fs.mkdir(root, { recursive: true });
-          } else if (parentPath.startsWith(rootPrefix)) {
-            await fs.mkdir(parentPath, { recursive: true });
-          } else {
-            continue;
-          }
-          parentCreated = true;
-          break;
-        }
-        if (!parentCreated) {
-          return res.send({ code: 403, message: t('暂无权限') });
-        }
+        const originFilePath = join(
+          path,
+          `${originFilename.replace(/\//g, '')}`,
+        );
+        await fs.mkdir(path, { recursive: true });
+        const filePath = join(path, `${filename.replace(/\//g, '')}`);
        const fileExists = await fileExist(filePath);
-        if (fileExists && resolveFileAccess(config.scriptPath, [filePath])) {
-          let removeSource = filename !== originFilename;
-          let backupSource = '';
-          if (removeSource) {
-            const [originRealPath, targetRealPath] = await Promise.all([
-              existingWritableRealPath(originFilePath),
-              existingWritableRealPath(filePath),
-            ]);
-            // Aliases of one script are an in-place save. Removing the source
-            // would also remove the destination behind a target symlink.
-            removeSource = originRealPath !== targetRealPath;
-            backupSource = originRealPath;
-          }
-          // Save-as removes the source after committing the destination. Keep
-          // its original content too: destination history only protects the
-          // file being overwritten, not the source being deleted.
-          if (removeSource) {
-            await fs.copyFile(
-              backupSource,
-              join(config.bakPath, originFilename.replace(/\//g, '')),
-            );
-          }
-          const service = Container.get(ScriptHistoryService);
-          const data = await service.save(path, filename, content, {
-            skipHistory: req.body.skipHistory,
-            expectedHash: req.body.expectedHash,
-          });
-          if (removeSource) await rmPath(originFilePath);
-          return res.send({ code: 200, data });
-        }
        if (fileExists) {
          await fs.copyFile(
            originFilePath,
@@ -376,7 +191,7 @@ export default (app: Router) => {
        await writeFileWithLock(filePath, content);
        return res.send({ code: 200 });
      } catch (e) {
-        return historyError(e, res, next);
+        return next(e);
      }
    },
  );
@@ -388,11 +203,6 @@ export default (app: Router) => {
        filename: Joi.string().required(),
        path: Joi.string().optional().allow(''),
        content: Joi.string().required().allow(''),
-        skipHistory: Joi.boolean().optional(),
-        expectedHash: Joi.string()
-          .hex()
-          .length(64)
-          .when('skipHistory', { is: true, then: Joi.required() }),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -407,17 +217,13 @@ export default (app: Router) => {
        if (!filePath) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }
-        const service = Container.get(ScriptHistoryService);
-        const data = await service.save(path || '', filename, content, {
-          skipHistory: req.body.skipHistory,
-          expectedHash: req.body.expectedHash,
-        });
-        return res.send({ code: 200, data });
+        await writeFileWithLock(filePath, content);
+        return res.send({ code: 200 });
      } catch (e) {
-        return historyError(e, res, next);
+        return next(e);
      }
    },
  );
@@ -445,7 +251,7 @@ export default (app: Router) => {
        if (!filePath) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }
        await rmPath(filePath);
@@ -478,7 +284,7 @@ export default (app: Router) => {
        if (!filePath) {
          return res.send({
            code: 403,
-            message: t('暂无权限'),
+            message: '暂无权限',
          });
        }
        return res.download(filePath, filename, (err) => {
@@ -510,9 +316,6 @@ export default (app: Router) => {
        }
        const { name, ext } = parse(filename);
        const filePath = join(config.scriptPath, path, `${name}.swap${ext}`);
-        if (!isPathAllowed(filePath)) {
-          return res.send({ code: 403, message: t('暂无权限') });
-        }
        await writeFileWithLock(filePath, content || '');

        const scriptService = Container.get(ScriptService);
@@ -541,24 +344,12 @@ export default (app: Router) => {
        }
        const { name, ext } = parse(filename);
        const filePath = join(config.scriptPath, path, `${name}.swap${ext}`);
-        if (!isPathAllowed(filePath)) {
-          return res.send({ code: 403, message: t('暂无权限') });
-        }
-        const logPath = resolveFileAccess(config.logPath, [
-          path,
-          `${name}.swap`,
-        ]);
-        if (!logPath) {
-          return res.send({ code: 403, message: t('暂无权限') });
-        }
+        const logPath = join(config.logPath, path, `${name}.swap`);

        const scriptService = Container.get(ScriptService);
        const result = await scriptService.stopScript(filePath, pid);
        setTimeout(() => {
-          const cleanupPath = resolveFileAccess(config.logPath, [logPath]);
-          if (cleanupPath) {
-            void rmPath(cleanupPath);
-          }
+          rmPath(logPath);
        }, 3000);
        res.send(result);
      } catch (e) {
@@ -588,9 +379,6 @@ export default (app: Router) => {
        }
        const filePath = join(config.scriptPath, path, filename);
        const newPath = join(config.scriptPath, path, newFilename);
-        if (!isPathAllowed(filePath) || !isPathAllowed(newPath)) {
-          return res.send({ code: 403, message: t('暂无权限') });
-        }
        await fs.rename(filePath, newPath);
        res.send({ code: 200 });
      } catch (e) {
@@ -3,7 +3,7 @@ import { Container } from 'typedi';
 import { Logger } from 'winston';
 import SubscriptionService from '../services/subscription';
 import { celebrate, Joi } from 'celebrate';
-import { isValidCronSchedule } from '../shared/cronSchedule';
+import { CronExpressionParser } from 'cron-parser';
 const route = Router();

 export default (app: Router) => {
@@ -58,7 +58,10 @@ export default (app: Router) => {
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        if (!req.body.schedule || isValidCronSchedule(req.body.schedule)) {
+        if (
+          !req.body.schedule ||
+          CronExpressionParser.parse(req.body.schedule).hasNext()
+        ) {
          const subscriptionService = Container.get(SubscriptionService);
          const data = await subscriptionService.create(req.body);
          return res.send({ code: 200, data });
@@ -145,27 +148,13 @@ export default (app: Router) => {
      params: Joi.object({
        id: Joi.number().required(),
      }),
-      query: Joi.object({
-        offset: Joi.number().integer().min(0).optional(),
-        limit: Joi.number()
-          .integer()
-          .min(1)
-          .max(1024 * 1024)
-          .optional(),
-        tail: Joi.boolean().optional(),
-        t: Joi.string().optional(),
-      }).unknown(true),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
-        const result = await subscriptionService.log(req.params.id, {
-          offset: req.query.offset as unknown as number,
-          limit: req.query.limit as unknown as number,
-          tail: req.query.tail as unknown as boolean,
-        });
-        return res.send({ code: 200, data: result.content, ...result });
+        const data = await subscriptionService.log(req.params.id);
+        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
@@ -201,7 +190,11 @@ export default (app: Router) => {
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        if (!req.body.schedule || isValidCronSchedule(req.body.schedule)) {
+        if (
+          !req.body.schedule ||
+          typeof req.body.schedule === 'object' ||
+          CronExpressionParser.parse(req.body.schedule).hasNext()
+        ) {
          const subscriptionService = Container.get(SubscriptionService);
          const data = await subscriptionService.update(req.body);
          return res.send({ code: 200, data });
@@ -6,14 +6,15 @@ import config from '../config';
 import SystemService from '../services/system';
 import { celebrate, Joi } from 'celebrate';
 import UserService from '../services/user';
-import { t } from '../shared/i18n';
-import { isDefaultAuthInfo } from '../shared/auth';
-import { getUniqPath, handleLogPath, parseVersion } from '../config/util';
-import { findCronId } from '../shared/cronCommand';
+import {
+  getUniqPath,
+  handleLogPath,
+  parseVersion,
+  promiseExec,
+} from '../config/util';
 import dayjs from 'dayjs';
 import multer from 'multer';
 import { logStreamManager } from '../shared/logStreamManager';
-import { rateLimit } from 'express-rate-limit';

 const route = Router();
 const storage = multer.diskStorage({
@@ -37,7 +38,14 @@ export default (app: Router) => {
      const { version, changeLog, changeLogLink, publishTime } =
        await parseVersion(config.versionFile);

-      const isInitialized = !isDefaultAuthInfo(authInfo);
+      let isInitialized = true;
+      if (
+        Object.keys(authInfo).length === 2 &&
+        authInfo.username === 'admin' &&
+        authInfo.password === 'admin'
+      ) {
+        isInitialized = false;
+      }
      res.send({
        code: 200,
        data: {
@@ -205,17 +213,6 @@ export default (app: Router) => {
    },
  );

-  route.get(
-    '/update-status',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        res.send(await Container.get(SystemService).getUpgradeStatus());
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
  route.put(
    '/reload',
    celebrate({
@@ -257,7 +254,6 @@ export default (app: Router) => {

  route.put(
    '/command-run',
-    rateLimit({ windowMs: 60 * 1000, limit: 60 }),
    celebrate({
      body: Joi.object({
        command: Joi.string().required(),
@@ -267,13 +263,8 @@ export default (app: Router) => {
      try {
        const systemService = Container.get(SystemService);
        const command = req.body.command;
-        const crontab = await fs
-          .readFile(config.crontabFile, 'utf8')
-          .catch((e) => {
-            if (e.code === 'ENOENT') return '';
-            throw e;
-          });
-        const id = findCronId(crontab, command);
+        const idStr = `cat ${config.crontabFile} | grep -E "${command}" | perl -pe "s|.*ID=(.*) ${command}.*|\\1|" | head -1 | awk -F " " '{print $1}' | xargs echo -n`;
+        let id = await promiseExec(idStr);
        const uniqPath = await getUniqPath(command, id);
        const logTime = dayjs().format('YYYY-MM-DD-HH-mm-ss-SSS');
        const logPath = `${uniqPath}/${logTime}.log`;
@@ -287,13 +278,8 @@ export default (app: Router) => {
            },
            onEnd: async (cp, endTime, diff) => {
              // Close the stream after task completion
-              try {
-                await logStreamManager.closeStream(
-                  await handleLogPath(logPath),
-                );
-              } finally {
-                res.end();
-              }
+              await logStreamManager.closeStream(await handleLogPath(logPath));
+              res.end();
            },
            onError: async (message: string) => {
              res.write(message);
@@ -369,11 +355,6 @@ export default (app: Router) => {
      query: {
        startTime: Joi.string().allow('').optional(),
        endTime: Joi.string().allow('').optional(),
-        limit: Joi.number()
-          .integer()
-          .min(1)
-          .max(1024 * 1024)
-          .optional(),
        t: Joi.string().optional(),
      },
    }),
@@ -385,7 +366,6 @@ export default (app: Router) => {
          req.query as {
            startTime?: string;
            endTime?: string;
-            limit?: number;
          },
        );
      } catch (e) {
@@ -394,19 +374,6 @@ export default (app: Router) => {
    },
  );

-  route.get(
-    '/notify-log',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const systemService = Container.get(SystemService);
-        const data = await systemService.getNotifyLog();
-        res.send({ code: 200, data });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
  route.delete(
    '/log',
    async (req: Request, res: Response, next: NextFunction) => {
@@ -433,11 +400,8 @@ export default (app: Router) => {
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const userService = Container.get(UserService);
-        const result = await userService.resetAuthInfo(req.body);
-        if (result) {
-          return res.send(result);
-        }
-        res.send({ code: 200, message: t('更新成功') });
+        await userService.resetAuthInfo(req.body);
+        res.send({ code: 200, message: '更新成功' });
      } catch (e) {
        return next(e);
      }
@@ -462,42 +426,6 @@ export default (app: Router) => {
    },
  );

-  route.put(
-    '/config/lang',
-    celebrate({
-      body: Joi.object({
-        lang: Joi.string().allow('').allow(null),
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const systemService = Container.get(SystemService);
-        const result = await systemService.updateLanguage(req.body);
-        res.send(result);
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
-  route.put(
-    '/config/panel-title',
-    celebrate({
-      body: Joi.object({
-        panelTitle: Joi.string().max(100).allow('').allow(null),
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const systemService = Container.get(SystemService);
-        const result = await systemService.updatePanelTitle(req.body);
-        res.send(result);
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
  route.put(
    '/config/global-ssh-key',
    celebrate({
@@ -8,7 +8,6 @@ import path from 'path';
 import { v4 as uuidV4 } from 'uuid';
 import rateLimit from 'express-rate-limit';
 import config from '../config';
-import { t } from '../shared/i18n';
 import { isDemoEnv, getToken } from '../config/util';
 const route = Router();

@@ -22,25 +21,7 @@ const storage = multer.diskStorage({
    cb(null, key + ext);
  },
 });
-const upload = multer({
-  storage,
-  limits: { fileSize: 5 * 1024 * 1024, files: 1 },
-  fileFilter: (_req, file, cb) => {
-    const ext = path.extname(file.originalname).toLowerCase();
-    const imageTypes: Record<string, string> = {
-      '.png': 'image/png',
-      '.jpg': 'image/jpeg',
-      '.jpeg': 'image/jpeg',
-      '.gif': 'image/gif',
-      '.webp': 'image/webp',
-      '.avif': 'image/avif',
-    };
-    if (imageTypes[ext] !== file.mimetype) {
-      return cb(new Error(t('仅支持 PNG、JPEG、GIF、WebP、AVIF 图片')));
-    }
-    cb(null, true);
-  },
-});
+const upload = multer({ storage: storage });

 export default (app: Router) => {
  app.use('/user', route);
@@ -53,8 +34,8 @@ export default (app: Router) => {
    }),
    celebrate({
      body: Joi.object({
-        username: Joi.string().max(1024).required(),
-        password: Joi.string().max(1024).required(),
+        username: Joi.string().required(),
+        password: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -88,18 +69,18 @@ export default (app: Router) => {
    '/',
    celebrate({
      body: Joi.object({
-        username: Joi.string().max(1024).required(),
-        password: Joi.string().max(1024).required(),
+        username: Joi.string().required(),
+        password: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        if (isDemoEnv()) {
-          return res.send({ code: 450, message: t('未知错误') });
+          return res.send({ code: 450, message: '未知错误' });
        }
        const userService = Container.get(UserService);
-        const result = await userService.updateUsernameAndPassword(req.body);
-        res.send(result);
+        await userService.updateUsernameAndPassword(req.body);
+        res.send({ code: 200, message: '更新成功' });
      } catch (e) {
        return next(e);
      }
@@ -159,12 +140,12 @@ export default (app: Router) => {
  );

  route.put(
-    '/two-factor/deactivate',
+    '/two-factor/deactive',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
-        const data = await userService.deactivateTwoFactor();
+        const data = await userService.deactiveTwoFactor();
        res.send({ code: 200, data });
      } catch (e) {
        return next(e);
@@ -174,12 +155,11 @@ export default (app: Router) => {

  route.put(
    '/two-factor/login',
-    rateLimit({ windowMs: 15 * 60 * 1000, max: 20 }),
    celebrate({
      body: Joi.object({
        code: Joi.string().required(),
-        username: Joi.string().max(1024).required(),
-        password: Joi.string().max(1024).required(),
+        username: Joi.string().required(),
+        password: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -208,59 +188,6 @@ export default (app: Router) => {
    },
  );

-  route.get(
-    '/ip-blacklist',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const userService = Container.get(UserService);
-        const data = await userService.getIpBlacklist();
-        res.send({ code: 200, data });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
-  route.put(
-    '/ip-blacklist',
-    celebrate({
-      body: Joi.object({
-        ip: Joi.string()
-          .ip({ version: ['ipv4', 'ipv6'], cidr: 'forbidden' })
-          .required(),
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const userService = Container.get(UserService);
-        const data = await userService.blockIp(req.body.ip);
-        res.send({ code: 200, data, message: t('已加入 IP 黑名单') });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
-  route.delete(
-    '/ip-blacklist',
-    celebrate({
-      body: Joi.object({
-        ip: Joi.string()
-          .ip({ version: ['ipv4', 'ipv6'], cidr: 'forbidden' })
-          .required(),
-      }),
-    }),
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const userService = Container.get(UserService);
-        const data = await userService.unblockIp(req.body.ip);
-        res.send({ code: 200, data, message: t('已移出 IP 黑名单') });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
  route.get(
    '/notification',
    async (req: Request, res: Response, next: NextFunction) => {
@@ -291,19 +218,18 @@ export default (app: Router) => {

  route.put(
    '/init',
-    rateLimit({ windowMs: 15 * 60 * 1000, max: 20 }),
    celebrate({
      body: Joi.object({
-        username: Joi.string().max(1024).required(),
-        password: Joi.string().max(1024).required(),
+        username: Joi.string().required(),
+        password: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
-        const result = await userService.initializeUser(req.body);
-        res.send(result);
+        await userService.updateUsernameAndPassword(req.body);
+        res.send({ code: 200, message: '更新成功' });
      } catch (e) {
        return next(e);
      }
@@ -1,11 +1,13 @@
 import 'reflect-metadata';
 import cluster, { type Worker } from 'cluster';
-import type express from 'express';
+import compression from 'compression';
+import cors from 'cors';
+import express from 'express';
+import helmet from 'helmet';
 import { Container } from 'typedi';
 import config from './config';
 import Logger from './loaders/logger';
-import { errStack } from './shared/errors';
-import { initializeLanguageSync } from './shared/languageSync';
+import { monitoringMiddleware } from './middlewares/monitoring';
 import { type GrpcServerService } from './services/grpc';
 import { type HttpServerService } from './services/http';

@@ -17,48 +19,52 @@ interface WorkerMetadata {
 }

 class Application {
+  private app: express.Application;
  private httpServerService?: HttpServerService;
  private grpcServerService?: GrpcServerService;
  private isShuttingDown = false;
  private workerMetadataMap = new Map<number, WorkerMetadata>();
  private httpWorker?: Worker;

+  constructor() {
+    this.app = express();
+    // 创建一个全局中间件，删除查询参数中的t
+    this.app.use((req: express.Request, res: express.Response, next: express.NextFunction) => {
+      if (req.query.t) {
+        delete req.query.t;
+      }
+      next();
+    });
+  }
+
  async start() {
    try {
      if (cluster.isPrimary) {
        await this.initializeDatabase();
      }
-      await initializeLanguageSync();
      if (cluster.isPrimary) {
        this.startMasterProcess();
      } else {
        await this.startWorkerProcess();
      }
    } catch (error) {
-      Logger.error(`Failed to start application:\n${errStack(error)}`);
+      Logger.error('Failed to start application:', error);
      process.exit(1);
    }
  }

  private startMasterProcess() {
-    const readyTimeout =
-      process.arch === 'arm' &&
-      Number(
-        (process.config.variables as { arm_version?: string | number }).arm_version,
-      ) === 6
-        ? 120000
-        : 30000;
    // Fork gRPC worker first and wait for it to be ready
    const grpcWorker = this.forkWorker('grpc');
    
    // Wait for gRPC worker to signal it's ready before starting HTTP worker
-    this.waitForWorkerReady(grpcWorker, readyTimeout)
+    this.waitForWorkerReady(grpcWorker, 30000)
      .then(() => {
-        Logger.info('[boot] gRPC worker is ready, starting HTTP worker');
+        Logger.info('✌️ gRPC worker is ready, starting HTTP worker');
        this.httpWorker = this.forkWorker('http');
      })
      .catch((error) => {
-        Logger.error(`[boot] Failed to wait for gRPC worker:\n${errStack(error)}`);
+        Logger.error('✌️ Failed to wait for gRPC worker:', error);
        process.exit(1);
      });

@@ -67,39 +73,34 @@ class Application {
      if (metadata) {
        if (!this.isShuttingDown) {
          Logger.error(
-            `${metadata.serviceType} worker ${worker.process.pid} died (${signal || code
+            `✌️ ${metadata.serviceType} worker ${worker.process.pid} died (${signal || code
            }). Restarting...`,
          );
          // If gRPC worker died, restart it and wait for it to be ready
          if (metadata.serviceType === 'grpc') {
-            try {
-              this.httpWorker?.send('scheduler-unavailable');
-            } catch (error) {
-              Logger.warn('Unable to notify HTTP worker of scheduler exit');
-            }
            const newGrpcWorker = this.forkWorker('grpc');
-            this.waitForWorkerReady(newGrpcWorker, readyTimeout)
+            this.waitForWorkerReady(newGrpcWorker, 30000)
              .then(() => {
-                Logger.info('gRPC worker restarted and ready');
+                Logger.info('✌️ gRPC worker restarted and ready');
                // Re-register cron jobs by notifying the HTTP worker
                if (this.httpWorker) {
                  try {
                    this.httpWorker.send('reregister-crons');
-                    Logger.info('Sent reregister-crons message to HTTP worker');
+                    Logger.info('✌️ Sent reregister-crons message to HTTP worker');
                  } catch (error) {
-                    Logger.error(`Failed to send reregister-crons message:\n${errStack(error)}`);
+                    Logger.error('✌️ Failed to send reregister-crons message:', error);
                  }
                }
              })
              .catch((error) => {
-                Logger.error(`Failed to restart gRPC worker:\n${errStack(error)}`);
+                Logger.error('✌️ Failed to restart gRPC worker:', error);
                process.exit(1);
              });
          } else {
            // For HTTP worker, just restart it
            const newWorker = this.forkWorker(metadata.serviceType);
            this.httpWorker = newWorker;
-            Logger.info(`Restarted ${metadata.serviceType} worker (PID: ${newWorker.process.pid})`);
+            Logger.info(`✌️ Restarted ${metadata.serviceType} worker (PID: ${newWorker.process.pid})`);
          }
        }

@@ -130,14 +131,7 @@ class Application {
  }

  private forkWorker(serviceType: string): Worker {
-    const workerEnv: NodeJS.ProcessEnv = { SERVICE_TYPE: serviceType };
-    // PM2's fork launcher is inherited by our own cluster workers. Their APM
-    // messages go to this primary, not PM2, and duplicate its sampling work.
-    // Keep primary monitoring and allow restoring the inherited worker APM.
-    if (process.env.pm_id !== undefined && process.env.QL_WORKER_APM !== 'true') {
-      workerEnv.pmx = 'false';
-    }
-    const worker = cluster.fork(workerEnv);
+    const worker = cluster.fork({ SERVICE_TYPE: serviceType });

    this.workerMetadataMap.set(worker.id, {
      id: worker.id,
@@ -150,13 +144,17 @@ class Application {
  }

  private async initializeDatabase() {
-    const { runStartupProcess } = await import('./shared/startupProcess');
-    await runStartupProcess(require.resolve('./bootstrap/database'));
+    const dbLoader = await import('./loaders/db');
+    await dbLoader.default();
  }

-  private async setupMiddlewares(): Promise<express.Application> {
-    const { createHttpApplication } = await import('./loaders/httpApplication');
-    return createHttpApplication();
+  private setupMiddlewares() {
+    this.app.use(helmet({
+      contentSecurityPolicy: false,
+    }));
+    this.app.use(cors(config.cors));
+    this.app.use(compression());
+    this.app.use(monitoringMiddleware);
  }

  private setupMasterShutdown() {
@@ -171,14 +169,17 @@ class Application {
        if (worker) {
          const exitPromise = new Promise<void>((resolve) => {
            worker.once('exit', () => {
-              Logger.info(`Worker ${worker.process.pid} exited`);
+              Logger.info(`✌️ Worker ${worker.process.pid} exited`);
              resolve();
            });

            try {
              worker.send('shutdown');
            } catch (error) {
-              Logger.warn(`Failed to send shutdown to worker ${worker.process.pid}:\n${errStack(error)}`);
+              Logger.warn(
+                `✌️ Failed to send shutdown to worker ${worker.process.pid}:`,
+                error,
+              );
            }
          });

@@ -191,14 +192,14 @@ class Application {
          Promise.all(workerPromises),
          new Promise<void>((resolve) => {
            setTimeout(() => {
-              Logger.warn('Worker shutdown timeout reached');
+              Logger.warn('✌️ Worker shutdown timeout reached');
              resolve();
            }, 10000);
          }),
        ]);
        process.exit(0);
      } catch (error) {
-        Logger.error(`Error during worker shutdown:\n${errStack(error)}`);
+        Logger.error('✌️ Error during worker shutdown:', error);
        process.exit(1);
      }
    };
@@ -210,11 +211,11 @@ class Application {
  private async startWorkerProcess() {
    const serviceType = process.env.SERVICE_TYPE;
    if (!serviceType || !['http', 'grpc'].includes(serviceType)) {
-      Logger.error('[boot] Invalid SERVICE_TYPE:', serviceType);
+      Logger.error('✌️ Invalid SERVICE_TYPE:', serviceType);
      process.exit(1);
    }

-    Logger.info(`[boot] ${serviceType} worker started (PID: ${process.pid})`);
+    Logger.info(`✌️ ${serviceType} worker started (PID: ${process.pid})`);

    try {
      if (serviceType === 'http') {
@@ -225,26 +226,22 @@ class Application {

      process.send?.('ready');
    } catch (error) {
-      Logger.error(`[boot] ${serviceType} worker failed:\n${errStack(error)}`);
+      Logger.error(`✌️ ${serviceType} worker failed:`, error);
      process.exit(1);
    }
  }

  private async startHttpService() {
-    // 在导入任何 gRPC 客户端模块之前初始化 mTLS 证书
-    const { initGrpcCerts } = await import('./config/grpcCerts');
-    await initGrpcCerts();
-
-    const app = await this.setupMiddlewares();
+    this.setupMiddlewares();

    const { HttpServerService } = await import('./services/http');
    this.httpServerService = Container.get(HttpServerService);

    const appLoader = await import('./loaders/app');
-    await appLoader.default({ app });
+    await appLoader.default({ app: this.app });

    const server = await this.httpServerService.initialize(
-      app,
+      this.app,
      config.port,
    );

@@ -265,10 +262,17 @@ class Application {
    process.on('message', async (msg) => {
      if (msg === 'shutdown') {
        this.gracefulShutdown(serviceType);
-      } else if (serviceType === 'http' &&
-        (msg === 'reregister-crons' || msg === 'scheduler-unavailable')) {
-        const { default: cronClient } = await import('./schedule/client');
-        cronClient.readiness.invalidate();
+      } else if (msg === 'reregister-crons' && serviceType === 'http') {
+        // Re-register cron jobs when gRPC worker restarts
+        try {
+          Logger.info('✌️ Received reregister-crons message, re-registering cron jobs...');
+          const CronService = (await import('./services/cron')).default;
+          const cronService = Container.get(CronService);
+          await cronService.autosave_crontab();
+          Logger.info('✌️ Cron jobs re-registered successfully');
+        } catch (error) {
+          Logger.error('✌️ Failed to re-register cron jobs:', error);
+        }
      }
    });

@@ -289,7 +293,7 @@ class Application {
      }
      process.exit(0);
    } catch (error) {
-      Logger.error(`[${serviceType}] Error during shutdown:\n${errStack(error)}`);
+      Logger.error(`✌️ [${serviceType}] Error during shutdown:`, error);
      process.exit(1);
    }
  }
@@ -297,6 +301,6 @@ class Application {

 const app = new Application();
 app.start().catch((error) => {
-  Logger.error(`🙅‍♀️ Application failed to start:\n${errStack(error)}`);
+  Logger.error('🙅‍♀️ Application failed to start:', error);
  process.exit(1);
 });
@@ -1,23 +0,0 @@
-import { errStack } from '../shared/errors';
-// Also terminate if the primary disappears without forwarding a signal.
-const onParentDisconnect = () => process.exit(1);
-process.once('disconnect', onParentDisconnect);
-async function initializeDatabase() {
-  const { database } = await import('../data');
-  try {
-    const { default: loadDatabase } = await import('../loaders/db');
-    await loadDatabase();
-  } finally {
-    await database.close();
-  }
-}
-initializeDatabase()
-  .catch((error) => {
-    console.error(`[boot] Database initialization failed:\n${errStack(error)}`);
-    process.exitCode = 1;
-  })
-  .finally(() => {
-    process.removeListener('disconnect', onParentDisconnect);
-    // Let pending log writes drain and exit naturally after closing SQLite.
-    if (process.connected) process.disconnect();
-  });
@@ -1,141 +0,0 @@
-// A single, disposable backend process. Resolve startup dependencies, but never
-// run appLoader: its initData/initTask hooks install dependencies and start user work.
-import 'reflect-metadata';
-import dns from 'dns';
-import http from 'http';
-// The first scheduler connection can outlive its short RPC deadline. Let the
-// normal single-flight recovery finish within the supervised startup budget.
-async function waitForUpgradeScheduler(
-  readiness: {
-    recover(): Promise<boolean>;
-  },
-  timeoutMs: number,
-  retryMs = 250,
-) {
-  const deadline = Date.now() + timeoutMs;
-  do {
-    if (await readiness.recover()) return;
-    const remaining = deadline - Date.now();
-    if (remaining <= 0) break;
-    await new Promise((resolve) =>
-      setTimeout(resolve, Math.min(retryMs, remaining)),
-    );
-  } while (Date.now() < deadline);
-  throw new Error('Upgrade scheduler readiness failed');
-}
-async function probeUpgrade() {
-  if (!process.send || process.env.QL_UPGRADE_PROBE !== '1')
-    throw new Error('Upgrade probe requires its isolated supervisor');
-  dns.setDefaultResultOrder('ipv4first');
-  const { default: config } = await import('../config');
-  const { database } = await import('../data');
-  const { default: loadDatabase } = await import('../loaders/db');
-  const { Container } = await import('typedi');
-  const { GrpcServerService } = await import('../services/grpc');
-  const { HttpServerService } = await import('../services/http');
-  const { createHttpApplication } = await import('../loaders/httpApplication');
-  const { default: loadServer } = await import('../loaders/server');
-  const { default: loadExpress } = await import('../loaders/express');
-  await import('../loaders/app'); // Resolve normal startup hooks without running them.
-  const { default: inject } = await import('../loaders/depInjector');
-  const grpc = Container.get(GrpcServerService);
-  const server = Container.get(HttpServerService);
-  try {
-    await loadDatabase();
-    // Exercise an actual on-disk transaction as well as schema initialization.
-    await database.transaction(async () => {
-      await database.query('CREATE TABLE upgrade_probe (value INTEGER)');
-      await database.query('INSERT INTO upgrade_probe VALUES (42)');
-      const rows = await database.query('SELECT value FROM upgrade_probe');
-      if (
-        (
-          rows[0] as {
-            value: number;
-          }
-        )?.value !== 42
-      )
-        throw new Error('Upgrade database readback failed');
-    });
-    inject();
-    config.grpcPort = await grpc.initialize();
-    const { default: cronClient } = await import('../schedule/client');
-    cronClient.readiness.configure(async () => {});
-    await waitForUpgradeScheduler(
-      cronClient.readiness,
-      process.arch === 'arm' &&
-        Number(
-          (
-            process.config.variables as {
-              arm_version?: string | number;
-            }
-          ).arm_version,
-        ) === 6
-        ? 60000
-        : 10000,
-    );
-    const app = await createHttpApplication();
-    loadExpress({ app });
-    const listener = await server.initialize(app, 0);
-    await loadServer({ server: listener });
-    const address = listener.address();
-    if (!address || typeof address === 'string')
-      throw new Error('No probe HTTP port');
-    const health = await new Promise<any>((resolve, reject) => {
-      const request = http.get(
-        `http://127.0.0.1:${address.port}/api/health`,
-        (response) => {
-          let body = '';
-          response.on('data', (chunk) => {
-            body += chunk;
-          });
-          response.on('error', reject);
-          response.on('end', () => {
-            try {
-              const result = JSON.parse(body);
-              if (
-                response.statusCode !== 200 ||
-                result.code !== 200 ||
-                result.data?.status !== 'ok' ||
-                !result.data.services?.grpc ||
-                !result.data.services?.http
-              )
-                throw new Error('Upgrade HTTP/gRPC health check failed');
-              resolve(result.data);
-            } catch (error) {
-              reject(error);
-            }
-          });
-        },
-      );
-      request.setTimeout(10000, () =>
-        request.destroy(new Error('Upgrade health request timed out')),
-      );
-      request.on('error', reject);
-    });
-    process.send!({
-      type: 'upgrade-probe',
-      ok: true,
-      build: health.build,
-      memory: process.memoryUsage(),
-      pid: process.pid,
-    });
-  } finally {
-    await server.shutdown();
-    grpc.getServer().forceShutdown();
-    await database.close();
-  }
-}
-process.once('disconnect', () => process.exit(1));
-probeUpgrade()
-  .then(() => process.exit(0))
-  .catch((error) => {
-    process.send?.({
-      type: 'upgrade-probe',
-      ok: false,
-      code: error.code,
-      message: error.message,
-      stack: error.stack,
-    });
-    console.error(error);
-    process.exit(1);
-  });
@@ -1,5 +1,3 @@
-import { maybeSudo } from './container';
-
 export const LOG_END_SYMBOL = '　　　　　';

 export const TASK_COMMAND = 'task';
@@ -27,7 +25,6 @@ export const SAMPLE_FILES = [
 ];

 export const PYTHON_INSTALL_DIR = process.env.PYTHON_HOME;
-export const PYTHON_VENV_DIR = process.env.PYTHON_VENV_DIR;

 export const NotificationModeStringMap = {
  0: 'gotify',
@@ -51,8 +48,6 @@ export const NotificationModeStringMap = {
  18: 'chronocat',
  19: 'ntfy',
  20: 'wxPusherBot',
-  21: 'wxPusherSpt',
-  22: 'wpush',
 } as const;

 export const LINUX_DEPENDENCE_COMMAND: Record<
@@ -65,17 +60,17 @@ export const LINUX_DEPENDENCE_COMMAND: Record<
  }
 > = {
  Debian: {
-    install: maybeSudo('apt-get install -y'),
-    uninstall: maybeSudo('apt-get remove -y'),
-    info: maybeSudo('dpkg-query -s'),
+    install: 'apt-get install -y',
+    uninstall: 'apt-get remove -y',
+    info: 'dpkg-query -s',
    check(info: string) {
      return info.includes('install ok installed');
    },
  },
  Ubuntu: {
-    install: maybeSudo('apt-get install -y'),
-    uninstall: maybeSudo('apt-get remove -y'),
-    info: maybeSudo('dpkg-query -s'),
+    install: 'apt-get install -y',
+    uninstall: 'apt-get remove -y',
+    info: 'dpkg-query -s',
    check(info: string) {
      return info.includes('install ok installed');
    },
@@ -1,7 +0,0 @@
-export function isInContainer(): boolean {
-  return process.env.QL_CONTAINER === 'true';
-}
-
-export function maybeSudo(cmd: string): string {
-  return isInContainer() ? `sudo ${cmd}` : cmd;
-}
@@ -1,198 +0,0 @@
-import { execFileSync } from 'child_process';
-import * as fs from 'fs/promises';
-import path from 'path';
-import config from './index';
-import { fileExist } from './util';
-import Logger from '../loaders/logger';
-
-export interface GrpcTlsConfig {
-  caCert: string;
-  serverCert: string;
-  serverKey: string;
-  clientCert: string;
-  clientKey: string;
-}
-
-const certDir = path.join(config.configPath, 'grpc');
-const caKeyPath = path.join(certDir, 'ca.key');
-const caCertPath = path.join(certDir, 'ca.crt');
-const serverKeyPath = path.join(certDir, 'server.key');
-const serverCertPath = path.join(certDir, 'server.crt');
-const clientKeyPath = path.join(certDir, 'client.key');
-const clientCertPath = path.join(certDir, 'client.crt');
-
-let cachedConfig: GrpcTlsConfig | null = null;
-
-function run(args: string[]): string {
-  return execFileSync('openssl', args, {
-    stdio: 'pipe',
-    timeout: 30000,
-    encoding: 'utf-8',
-  }).trim();
-}
-
-async function generateAllCerts(): Promise<GrpcTlsConfig> {
-  Logger.info('[boot] Generating gRPC mTLS certificates...');
-  await fs.mkdir(certDir, { recursive: true, mode: 0o700 });
-  // Atomically reserve a private workspace for keys, CSRs and OpenSSL side files.
-  const workspace = await fs.mkdtemp(path.join(certDir, '.generate-'));
-  const caKeyTmp = path.join(workspace, 'ca.key');
-  const caCertTmp = path.join(workspace, 'ca.crt');
-  const serverKeyTmp = path.join(workspace, 'server.key');
-  const serverCsrTmp = path.join(workspace, 'server.csr');
-  const serverExtTmp = path.join(workspace, 'server.ext');
-  const clientKeyTmp = path.join(workspace, 'client.key');
-  const clientCsrTmp = path.join(workspace, 'client.csr');
-  const clientExtTmp = path.join(workspace, 'client.ext');
-
-  const cleanup = async () => {
-    await fs.rm(workspace, { recursive: true, force: true });
-  };
-
-  try {
-    run(['genrsa', '-out', caKeyTmp, '2048']);
-    run([
-      'req',
-      '-new',
-      '-x509',
-      '-days',
-      '3650',
-      '-key',
-      caKeyTmp,
-      '-out',
-      caCertTmp,
-      '-subj',
-      '/CN=qinglong-ca/O=qinglong/C=CN',
-    ]);
-    const caKey = await fs.readFile(caKeyTmp, 'utf-8');
-    const caCert = await fs.readFile(caCertTmp, 'utf-8');
-    await fs.writeFile(caKeyPath, caKey, { mode: 0o600 });
-
-    run(['genrsa', '-out', serverKeyTmp, '2048']);
-    run([
-      'req',
-      '-new',
-      '-key',
-      serverKeyTmp,
-      '-out',
-      serverCsrTmp,
-      '-subj',
-      '/CN=grpc-server',
-    ]);
-    await fs.writeFile(
-      serverExtTmp,
-      'subjectAltName=DNS:localhost,IP:127.0.0.1,IP:::1\n',
-    );
-    const serverCert = run([
-      'x509',
-      '-req',
-      '-days',
-      '3650',
-      '-in',
-      serverCsrTmp,
-      '-CA',
-      caCertTmp,
-      '-CAkey',
-      caKeyTmp,
-      '-CAserial',
-      path.join(workspace, 'ca.srl'),
-      '-CAcreateserial',
-      '-extfile',
-      serverExtTmp,
-    ]);
-    const serverKey = await fs.readFile(serverKeyTmp, 'utf-8');
-
-    run(['genrsa', '-out', clientKeyTmp, '2048']);
-    run([
-      'req',
-      '-new',
-      '-key',
-      clientKeyTmp,
-      '-out',
-      clientCsrTmp,
-      '-subj',
-      '/CN=grpc-client',
-    ]);
-    await fs.writeFile(clientExtTmp, 'extendedKeyUsage=clientAuth\n');
-    const clientCert = run([
-      'x509',
-      '-req',
-      '-days',
-      '3650',
-      '-in',
-      clientCsrTmp,
-      '-CA',
-      caCertTmp,
-      '-CAkey',
-      caKeyTmp,
-      '-CAserial',
-      path.join(workspace, 'ca.srl'),
-      '-CAcreateserial',
-      '-extfile',
-      clientExtTmp,
-    ]);
-    const clientKey = await fs.readFile(clientKeyTmp, 'utf-8');
-
-    Logger.info('[boot] gRPC mTLS certificates generated successfully');
-    return { caCert, serverCert, serverKey, clientCert, clientKey };
-  } finally {
-    await cleanup();
-  }
-}
-
-async function saveCerts(tlsConfig: GrpcTlsConfig): Promise<void> {
-  await fs.mkdir(certDir, { recursive: true });
-
-  await fs.writeFile(caCertPath, tlsConfig.caCert, { mode: 0o644 });
-  await fs.writeFile(serverCertPath, tlsConfig.serverCert, { mode: 0o644 });
-  await fs.writeFile(serverKeyPath, tlsConfig.serverKey, { mode: 0o600 });
-  await fs.writeFile(clientCertPath, tlsConfig.clientCert, { mode: 0o644 });
-  await fs.writeFile(clientKeyPath, tlsConfig.clientKey, { mode: 0o600 });
-
-  Logger.info(`[boot] gRPC mTLS certificates saved to ${certDir}`);
-}
-
-async function loadExistingCerts(): Promise<GrpcTlsConfig | null> {
-  const exists = await Promise.all([
-    fileExist(caCertPath),
-    fileExist(serverCertPath),
-    fileExist(serverKeyPath),
-    fileExist(clientCertPath),
-    fileExist(clientKeyPath),
-  ]);
-
-  if (exists.some((e) => !e)) {
-    return null;
-  }
-
-  const [caCert, serverCert, serverKey, clientCert, clientKey] = await Promise.all([
-    fs.readFile(caCertPath, 'utf-8'),
-    fs.readFile(serverCertPath, 'utf-8'),
-    fs.readFile(serverKeyPath, 'utf-8'),
-    fs.readFile(clientCertPath, 'utf-8'),
-    fs.readFile(clientKeyPath, 'utf-8'),
-  ]);
-
-  Logger.info('[boot] Loaded existing gRPC mTLS certificates from disk');
-  return { caCert, serverCert, serverKey, clientCert, clientKey };
-}
-
-export async function initGrpcCerts(): Promise<GrpcTlsConfig> {
-  if (cachedConfig) {
-    return cachedConfig;
-  }
-
-  let tlsConfig = await loadExistingCerts();
-
-  if (!tlsConfig) {
-    tlsConfig = await generateAllCerts();
-    await saveCerts(tlsConfig);
-  }
-
-  cachedConfig = tlsConfig;
-  return tlsConfig;
-}
-
-export function getGrpcCerts(): GrpcTlsConfig | null {
-  return cachedConfig;
-}
@@ -1,5 +1,6 @@
 import dotenv from 'dotenv';
 import path from 'path';
+import { createRandomString } from './share';

 dotenv.config({
  path: path.join(__dirname, '../../.env'),
@@ -8,8 +9,6 @@ dotenv.config({
 interface Config {
  port: number;
  grpcPort: number;
-  bindHost: string;
-  bindHostGrpc: string;
  nodeEnv: string;
  isDevelopment: boolean;
  isProduction: boolean;
@@ -32,8 +31,6 @@ interface Config {
 const config: Config = {
  port: parseInt(process.env.BACK_PORT || '5700', 10),
  grpcPort: parseInt(process.env.GRPC_PORT || '5500', 10),
-  bindHost: process.env.BIND_HOST || '::',
-  bindHostGrpc: process.env.BIND_HOST_GRPC || '::',
  nodeEnv: process.env.NODE_ENV || 'development',
  isDevelopment: process.env.NODE_ENV === 'development',
  isProduction: process.env.NODE_ENV === 'production',
@@ -67,19 +64,6 @@ if (!process.env.QL_DIR) {

 const lastVersionFile = `https://qn.whyour.cn/version.yaml`;

-// Get and normalize QlBaseUrl
-let baseUrl = process.env.QlBaseUrl || '';
-if (baseUrl) {
-  // Ensure it starts with /
-  if (!baseUrl.startsWith('/')) {
-    baseUrl = `/${baseUrl}`;
-  }
-  // Remove trailing slash for consistency in route definitions
-  if (baseUrl.endsWith('/')) {
-    baseUrl = baseUrl.slice(0, -1);
-  }
-}
-
 const rootPath = process.env.QL_DIR as string;
 const envFound = dotenv.config({ path: path.join(rootPath, '.env') });

@@ -109,7 +93,6 @@ const jsEnvFile = path.join(preloadPath, 'env.js');
 const pyEnvFile = path.join(preloadPath, 'env.py');
 const jsNotifyFile = path.join(preloadPath, '__ql_notify__.js');
 const pyNotifyFile = path.join(preloadPath, '__ql_notify__.py');
-const langEnvFile = path.join(preloadPath, 'lang_env.sh');
 const confFile = path.join(configPath, 'config.sh');
 const crontabFile = path.join(configPath, 'crontab.list');
 const authConfigFile = path.join(configPath, 'auth.json');
@@ -118,6 +101,8 @@ const confBakDir = path.join(dataPath, 'config/bak/');
 const sampleFile = path.join(samplePath, 'config.sample.sh');
 const sqliteFile = path.join(samplePath, 'database.sqlite');

+const authError = '错误的用户名密码，请重试';
+const loginFaild = '请先登录!';
 const configString = 'config sample crontab shareCode diy';
 const versionFile = path.join(rootPath, 'version.yaml');
 const dataTgzFile = path.join(tmpPath, 'data.tgz');
@@ -131,7 +116,6 @@ if (envFound.error) {
 export default {
  ...config,
  jwt: config.jwt,
-  baseUrl,
  rootPath,
  tmpPath,
  dataPath,
@@ -139,6 +123,8 @@ export default {
  shareShellFile,
  dependenceProxyFile,
  configString,
+  loginFaild,
+  authError,
  logPath,
  extraFile,
  authConfigFile,
@@ -151,7 +137,6 @@ export default {
  pyEnvFile,
  jsNotifyFile,
  pyNotifyFile,
-  langEnvFile,
  dbPath,
  uploadPath,
  configPath,
@@ -168,8 +153,6 @@ export default {
    'env.js',
    'env.py',
    'token.json',
-    'grpc',
-    '__pycache__',
  ],
  writePathList: [configPath, scriptPath],
  bakPath,
@@ -1,5 +1,3 @@
-import { randomInt } from 'crypto';
-
 export function createRandomString(min: number, max: number): string {
  const num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
  const english = [
@@ -67,20 +65,20 @@ export function createRandomString(min: number, max: number): string {
  arr.push(getOne(ENGLISH));
  arr.push(getOne(special));

-  const len = min + randomInt(max - min + 1);
+  const len = min + Math.floor(Math.random() * (max - min + 1));

  for (let i = 4; i < len; i++) {
-    arr.push(config[randomInt(config.length)]);
+    arr.push(config[Math.floor(Math.random() * config.length)]);
  }

  const newArr = [];
  for (let j = 0; j < len; j++) {
-    newArr.push(arr.splice(randomInt(arr.length), 1)[0]);
+    newArr.push(arr.splice(Math.random() * arr.length, 1)[0]);
  }

  function getOne(arr: any[]) {
-    return arr[randomInt(arr.length)];
+    return arr[Math.floor(Math.random() * arr.length)];
  }

  return newArr.join('');
-}
+}
@@ -1,7 +1,5 @@
 import { Subscription } from '../data/subscription';
 import isNil from 'lodash/isNil';
-import { shellQuote } from '../shared/shellQuote';
-import { getSubscriptionSshAlias } from '../shared/subscriptionPath';

 export function formatUrl(doc: Subscription) {
  let url = doc.url;
@@ -9,7 +7,7 @@ export function formatUrl(doc: Subscription) {
  if (doc.type === 'private-repo') {
    if (doc.pull_type === 'ssh-key') {
      host = doc.url!.replace(/.*\@([^\:]+)\:.*/, '$1');
-      url = doc.url!.replace(host, getSubscriptionSshAlias(doc.alias));
+      url = doc.url!.replace(host, doc.alias);
    } else {
      host = doc.url!.replace(/.*\:\/\/([^\/]+)\/.*/, '$1');
      const { username, password } = doc.pull_option as any;
@@ -20,24 +18,29 @@ export function formatUrl(doc: Subscription) {
 }

 export function formatCommand(doc: Subscription, url?: string) {
-  const args =
-    doc.type === 'file'
-      ? ['raw', url || formatUrl(doc).url, doc.proxy || '']
-      : [
-          'repo',
-          url || formatUrl(doc).url,
-          doc.whitelist || '',
-          doc.blacklist || '',
-          doc.dependences || '',
-          doc.branch || '',
-          doc.extensions || '',
-          doc.proxy || '',
-        ];
-  args.push(
-    String(isNil(doc.autoAddCron) ? true : Boolean(doc.autoAddCron)),
-    String(isNil(doc.autoDelCron) ? true : Boolean(doc.autoDelCron)),
-  );
-  return `SUB_ID=${shellQuote(String(doc.id))} ql ${args
-    .map((arg) => shellQuote(arg!))
-    .join(' ')}`;
+  let command = `SUB_ID=${doc.id} ql `;
+  let _url = url || formatUrl(doc).url;
+  const {
+    type,
+    whitelist,
+    blacklist,
+    dependences,
+    branch,
+    extensions,
+    proxy,
+    autoAddCron,
+    autoDelCron,
+  } = doc;
+  if (type === 'file') {
+    command += `raw "${_url}" "${proxy || ''}" "${
+      isNil(autoAddCron) ? true : Boolean(autoAddCron)
+    }" "${isNil(autoDelCron) ? true : Boolean(autoDelCron)}"`;
+  } else {
+    command += `repo "${_url}" "${whitelist || ''}" "${blacklist || ''}" "${
+      dependences || ''
+    }" "${branch || ''}" "${extensions || ''}" "${proxy || ''}" "${
+      isNil(autoAddCron) ? true : Boolean(autoAddCron)
+    }" "${isNil(autoDelCron) ? true : Boolean(autoDelCron)}"`;
+  }
+  return command;
 }
@@ -1,56 +1,21 @@
 import * as fs from 'fs/promises';
-import { statSync } from 'fs';
 import * as path from 'path';
-import { exec, execSync } from 'child_process';
+import { exec } from 'child_process';
 import psTreeFun from 'ps-tree';
 import { promisify } from 'util';
 import { load } from 'js-yaml';
 import config from './index';
-import { PYTHON_INSTALL_DIR, PYTHON_VENV_DIR, TASK_COMMAND } from './const';
+import { PYTHON_INSTALL_DIR, TASK_COMMAND } from './const';
 import Logger from '../loaders/logger';
 import { writeFileWithLock } from '../shared/utils';
 import { DependenceTypes } from '../data/dependence';
 import { FormData } from 'undici';
 import os from 'os';
-import { maybeSudo, isInContainer } from './container';
-import { shellQuote } from '../shared/shellQuote';
-import { resolveFileAccess } from '../shared/fileAccess';
-import {
-  mirrorWriteCommand,
-  normalizeMirror,
-  rewriteMirrorSources,
-} from '../shared/linuxMirror';

 export * from './share';

 let osType: 'Debian' | 'Ubuntu' | 'Alpine' | undefined;

-function getOsTypeSync(): 'Debian' | 'Ubuntu' | 'Alpine' | undefined {
-  // 1. 环境变量覆盖
-  const envOs = process.env.QL_OS_TYPE?.toLowerCase();
-  if (envOs === 'alpine') return 'Alpine';
-  if (envOs === 'debian') return 'Debian';
-  if (envOs === 'ubuntu') return 'Ubuntu';
-
-  // 2. 模块缓存（由 detectOS 设置）
-  if (osType) return osType;
-
-  // 3. 能力检测：检查包管理器二进制
-  try {
-    execSync('which apt-get', { stdio: 'ignore' });
-    return 'Debian';
-  } catch {
-    try {
-      execSync('which apk', { stdio: 'ignore' });
-      return 'Alpine';
-    } catch {
-      // macOS / 未知系统
-    }
-  }
-
-  return undefined;
-}
-
 export async function getFileContentByName(fileName: string) {
  const _exsit = await fileExist(fileName);
  if (_exsit) {
@@ -152,8 +117,7 @@ export async function handleLogPath(
  logPath: string,
  data: string = '',
 ): Promise<string> {
-  const absolutePath = resolveFileAccess(config.logPath, [logPath]);
-  if (!absolutePath) throw new Error('Log path is outside the log directory');
+  const absolutePath = path.resolve(config.logPath, logPath);
  const logFileExist = await fileExist(absolutePath);
  if (!logFileExist) {
    await createFile(absolutePath, data);
@@ -223,105 +187,48 @@ export function dirSort(a: IFile, b: IFile): number {
  }
 }

-const FILE_SYSTEM_READ_CONCURRENCY = 32;
-
-type FileSystemTaskRunner = <T>(task: () => Promise<T>) => Promise<T>;
-
-function createFileSystemTaskRunner(concurrency: number): FileSystemTaskRunner {
-  let activeCount = 0;
-  const queue: Array<() => void> = [];
-
-  const runNext = () => {
-    while (activeCount < concurrency && queue.length > 0) {
-      activeCount += 1;
-      queue.shift()?.();
-    }
-  };
-
-  return <T>(task: () => Promise<T>) =>
-    new Promise<T>((resolve, reject) => {
-      queue.push(() => {
-        task()
-          .then(resolve, reject)
-          .finally(() => {
-            activeCount -= 1;
-            runNext();
-          });
-      });
-      runNext();
-    });
-}
-
-async function readDirsWithRunner(
-  dir: string,
-  baseDir: string,
-  blacklist: string[],
-  sort: (a: IFile, b: IFile) => number,
-  runFileSystemTask: FileSystemTaskRunner,
-): Promise<IFile[]> {
-  const relativePath = path.relative(baseDir, dir);
-  const entries = await runFileSystemTask(() =>
-    fs.readdir(dir, { withFileTypes: true }),
-  );
-
-  const items = await Promise.all(
-    entries.map(async (entry): Promise<IFile | undefined> => {
-      if (blacklist.includes(entry.name) || entry.isSymbolicLink()) {
-        return undefined;
-      }
-
-      const subPath = path.join(dir, entry.name);
-      const stats = await runFileSystemTask(() => fs.lstat(subPath));
-      if (stats.isSymbolicLink()) {
-        return undefined;
-      }
-      const key = path.join(relativePath, entry.name);
-
-      if (stats.isDirectory()) {
-        const children = await readDirsWithRunner(
-          subPath,
-          baseDir,
-          blacklist,
-          sort,
-          runFileSystemTask,
-        );
-        return {
-          title: entry.name,
-          key,
-          type: 'directory',
-          parent: relativePath,
-          createTime: stats.birthtime.getTime(),
-          children,
-        };
-      }
-
-      return {
-        title: entry.name,
-        type: 'file',
-        key,
-        parent: relativePath,
-        size: stats.size,
-        createTime: stats.birthtime.getTime(),
-      };
-    }),
-  );
-
-  return items.filter((item): item is IFile => Boolean(item)).sort(sort);
-}
-
 export async function readDirs(
  dir: string,
  baseDir: string = '',
  blacklist: string[] = [],
  sort: (a: IFile, b: IFile) => number = dirSort,
 ): Promise<IFile[]> {
-  return readDirsWithRunner(
-    dir,
-    baseDir,
-    blacklist,
-    sort,
-    createFileSystemTaskRunner(FILE_SYSTEM_READ_CONCURRENCY),
-  );
+  const relativePath = path.relative(baseDir, dir);
+  const files = await fs.readdir(dir);
+  const result: IFile[] = [];
+
+  for (const file of files) {
+    const subPath = path.join(dir, file);
+    const stats = await fs.lstat(subPath);
+    const key = path.join(relativePath, file);
+
+    if (blacklist.includes(file) || stats.isSymbolicLink()) {
+      continue;
+    }
+
+    if (stats.isDirectory()) {
+      const children = await readDirs(subPath, baseDir, blacklist, sort);
+      result.push({
+        title: file,
+        key,
+        type: 'directory',
+        parent: relativePath,
+        createTime: stats.birthtime.getTime(),
+        children: children.sort(sort),
+      });
+    } else {
+      result.push({
+        title: file,
+        type: 'file',
+        key,
+        parent: relativePath,
+        size: stats.size,
+        createTime: stats.birthtime.getTime(),
+      });
+    }
+  }
+
+  return result.sort(sort);
 }

 export async function readDir(
@@ -329,10 +236,7 @@ export async function readDir(
  baseDir: string = '',
  blacklist: string[] = [],
 ): Promise<IFile[]> {
-  const absoluteDir = path.resolve(baseDir, dir);
-  if (!absoluteDir.startsWith(path.resolve(baseDir))) {
-    return [];
-  }
+  const absoluteDir = path.join(baseDir, dir);
  const relativePath = path.relative(baseDir, absoluteDir);

  try {
@@ -496,69 +400,18 @@ export function psTree(pid: number): Promise<number[]> {
  });
 }

-export async function killTask(pid: number, waitForExit = false) {
-  const descendants = await psTree(pid);
-  const signal = (target: number, sig: NodeJS.Signals) => {
+export async function killTask(pid: number) {
+  const pids = await psTree(pid);
+
+  if (pids.length) {
    try {
-      process.kill(target, sig);
-    } catch (error: any) {
-      if (error.code !== 'ESRCH') throw error;
-    }
-  };
-  if (!waitForExit) {
-    if (descendants.length) {
-      // A child may exit after psTree; keep signalling the remaining tree.
-      for (const target of [pid, ...descendants].reverse()) {
-        signal(target, 'SIGTERM');
-      }
-    } else signal(pid, 'SIGINT');
-    return;
+      [pid, ...pids].reverse().forEach((x) => {
+        process.kill(x, 15);
+      });
+    } catch (error) {}
+  } else {
+    process.kill(pid, 2);
  }
-  const pids = [...descendants.reverse(), pid];
-  for (const target of pids) signal(target, 'SIGTERM');
-  const alive = async (target: number) => {
-    try {
-      process.kill(target, 0);
-    } catch (error: any) {
-      if (error.code === 'ESRCH') return false;
-      throw error;
-    }
-    if (process.platform === 'linux') {
-      try {
-        const stat = await fs.readFile(`/proc/${target}/stat`, 'utf8');
-        // The command field may contain spaces and parentheses. Zombies have
-        // exited even while their parent has not reaped the PID yet.
-        const state = stat.slice(stat.lastIndexOf(')') + 2).split(' ')[0];
-        if (['Z', 'X', 'x'].includes(state)) return false;
-      } catch {
-        // /proc may be unavailable, or the process may have just exited.
-        // Retain the portable signal probe rather than assuming it is dead.
-        try {
-          process.kill(target, 0);
-        } catch (error: any) {
-          if (error.code === 'ESRCH') return false;
-          throw error;
-        }
-      }
-    }
-    return true;
-  };
-  const wait = async () => {
-    const deadline = Date.now() + 1000;
-    let remaining = pids;
-    while (true) {
-      const states = await Promise.all(remaining.map(alive));
-      remaining = remaining.filter((_, index) => states[index]);
-      if (!remaining.length || Date.now() >= deadline) return remaining;
-      await new Promise((resolve) => setTimeout(resolve, 20));
-    }
-  };
-  let remaining = await wait();
-  if (!remaining.length) return;
-  for (const target of remaining) signal(target, 'SIGKILL');
-  remaining = await wait();
-  if (remaining.length)
-    throw new Error(`Task processes did not exit: ${remaining.join(', ')}`);
 }

 export async function getPid(cmd: string) {
@@ -653,13 +506,11 @@ export function safeJSONParse(value?: string) {
  try {
    return JSON.parse(value);
  } catch (error) {
-    Logger.error('[safeJSONParse error]', error);
+    Logger.error('[safeJSONParse失败]', error);
    return {};
  }
 }

-export { errStack } from '../shared/errors';
-
 export async function rmPath(path: string) {
  try {
    const _exsit = await fileExist(path);
@@ -667,7 +518,7 @@ export async function rmPath(path: string) {
      await fs.rm(path, { force: true, recursive: true, maxRetries: 5 });
    }
  } catch (error) {
-    Logger.error('[rmPath error]', error);
+    Logger.error('[rmPath失败]', error);
  }
 }

@@ -677,189 +528,65 @@ export async function setSystemTimezone(timezone: string): Promise<boolean> {
      throw new Error('Invalid timezone');
    }

-    await promiseExec(
-      maybeSudo(`ln -sf /usr/share/zoneinfo/${timezone} /etc/localtime`),
-    );
-    await promiseExec(`echo "${timezone}" | ${maybeSudo('tee /etc/timezone')}`);
+    await promiseExec(`ln -sf /usr/share/zoneinfo/${timezone} /etc/localtime`);
+    await promiseExec(`echo "${timezone}" > /etc/timezone`);

    return true;
  } catch (error) {
-    Logger.error('[setSystemTimezone error]', error);
+    Logger.error('[setSystemTimezone失败]', error);
    return false;
  }
 }

-// Helper function to check if a name is a GitHub URL
-function getPythonExecutable(): string {
-  return PYTHON_VENV_DIR
-    ? shellQuote(path.resolve(config.rootPath, PYTHON_VENV_DIR, 'bin/python3'))
-    : 'python3';
-}
-
-function getPythonPip(): string {
-  return PYTHON_VENV_DIR ? `${getPythonExecutable()} -m pip` : 'pip3';
-}
-
-function isGitHubUrl(name: string): boolean {
-  // Support git+https://, git+http://, https://, and http:// URLs
-  // This covers GitHub URLs and other git-compatible repositories
-  return !!name.match(/^(git\+https?:\/\/|https?:\/\/)/i);
-}
-
-// Helper function to check if a name is a requirements file
-function isRequirementsFile(name: string): boolean {
-  return !!name.match(/requirements.*\.(txt|in)$/i);
-}
-
-// Helper function to check if a name is a pyproject.toml file
-function isPyprojectToml(name: string): boolean {
-  return name.endsWith('pyproject.toml');
-}
-
-export function isPythonSourceDependency(name: string): boolean {
-  const source = name.trim();
-  return (
-    isGitHubUrl(source) || isRequirementsFile(source) || isPyprojectToml(source)
-  );
-}
-
 export function getGetCommand(type: DependenceTypes, name: string): string {
-  const trimmedName = name.trim();
-
-  // For Python dependencies installed from GitHub or requirements files,
-  // we can't reliably check if they're installed, so skip the check
-  if (type === DependenceTypes.python3) {
-    if (isPythonSourceDependency(trimmedName)) {
-      // Return a command that will always indicate not installed
-      // This ensures GitHub URLs and requirements files are always installed
-      return 'echo ""';
-    }
-  }
-
  const baseCommands = {
-    [DependenceTypes.nodejs]: `pnpm ls -g  | grep "${trimmedName}" | head -1`,
-    [DependenceTypes.python3]: `${getPythonExecutable()} -c ${shellQuote(
-      `from importlib.metadata import version, PackageNotFoundError
-import importlib.util
-import sys
+    [DependenceTypes.nodejs]: `pnpm ls -g  | grep "${name}" | head -1`,
+    [DependenceTypes.python3]: `
+    python3 -c "exec('''
+name='${name}'
 try:
- try:
-  from packaging.requirements import Requirement
- except ImportError:
-  from pip._vendor.packaging.requirements import Requirement
- requirement = Requirement(sys.argv[1])
- if requirement.marker and not requirement.marker.evaluate():
-  print('not applicable')
- else:
-  try:
-   installed = version(requirement.name)
-  except PackageNotFoundError:
-   if not requirement.specifier and not requirement.extras and not requirement.url:
-    if importlib.util.find_spec(requirement.name):
-     print(requirement.name)
-  else:
-   if requirement.specifier.contains(installed, prereleases=True):
-    print(installed)
-except Exception:
- pass`,
-    )} ${shellQuote(trimmedName)}`,
-    [DependenceTypes.linux]:
-      getOsTypeSync() === 'Alpine'
-        ? `apk info -es ${trimmedName}`
-        : maybeSudo(`dpkg-query -s ${trimmedName}`),
+    from importlib.metadata import version
+    print(version(name))
+except:
+    import importlib.util as u
+    import importlib.metadata as m
+    spec=u.find_spec(name)
+    print(name if spec else '')
+''')"`,
+    [DependenceTypes.linux]: `apt-get info ${name}`,
  };

  return baseCommands[type];
 }

 export function getInstallCommand(type: DependenceTypes, name: string): string {
-  if (type === DependenceTypes.python3) {
-    const prefix =
-      PYTHON_INSTALL_DIR && !PYTHON_VENV_DIR
-        ? ` --prefix=${shellQuote(PYTHON_INSTALL_DIR)}`
-        : '';
-    const pip = `${getPythonPip()} install --disable-pip-version-check${
-      PYTHON_VENV_DIR ? '' : ' --root-user-action=ignore'
-    }${prefix}`;
-    name = name.trim();
-    if (isRequirementsFile(name) || isPyprojectToml(name)) {
-      const file = [config.scriptPath, config.repoPath]
-        .filter(Boolean)
-        .map((root) => resolveFileAccess(root, [name]))
-        .find((file) => {
-          if (!file) return false;
-          try {
-            return statSync(file).isFile();
-          } catch {
-            return false;
-          }
-        });
-      if (!file)
-        throw new Error(
-          'Python dependency file must be inside scripts or repo',
-        );
-      return isRequirementsFile(name)
-        ? `${pip} -r ${shellQuote(file)}`
-        : `${pip} ${shellQuote(path.dirname(file))}`;
-    }
-    return `${pip} -- ${shellQuote(name)}`;
-  }
  const baseCommands = {
    [DependenceTypes.nodejs]: 'pnpm add -g',
-    [DependenceTypes.linux]:
-      getOsTypeSync() === 'Alpine'
-        ? 'apk add --no-check-certificate'
-        : maybeSudo('apt-get install -y'),
+    [DependenceTypes.python3]:
+      'pip3 install --disable-pip-version-check --root-user-action=ignore',
+    [DependenceTypes.linux]: 'apt install -y',
  };
-  return `${baseCommands[type]} ${name.trim()}`;
+
+  let command = baseCommands[type];
+
+  if (type === DependenceTypes.python3 && PYTHON_INSTALL_DIR) {
+    command = `${command} --prefix=${PYTHON_INSTALL_DIR}`;
+  }
+
+  return `${command} ${name.trim()}`;
 }

 export function getUninstallCommand(
  type: DependenceTypes,
  name: string,
 ): string {
-  if (type === DependenceTypes.python3) {
-    name = name.trim();
-    if (isRequirementsFile(name)) {
-      const file = [config.scriptPath, config.repoPath]
-        .filter(Boolean)
-        .map((root) => resolveFileAccess(root, [name]))
-        .find((file) => {
-          if (!file) return false;
-          try {
-            return statSync(file).isFile();
-          } catch {
-            return false;
-          }
-        });
-      if (!file)
-        throw new Error(
-          'Python dependency file must be inside scripts or repo',
-        );
-      return `${getPythonPip()} uninstall --disable-pip-version-check${
-        PYTHON_VENV_DIR ? '' : ' --root-user-action=ignore'
-      } -y -r ${shellQuote(file)}`;
-    }
-    if (isPyprojectToml(name) || isGitHubUrl(name)) {
-      // A source URL/project can install several distributions and has no safe
-      // inverse. Removing its panel entry leaves installed packages intact.
-      return `printf '%s\\n' ${shellQuote(
-        'Remove installed Python distributions separately by package name.',
-      )}`;
-    }
-    const packageName =
-      name.match(
-        /^([A-Za-z0-9][A-Za-z0-9._-]*)(?:\[[^\]]+\])?(?=\s*(?:[<>=!~;@]|$))/,
-      )?.[1] || name;
-    return `${getPythonPip()} uninstall --disable-pip-version-check${
-      PYTHON_VENV_DIR ? '' : ' --root-user-action=ignore'
-    } -y -- ${shellQuote(packageName)}`;
-  }
  const baseCommands = {
    [DependenceTypes.nodejs]: 'pnpm remove -g',
-    [DependenceTypes.linux]:
-      getOsTypeSync() === 'Alpine' ? 'apk del' : maybeSudo('apt-get remove -y'),
+    [DependenceTypes.python3]:
+      'pip3 uninstall --disable-pip-version-check --root-user-action=ignore -y',
+    [DependenceTypes.linux]: 'apt remove -y',
  };
+
  return `${baseCommands[type]} ${name.trim()}`;
 }

@@ -892,21 +619,6 @@ export async function detectOS(): Promise<
  'Debian' | 'Ubuntu' | 'Alpine' | undefined
 > {
  if (osType) return osType;
-
-  const envOs = process.env.QL_OS_TYPE?.toLowerCase();
-  if (envOs === 'alpine') {
-    osType = 'Alpine';
-    return osType;
-  }
-  if (envOs === 'debian') {
-    osType = 'Debian';
-    return osType;
-  }
-  if (envOs === 'ubuntu') {
-    osType = 'Ubuntu';
-    return osType;
-  }
-
  const platform = os.platform();

  if (platform === 'linux') {
@@ -931,73 +643,89 @@ export async function detectOS(): Promise<
  return osType;
 }

+async function getCurrentMirrorDomain(
+  filePath: string,
+): Promise<string | null> {
+  const fileContent = await fs.readFile(filePath, 'utf8');
+  const lines = fileContent.split('\n');
+  for (const line of lines) {
+    if (line.trim().startsWith('#')) {
+      continue;
+    }
+    const match = line.match(/https?:\/\/[^\/]+/);
+    if (match) {
+      return match[0];
+    }
+  }
+  return null;
+}
+
+async function replaceDomainInFile(
+  filePath: string,
+  oldDomainWithScheme: string,
+  newDomainWithScheme: string,
+): Promise<void> {
+  let fileContent = await fs.readFile(filePath, 'utf8');
+  let updatedContent = fileContent.replace(
+    new RegExp(oldDomainWithScheme, 'g'),
+    newDomainWithScheme,
+  );
+
+  if (!newDomainWithScheme.endsWith('/')) {
+    newDomainWithScheme += '/';
+  }
+
+  await writeFileWithLock(filePath, updatedContent);
+}
+
 async function _updateLinuxMirror(
  osType: string,
-  mirror: string,
+  mirrorDomainWithScheme: string,
 ): Promise<string> {
-  const defaults: Record<string, string> = {
-    Debian: 'http://deb.debian.org/debian',
-    Ubuntu: 'http://archive.ubuntu.com/ubuntu',
-    Alpine: 'http://dl-cdn.alpinelinux.org/alpine',
-  };
-  if (!defaults[osType])
-    throw new Error('Unsupported OS type for updating mirrors.');
-  const target = mirror || defaults[osType];
-  normalizeMirror(target);
-  const S = osType !== 'Alpine' && isInContainer() ? 'sudo ' : '';
-  const update =
-    osType === 'Alpine' ? 'apk update' : `${S}apt-get update --error-on=any`;
-  let file =
-    osType === 'Alpine'
-      ? '/etc/apk/repositories'
-      : `/etc/apt/sources.list.d/${osType.toLowerCase()}.sources`;
-  let content = '';
-  try {
-    content = await fs.readFile(file, 'utf8');
-  } catch (error: any) {
-    if (error.code !== 'ENOENT') throw error;
-    if (osType !== 'Alpine') {
-      try {
-        file = '/etc/apt/sources.list';
-        content = await fs.readFile(file, 'utf8');
-      } catch (legacyError: any) {
-        if (legacyError.code !== 'ENOENT') throw legacyError;
-        file = `/etc/apt/sources.list.d/${osType.toLowerCase()}.sources`;
+  let filePath: string, currentDomainWithScheme: string | null;
+  switch (osType) {
+    case 'Debian':
+      filePath = '/etc/apt/sources.list.d/debian.sources';
+      currentDomainWithScheme = await getCurrentMirrorDomain(filePath);
+      if (currentDomainWithScheme) {
+        await replaceDomainInFile(
+          filePath,
+          currentDomainWithScheme,
+          mirrorDomainWithScheme || 'http://deb.debian.org',
+        );
+        return 'apt-get update';
+      } else {
+        throw Error(`Current mirror domain not found.`);
      }
-    }
+    case 'Ubuntu':
+      filePath = '/etc/apt/sources.list.d/ubuntu.sources';
+      currentDomainWithScheme = await getCurrentMirrorDomain(filePath);
+      if (currentDomainWithScheme) {
+        await replaceDomainInFile(
+          filePath,
+          currentDomainWithScheme,
+          mirrorDomainWithScheme || 'http://archive.ubuntu.com',
+        );
+        return 'apt-get update';
+      } else {
+        throw Error(`Current mirror domain not found.`);
+      }
+    case 'Alpine':
+      filePath = '/etc/apk/repositories';
+      currentDomainWithScheme = await getCurrentMirrorDomain(filePath);
+      if (currentDomainWithScheme) {
+        await replaceDomainInFile(
+          filePath,
+          currentDomainWithScheme,
+          mirrorDomainWithScheme || 'http://dl-cdn.alpinelinux.org',
+        );
+        return 'apk update';
+      } else {
+        throw Error(`Current mirror domain not found.`);
+      }
+    default:
+      throw Error('Unsupported OS type for updating mirrors.');
  }
-  if (!content.trim()) {
-    const release = await fs.readFile('/etc/os-release', 'utf8');
-    if (osType === 'Alpine') {
-      const version = release.match(/^VERSION_ID=["']?(\d+\.\d+)/m)?.[1];
-      if (!version)
-        throw new Error('Cannot determine Alpine repository version');
-      content = `${defaults.Alpine}/v${version}/main\n${defaults.Alpine}/v${version}/community\n`;
-    } else {
-      // The fallback may have read an empty legacy .list. Deb822 stanzas must
-      // be written to a .sources file, leaving the legacy file untouched.
-      file = `/etc/apt/sources.list.d/${osType.toLowerCase()}.sources`;
-      const codename = release.match(/^VERSION_CODENAME=["']?([\w-]+)/m)?.[1];
-      if (!codename)
-        throw new Error('Cannot determine APT repository codename');
-      const ubuntu = osType === 'Ubuntu';
-      content = `Types: deb\nURIs: ${
-        defaults[osType]
-      }\nSuites: ${codename} ${codename}-updates${
-        ubuntu ? ` ${codename}-backports` : ''
-      }\nComponents: ${
-        ubuntu ? 'main restricted universe multiverse' : 'main'
-      }\nSigned-By: /usr/share/keyrings/${osType.toLowerCase()}-archive-keyring.gpg\n`;
-      if (!ubuntu)
-        content += `\nTypes: deb\nURIs: http://security.debian.org/debian-security\nSuites: ${codename}-security\nComponents: main\nSigned-By: /usr/share/keyrings/debian-archive-keyring.gpg\n`;
-    }
-  }
-  return mirrorWriteCommand(
-    file,
-    rewriteMirrorSources(content, target),
-    S,
-    update,
-  );
 }

 export async function updateLinuxMirrorFile(mirror: string): Promise<string> {
@@ -1,28 +0,0 @@
-import { EventEmitter } from 'events';
-import { database } from '.';
-import { DatabaseClient } from './databaseClient';
-
-// Keep the existing Keyv serialization and namespace. Only its SQLite transport
-// changes; old cached authentication records remain readable in either version.
-export class CacheStore extends EventEmitter {
-  readonly opts = { dialect: 'sqlite' };
-  namespace?: string;
-  constructor(private client: () => DatabaseClient = () => database) {
-    super();
-  }
-  get(key: string): Promise<string | undefined> {
-    return this.client().request('cache', 'get', key);
-  }
-  async set(key: string, value: string) {
-    return this.client().request('cache', 'set', key, value);
-  }
-  async delete(key: string): Promise<boolean> {
-    return this.client().request('cache', 'delete', key);
-  }
-  async clear(): Promise<void> {
-    throw new Error('Clearing all authentication namespaces is not supported');
-  }
-  async disconnect(): Promise<void> {
-    /* The shared database client owns the worker. */
-  }
-}
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { sequelize } from '.';
+import { DataTypes, Model, ModelDefined } from 'sequelize';

 export class Crontab {
  name?: string;
@@ -12,7 +13,6 @@ export class Crontab {
  pid?: number;
  isDisabled?: 1 | 0;
  log_path?: string;
-  queued_token?: string | null;
  isPinned?: 1 | 0;
  labels?: string[];
  last_running_time?: number;
@@ -23,7 +23,6 @@ export class Crontab {
  task_after?: string;
  log_name?: string;
  allow_multiple_instances?: 1 | 0;
-  work_dir?: string;

  constructor(options: Crontab) {
    this.name = options.name;
@@ -50,16 +49,45 @@ export class Crontab {
    this.task_after = options.task_after;
    this.log_name = options.log_name;
    this.allow_multiple_instances = options.allow_multiple_instances || 0;
-    this.work_dir = options.work_dir;
  }
 }

 export enum CrontabStatus {
  'running' = 0,
+  'queued' = 0.5,
  'idle' = 1,
-  'disabled' = 2,
-  'queued' = 3,
+  'disabled',
 }

-export type CronInstance = RecordRow<Crontab>;
-export const CrontabModel = new Repository<Crontab>('Crontab');
+export interface CronInstance extends Model<Crontab, Crontab>, Crontab {}
+export const CrontabModel = sequelize.define<CronInstance>('Crontab', {
+  name: {
+    unique: 'compositeIndex',
+    type: DataTypes.STRING,
+  },
+  command: {
+    unique: 'compositeIndex',
+    type: DataTypes.STRING,
+  },
+  schedule: {
+    unique: 'compositeIndex',
+    type: DataTypes.STRING,
+  },
+  timestamp: DataTypes.STRING,
+  saved: DataTypes.BOOLEAN,
+  status: DataTypes.NUMBER,
+  isSystem: DataTypes.NUMBER,
+  pid: DataTypes.NUMBER,
+  isDisabled: DataTypes.NUMBER,
+  isPinned: DataTypes.NUMBER,
+  log_path: DataTypes.STRING,
+  labels: DataTypes.JSON,
+  last_running_time: DataTypes.NUMBER,
+  last_execution_time: DataTypes.NUMBER,
+  sub_id: { type: DataTypes.NUMBER, allowNull: true },
+  extra_schedules: DataTypes.JSON,
+  task_before: DataTypes.STRING,
+  task_after: DataTypes.STRING,
+  log_name: DataTypes.STRING,
+  allow_multiple_instances: DataTypes.NUMBER,
+});
@@ -1,26 +0,0 @@
-import { Repository, RecordRow } from './repository';
-
-export class CrontabStat {
-  id?: number;
-  ref_id!: number;
-  date!: string;
-  run_count?: number;
-  success_count?: number;
-  fail_count?: number;
-  total_time?: number;
-  max_time?: number;
-
-  constructor(options: CrontabStat) {
-    this.id = options.id;
-    this.ref_id = options.ref_id;
-    this.date = options.date;
-    this.run_count = options.run_count || 0;
-    this.success_count = options.success_count || 0;
-    this.fail_count = options.fail_count || 0;
-    this.total_time = options.total_time || 0;
-    this.max_time = options.max_time || 0;
-  }
-}
-
-export type CrontabStatInstance = RecordRow<CrontabStat>;
-export const CrontabStatModel = new Repository<CrontabStat>('CrontabStat');
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { sequelize } from '.';
+import { DataTypes, Model } from 'sequelize';

 export enum CronViewType {
  '系统' = 1,
@@ -38,5 +39,24 @@ export class CrontabView {
  }
 }

-export type CronViewInstance = RecordRow<CrontabView>;
-export const CrontabViewModel = new Repository<CrontabView>('CrontabView');
+export interface CronViewInstance
+  extends Model<CrontabView, CrontabView>,
+    CrontabView {}
+export const CrontabViewModel = sequelize.define<CronViewInstance>(
+  'CrontabView',
+  {
+    name: {
+      unique: 'name',
+      type: DataTypes.STRING,
+    },
+    position: DataTypes.NUMBER,
+    isDisabled: DataTypes.NUMBER,
+    filters: DataTypes.JSON,
+    sorts: DataTypes.JSON,
+    filterRelation: {
+      type: DataTypes.STRING,
+      allowNull: true,
+    },
+    type: DataTypes.NUMBER,
+  },
+);
@@ -1,325 +0,0 @@
-import { AsyncLocalStorage } from 'async_hooks';
-import { ChildProcess, fork } from 'child_process';
-import { join } from 'path';
-import { setTimeout, clearTimeout } from 'timers';
-import { DatabaseError } from './databaseErrors';
-
-type Scope = { active: boolean; child: boolean; token: number };
-type Reply = {
-  id: number;
-  value?: any;
-  error?: { code: string; message: string };
-};
-type Limits = { timeoutMs?: number; queueLimit?: number };
-
-// One worker per backend process; SQLite itself coordinates independent processes.
-// A transaction owns this client's queue until its callback and commit finish.
-export class DatabaseClient {
-  private worker?: ChildProcess;
-  private stopped: Promise<void> = Promise.resolve();
-  private failed?: Error;
-  private closed = false;
-  private nextId = 0;
-  private queued = 0;
-  private tail: Promise<void> = Promise.resolve();
-  private pending = new Map<
-    number,
-    {
-      resolve(value: any): void;
-      reject(error: Error): void;
-      timer: NodeJS.Timeout;
-    }
-  >();
-  private scope = new AsyncLocalStorage<Scope>();
-
-  private readonly timeoutMs: number;
-  private readonly queueLimit: number;
-
-  constructor(
-    public readonly storage: string,
-    private cacheStorage?: string,
-    limits: Limits = {},
-  ) {
-    this.timeoutMs =
-      limits.timeoutMs ?? (process.arch === 'arm' ? 300000 : 60000);
-    this.queueLimit = limits.queueLimit ?? 256;
-    if (
-      !Number.isSafeInteger(this.timeoutMs) ||
-      this.timeoutMs < 1 ||
-      !Number.isSafeInteger(this.queueLimit) ||
-      this.queueLimit < 1
-    )
-      throw new Error('Invalid database worker limits');
-  }
-
-  private abort(error: Error) {
-    this.failed ||= error;
-    for (const request of this.pending.values()) {
-      clearTimeout(request.timer);
-      request.reject(this.failed);
-    }
-    this.pending.clear();
-    this.unref();
-    this.worker?.kill('SIGKILL');
-  }
-
-  private unref() {
-    this.worker?.unref();
-    this.worker?.channel?.unref();
-  }
-
-  private start() {
-    if (this.worker) return this.worker;
-    const [major, minor] = process.versions.node.split('.').map(Number);
-    if (major < 22 || (major === 22 && minor < 17))
-      throw new DatabaseError(
-        'Qinglong requires Node >=22.17; keep the previous installation until Node is upgraded',
-        'UNSUPPORTED_NODE',
-      );
-    // ts-node's CLI places its executable in execArgv, rather than using -r.
-    // Source workers register their own compiler; compiled workers need none.
-    const preloads = __filename.endsWith('.ts')
-      ? ['--require', require.resolve('ts-node/register/transpile-only')]
-      : [];
-    const armv6 =
-      process.arch === 'arm' &&
-      Number(
-        (process.config.variables as { arm_version?: string | number })
-          .arm_version,
-      ) === 6;
-    const worker = fork(require.resolve('./databaseProcess'), [], {
-      serialization: 'advanced',
-      stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
-      execArgv: [
-        ...preloads,
-        ...(armv6 ? ['--jitless'] : []),
-        '--max-old-space-size=128',
-      ],
-      env: {
-        ...process.env,
-        NODE_OPTIONS: '',
-        ...(__filename.endsWith('.ts')
-          ? { TS_NODE_PROJECT: join(__dirname, 'tsconfig.worker.json') }
-          : {}),
-      },
-    });
-    this.stopped = new Promise((resolve) =>
-      worker.once('close', () => resolve()),
-    );
-    const onOwnerExit = () => worker.kill('SIGKILL');
-    process.once('exit', onOwnerExit);
-    worker.once('close', () => process.removeListener('exit', onOwnerExit));
-    this.worker = worker;
-    worker.on('message', (reply: Reply & { type?: string }) => {
-      if (reply.type === 'fatal' && reply.error) {
-        this.abort(new DatabaseError(reply.error.message, reply.error.code));
-        return;
-      }
-      const request = this.pending.get(reply.id);
-      if (!request) return;
-      this.pending.delete(reply.id);
-      clearTimeout(request.timer);
-      if (!this.pending.size) this.unref();
-      if (reply.error)
-        request.reject(
-          new DatabaseError(reply.error.message, reply.error.code),
-        );
-      else request.resolve(reply.value);
-    });
-    const fail = () =>
-      this.abort(
-        new DatabaseError(
-          'Database worker stopped; restart the service before retrying a write',
-          'DATABASE_WORKER_EXIT',
-        ),
-      );
-    worker.on('error', fail);
-    worker.on('exit', () => {
-      if (!this.closed) fail();
-    });
-    worker.send({
-      storage: this.storage,
-      cacheStorage: this.cacheStorage,
-      ownerPid: process.pid,
-    });
-    this.unref();
-    return worker;
-  }
-
-  private send(
-    operation: string,
-    args: any[] = [],
-    token?: number,
-  ): Promise<any> {
-    if (this.failed) return Promise.reject(this.failed);
-    if (this.closed)
-      return Promise.reject(
-        new DatabaseError('Database is closed', 'DATABASE_CLOSED'),
-      );
-    return new Promise((resolve, reject) => {
-      try {
-        const worker = this.start();
-        const id = ++this.nextId;
-        const timer = setTimeout(
-          () =>
-            this.abort(
-              new DatabaseError(
-                'Database worker timed out; writes are never automatically replayed',
-                'DATABASE_WORKER_TIMEOUT',
-              ),
-            ),
-          this.timeoutMs,
-        );
-        timer.unref();
-        this.pending.set(id, { resolve, reject, timer });
-        worker.ref();
-        worker.channel?.ref();
-        try {
-          worker.send({ id, operation, args, token }, (error) => {
-            if (error)
-              this.abort(
-                new DatabaseError(
-                  'Database IPC disconnected',
-                  'DATABASE_WORKER_EXIT',
-                ),
-              );
-          });
-        } catch (error) {
-          this.pending.delete(id);
-          clearTimeout(timer);
-          if (!this.pending.size) this.unref();
-          reject(error);
-        }
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-
-  private exclusive<T>(
-    operation: () => Promise<T>,
-    shutdown = false,
-  ): Promise<T> {
-    if (!shutdown && this.queued >= this.queueLimit)
-      return Promise.reject(
-        new DatabaseError('Database request queue is full', 'DATABASE_BUSY'),
-      );
-    this.queued++;
-    const previous = this.tail;
-    let release!: () => void;
-    this.tail = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    return previous.then(operation).finally(() => {
-      this.queued--;
-      release();
-    });
-  }
-
-  request<T = any>(operation: string, ...args: any[]): Promise<T> {
-    const scope = this.scope.getStore();
-    if (scope) {
-      if (!scope.active || scope.child)
-        return Promise.reject(
-          new DatabaseError(
-            'Transaction scope is no longer available',
-            'TRANSACTION_SCOPE',
-          ),
-        );
-      if (this.pending.size >= this.queueLimit)
-        return Promise.reject(
-          new DatabaseError('Database request queue is full', 'DATABASE_BUSY'),
-        );
-      return this.send(operation, args, scope.token);
-    }
-    return this.exclusive(() => this.send(operation, args));
-  }
-
-  async transaction<T>(operation: () => Promise<T>): Promise<T> {
-    const parent = this.scope.getStore();
-    if (parent && (!parent.active || parent.child))
-      throw new DatabaseError(
-        'Concurrent or expired nested transaction',
-        'TRANSACTION_SCOPE',
-      );
-    const run = async () => {
-      const token = ++this.nextId;
-      if (parent) parent.child = true;
-      const scope: Scope = { active: true, child: false, token };
-      let began = false;
-      let timer: NodeJS.Timeout | undefined;
-      try {
-        await this.send('begin', [], token);
-        began = true;
-        const deadline = new Promise<never>((_, reject) => {
-          timer = setTimeout(
-            () =>
-              reject(
-                new DatabaseError(
-                  'Database transaction timed out',
-                  'DATABASE_TRANSACTION_TIMEOUT',
-                ),
-              ),
-            this.timeoutMs,
-          );
-        });
-        const value = await Promise.race([
-          this.scope.run(scope, operation),
-          deadline,
-        ]);
-        scope.active = false;
-        await this.send('commit', [], token);
-        return value;
-      } catch (error) {
-        scope.active = false;
-        if (began) {
-          try {
-            await this.send('rollback', [], token);
-          } catch {
-            this.abort(
-              new DatabaseError(
-                'Transaction rollback failed; restart the service',
-                'DATABASE_ROLLBACK_FAILED',
-              ),
-            );
-          }
-        }
-        throw error;
-      } finally {
-        clearTimeout(timer);
-        if (parent) parent.child = false;
-      }
-    };
-    return parent ? run() : this.exclusive(run);
-  }
-
-  query<T = Record<string, unknown>>(
-    sql: string,
-    params: unknown[] = [],
-  ): Promise<T[]> {
-    return this.request('query', sql, params);
-  }
-
-  get healthy() {
-    return !this.failed && !this.closed;
-  }
-
-  async close() {
-    if (this.scope.getStore())
-      throw new DatabaseError(
-        'Cannot close within a transaction',
-        'TRANSACTION_SCOPE',
-      );
-    await this.exclusive(async () => {
-      if (this.closed) return;
-      try {
-        if (this.worker && !this.failed) await this.send('close');
-      } finally {
-        this.closed = true;
-        this.worker?.ref();
-        this.worker?.kill('SIGKILL');
-        await this.stopped;
-      }
-    }, true);
-  }
-}
@@ -1,36 +0,0 @@
-// Error details (SQL, bindings, credentials) stay inside the database worker.
-export class DatabaseError extends Error {
-  constructor(message: string, public readonly code: string) {
-    super(message);
-    this.name = 'DatabaseError';
-  }
-}
-
-export function databaseStartupFailure(value: unknown) {
-  const error = (value && typeof value === 'object' ? value : {}) as Error & { code?: string };
-  const missing = /Cannot find (?:module|package) ['"]([^'"]+)['"]/.exec(
-    error.message || '',
-  )?.[1];
-  const importer = /Require stack:\r?\n-\s+([^\r\n]+)/.exec(
-    error.message || '',
-  )?.[1];
-  const dependency =
-    /MODULE_NOT_FOUND/.test(error.code || '') &&
-    Boolean(
-      missing &&
-        ((!missing.startsWith('.') &&
-          !missing.startsWith('/') &&
-          !missing.startsWith('node:')) ||
-          /node_modules[/\\]/.test(missing) ||
-          /node_modules[/\\]/.test(importer || '')),
-    );
-  return dependency
-    ? {
-        code: 'MODULE_NOT_FOUND',
-        message: "Cannot find module '@mikro-orm/sql'",
-      }
-    : {
-        code: 'DATABASE_WORKER_EXIT',
-        message: 'Database process failed to start',
-      };
-}
@@ -1,61 +0,0 @@
-import { databaseStartupFailure } from './databaseErrors';
-import { Worker } from 'worker_threads';
-
-// IPC disconnect cannot run while DatabaseSync is executing SQL. Start this
-// independent, allocation-light monitor before opening SQLite so a SIGKILLed
-// backend cannot leave an orphan holding the old service's database write lock.
-async function monitorOwner(ownerPid: number) {
-  if (!Number.isSafeInteger(ownerPid) || ownerPid < 1)
-    throw new Error('Invalid database owner');
-  const monitor = new Worker(
-    `
-    const {parentPort,workerData}=require('node:worker_threads');
-    process.on('uncaughtException',()=>process.kill(process.pid,'SIGKILL'));
-    const check=()=>{
-      if(process.ppid!==workerData.ownerPid)process.kill(process.pid,'SIGKILL');
-    };
-    check();
-    setInterval(check,500);
-    parentPort.postMessage('ready');
-  `,
-    {
-      eval: true,
-      workerData: { ownerPid },
-      // V8's process-wide --jitless remains active on ARMv6. Do not load the
-      // source worker's ts-node compiler into this tiny, plain-JavaScript monitor.
-      execArgv: [],
-      resourceLimits: {
-        maxOldGenerationSizeMb: 8,
-        maxYoungGenerationSizeMb: 2,
-        stackSizeMb: 1,
-      },
-    },
-  );
-  monitor.once('exit', () => process.exit(1));
-  await new Promise<void>((resolve, reject) => {
-    monitor.once('message', () => resolve());
-    monitor.once('error', reject);
-  });
-  monitor.unref();
-}
-
-// The bootstrap catches dependency import errors before the ORM module loads.
-// The advanced IPC serializer preserves Date, Buffer and undefined values.
-process.once('disconnect', () => process.exit(1));
-process.once('message', async (settings) => {
-  const pending: unknown[] = [];
-  const buffer = (request: unknown) => pending.push(request);
-  // Keep a listener throughout asynchronous monitor startup. Node may flush
-  // several buffered IPC messages while delivering the initial settings.
-  process.on('message', buffer);
-  try {
-    await monitorOwner((settings as { ownerPid: number }).ownerPid);
-    require('./databaseWorker').startDatabaseWorker(settings);
-    process.removeListener('message', buffer);
-    for (const request of pending) process.emit('message', request, undefined);
-  } catch (error) {
-    process.send?.({ type: 'fatal', error: databaseStartupFailure(error) });
-  } finally {
-    process.removeListener('message', buffer);
-  }
-});
@@ -1,280 +0,0 @@
-import { mkdirSync } from 'fs';
-import { dirname } from 'path';
-import { EntitySchema, Type } from '@mikro-orm/core';
-import { MikroORM, SqliteDriver, NodeSqliteDialect, raw } from '@mikro-orm/sql';
-import { entityDefinitions } from './schema';
-
-// Sequelize DATE readers expect TEXT. Numeric epoch dates would break rollback.
-class LegacyDateType extends Type<Date, string> {
-  convertToDatabaseValue(value: Date) {
-    return value == null
-      ? value
-      : value.toISOString().replace('T', ' ').replace('Z', ' +00:00');
-  }
-  convertToJSValue(value: string | Date) {
-    return value == null
-      ? value
-      : value instanceof Date
-      ? value
-      : new Date(value);
-  }
-  getColumnType() {
-    return 'DATETIME';
-  }
-  compareAsType() {
-    return 'string' as const;
-  }
-  get runtimeType() {
-    return 'Date';
-  }
-}
-
-const entities = Object.values(entityDefinitions).map(
-  (definition) =>
-    new EntitySchema({
-      ...definition,
-      properties: Object.fromEntries(
-        Object.entries(definition.properties).map(([name, field]) => [
-          name,
-          {
-            ...field,
-            type:
-              field.type === 'legacyDate' ? new LegacyDateType() : field.type,
-          },
-        ]),
-      ),
-    } as any),
-);
-let orm: Awaited<ReturnType<typeof MikroORM.init<SqliteDriver>>>;
-let cache: any;
-const transactions: number[] = [];
-let ready: Promise<void>;
-let workerData: { storage: string; cacheStorage?: string; ownerPid: number };
-
-async function initialize() {
-  if (workerData.storage !== ':memory:')
-    mkdirSync(dirname(workerData.storage), { recursive: true });
-  orm = await MikroORM.init<SqliteDriver>({
-    driver: SqliteDriver,
-    driverOptions: new NodeSqliteDialect(workerData.storage),
-    dbName: workerData.storage,
-    entities,
-    debug: false,
-    allowGlobalContext: false,
-    discovery: { warnWhenNoEntities: false },
-  });
-  await orm.em.getConnection().execute('PRAGMA busy_timeout=10000');
-}
-
-function filter(name: keyof typeof entityDefinitions, value: any): any {
-  if (value === undefined) throw new Error('Undefined database predicate');
-  if (value == null || typeof value !== 'object' || value instanceof Date)
-    return value;
-  if (Array.isArray(value)) return value.map((part) => filter(name, part));
-  const properties = entityDefinitions[name].properties;
-  return Object.fromEntries(
-    Object.entries(value).map(([key, item]: [string, any]) => {
-      if (item === undefined) throw new Error('Undefined database predicate');
-      // LIKE searches JSON's serialized text, matching the pre-migration behavior.
-      if (
-        key in properties &&
-        (properties as any)[key].type === 'json' &&
-        item &&
-        typeof item === 'object' &&
-        '$like' in item
-      )
-        return [raw(`cast("${key}" as text)`), item];
-      return [key, filter(name, item)];
-    }),
-  );
-}
-
-function values(
-  name: keyof typeof entityDefinitions,
-  payload: Record<string, any>,
-  insert = false,
-) {
-  const properties = entityDefinitions[name].properties;
-  const data = Object.fromEntries(
-    Object.entries(payload).filter(
-      ([key, value]) => key in properties && value !== undefined,
-    ),
-  );
-  for (const [key, value] of Object.entries(data)) {
-    if ((properties as any)[key].type === 'json' && value !== null)
-      data[key] = JSON.parse(JSON.stringify(value));
-  }
-  const now = new Date();
-  if (insert && !data.createdAt) data.createdAt = now;
-  data.updatedAt = now;
-  return data;
-}
-
-function plain(name: keyof typeof entityDefinitions, row: any) {
-  if (!row) return null;
-  return Object.fromEntries(
-    Object.keys(entityDefinitions[name].properties)
-      .filter((key) => row[key] !== undefined)
-      .map((key) => [key, row[key]]),
-  );
-}
-
-async function execute(
-  operation: string,
-  args: any[],
-  token?: number,
-): Promise<any> {
-  await ready;
-  // Reject queued work after owner death; the monitor interrupts running SQL.
-  if (process.ppid !== workerData.ownerPid) process.exit(1);
-  const connection = orm.em.getConnection();
-  if (operation === 'begin') {
-    await connection.execute(
-      transactions.length ? `SAVEPOINT "ql_${token}"` : 'BEGIN IMMEDIATE',
-    );
-    transactions.push(token!);
-    return;
-  }
-  if (token !== transactions[transactions.length - 1])
-    throw new Error('Database transaction ownership mismatch');
-  if (operation === 'commit' || operation === 'rollback') {
-    if (!transactions.length) throw new Error('No active database transaction');
-    const nested = transactions.length > 1;
-    if (operation === 'rollback' && nested)
-      await connection.execute(`ROLLBACK TO SAVEPOINT "ql_${token}"`);
-    await connection.execute(
-      nested ? `RELEASE SAVEPOINT "ql_${token}"` : operation.toUpperCase(),
-    );
-    transactions.pop();
-    return;
-  }
-  if (operation === 'close') {
-    if (transactions.length)
-      throw new Error('Cannot close an active transaction');
-    cache?.close();
-    await orm.close();
-    return;
-  }
-  if (operation === 'query') return connection.execute(args[0], args[1]);
-  if (operation === 'cache') {
-    if (!workerData.cacheStorage)
-      throw new Error('No cache database configured');
-    if (!cache) {
-      const { DatabaseSync } = require('node:sqlite');
-      mkdirSync(dirname(workerData.cacheStorage), { recursive: true });
-      cache = new DatabaseSync(workerData.cacheStorage);
-      cache.exec(
-        'PRAGMA busy_timeout=10000;CREATE TABLE IF NOT EXISTS keyv(key VARCHAR(255) PRIMARY KEY,value TEXT)',
-      );
-    }
-    const [action, key, value] = args;
-    switch (action) {
-      case 'get':
-        return cache.prepare('SELECT value FROM keyv WHERE key=?').get(key)
-          ?.value;
-      case 'set':
-        cache
-          .prepare(
-            'INSERT INTO keyv(key,value) VALUES(?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value',
-          )
-          .run(key, value);
-        return true;
-      case 'delete':
-        return (
-          cache.prepare('DELETE FROM keyv WHERE key=?').run(key).changes > 0
-        );
-      default:
-        throw new Error('Unsupported cache operation');
-    }
-  }
-  const [name, condition, options = {}] = args as [
-    keyof typeof entityDefinitions,
-    any,
-    any,
-  ];
-  if (!(name in entityDefinitions)) throw new Error('Unknown entity');
-  const em = orm.em.fork();
-  const entityName = entities.find((entity) => entity.meta.className === name)!;
-  if (operation !== 'insert' && condition == null)
-    throw new Error('Missing database predicate');
-  const query = operation === 'insert' ? {} : filter(name, condition);
-  const readOptions = {
-    ...options,
-    orderBy: options.orderBy?.map((order: Record<string, string>) =>
-      Object.fromEntries(
-        Object.entries(order).map(([field, direction]) => [
-          name === 'Env' && field === 'isPinned'
-            ? raw('COALESCE("isPinned",0)')
-            : field,
-          direction,
-        ]),
-      ),
-    ),
-  };
-  switch (operation) {
-    case 'find':
-      return (await em.find(entityName, query, readOptions)).map((row) =>
-        plain(name, row),
-      );
-    case 'findOne':
-      return plain(name, await em.findOne(entityName, query, readOptions));
-    case 'count':
-      return em.count(entityName, query);
-    case 'insert': {
-      const id = await em.insert(entityName, values(name, condition, true));
-      return plain(name, await em.findOneOrFail(entityName, { id }));
-    }
-    case 'nativeUpdate':
-      return em.nativeUpdate(entityName, query, values(name, options));
-    case 'nativeDelete':
-      return em.nativeDelete(entityName, query);
-    default:
-      throw new Error('Unsupported database operation');
-  }
-}
-
-export function startDatabaseWorker(settings: typeof workerData) {
-  workerData = settings;
-  ready = initialize();
-  void ready.catch(() => {});
-  let queue = Promise.resolve();
-  process.on('message', ({ id, operation, args, token }) => {
-    // Continue after a failed statement so the owner can still roll back.
-    queue = queue.then(async () => {
-      try {
-        process.send?.({
-          id,
-          value: await execute(operation, args, token),
-        });
-      } catch (error: any) {
-        const code =
-          error.name === 'UniqueConstraintViolationException'
-            ? 'UNIQUE_CONSTRAINT'
-            : error.name === 'TableNotFoundException'
-            ? 'DATABASE_SCHEMA_MISSING'
-            : (
-                {
-                  5: 'SQLITE_BUSY',
-                  6: 'SQLITE_LOCKED',
-                  8: 'SQLITE_READONLY',
-                  10: 'SQLITE_IOERR',
-                  11: 'SQLITE_CORRUPT',
-                  13: 'SQLITE_FULL',
-                  14: 'SQLITE_CANTOPEN',
-                  26: 'SQLITE_NOTADB',
-                } as Record<number, string>
-              )[Number(error.errcode) & 255] || 'DATABASE_QUERY_FAILED';
-        process.send?.({
-          id,
-          error: {
-            code,
-            message:
-              code === 'UNIQUE_CONSTRAINT'
-                ? 'Resource already exists'
-                : `Database operation failed (${code})`,
-          },
-        });
-      }
-    });
-  });
-}
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { sequelize } from '.';
+import { DataTypes, Model, ModelDefined } from 'sequelize';

 export class Dependence {
  timestamp?: string;
@@ -46,5 +47,17 @@ export enum versionDependenceCommandTypes {
  '=',
 }

-export type DependenceInstance = RecordRow<Dependence>;
-export const DependenceModel = new Repository<Dependence>('Dependence');
+export interface DependenceInstance
+  extends Model<Dependence, Dependence>,
+    Dependence {}
+export const DependenceModel = sequelize.define<DependenceInstance>(
+  'Dependence',
+  {
+    name: DataTypes.STRING,
+    type: DataTypes.NUMBER,
+    timestamp: DataTypes.STRING,
+    status: DataTypes.NUMBER,
+    log: DataTypes.JSON,
+    remark: DataTypes.STRING,
+  },
+);
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { DataTypes, Model } from 'sequelize';
+import { sequelize } from '.';

 export class Env {
  value?: string;
@@ -9,7 +10,6 @@ export class Env {
  name?: string;
  remarks?: string;
  isPinned?: 1 | 0;
-  labels?: string[];

  constructor(options: Env) {
    this.value = options.value;
@@ -23,7 +23,6 @@ export class Env {
    this.name = options.name;
    this.remarks = options.remarks || '';
    this.isPinned = options.isPinned || 0;
-    this.labels = options.labels || [];
  }
 }

@@ -37,5 +36,13 @@ export const initPosition = 4500000000000000;
 export const stepPosition = 10000000000;
 export const minPosition = 100;

-export type EnvInstance = RecordRow<Env>;
-export const EnvModel = new Repository<Env>('Env');
+export interface EnvInstance extends Model<Env, Env>, Env {}
+export const EnvModel = sequelize.define<EnvInstance>('Env', {
+  value: { type: DataTypes.STRING, unique: 'compositeIndex' },
+  timestamp: DataTypes.STRING,
+  status: DataTypes.NUMBER,
+  position: DataTypes.NUMBER,
+  name: { type: DataTypes.STRING, unique: 'compositeIndex' },
+  remarks: DataTypes.STRING,
+  isPinned: DataTypes.NUMBER,
+});
@@ -1,10 +1,23 @@
+import { Sequelize, Transaction } from 'sequelize';
 import config from '../config/index';
 import { join } from 'path';
-import { DatabaseClient } from './databaseClient';

-export const database = new DatabaseClient(
-  join(config.dbPath, 'database.sqlite'),
-  join(config.dbPath, 'keyv.sqlite'),
-);
+export const sequelize = new Sequelize({
+  dialect: 'sqlite',
+  storage: join(config.dbPath, 'database.sqlite'),
+  logging: false,
+  retry: {
+    max: 10,
+    match: ['SQLITE_BUSY: database is locked'],
+  },
+  pool: {
+    max: 5,
+    min: 2,
+    idle: 30000,
+    acquire: 30000,
+    evict: 10000,
+  },
+  transactionType: Transaction.TYPES.IMMEDIATE,
+});

 export type ResponseType<T> = { code: number; data?: T; message?: string };
@@ -20,8 +20,6 @@ export enum NotificationMode {
  'chronocat' = 'Chronocat',
  'ntfy' = 'ntfy',
  'wxPusherBot' = 'wxPusherBot',
-  'openiLink' = 'openiLink',
-  'wpush' = 'wpush',
 }

 abstract class NotificationBaseInfo {
@@ -163,22 +161,6 @@ export class WxPusherBotNotification extends NotificationBaseInfo {
  public wxPusherBotUids = '';
 }

-export class WxPusherSptNotification extends NotificationBaseInfo {
-  public wxPusherSptList = '';
-}
-
-export class OpeniLinkNotification extends NotificationBaseInfo {
-  public openiLinkAppToken = '';
-  public openiLinkHubUrl = '';
-  public openiLinkContextToken = '';
-}
-
-export class WpushNotification extends NotificationBaseInfo {
-  public wpushApiKey = '';
-  public wpushChannel = '';
-  public wpushTopicCode = '';
-}
-
 export interface NotificationInfo
  extends GoCqHttpBotNotification,
    GotifyNotification,
@@ -200,7 +182,4 @@ export interface NotificationInfo
    ChronocatNotification,
    LarkNotification,
    NtfyNotification,
-    WxPusherBotNotification,
-    WxPusherSptNotification,
-    OpeniLinkNotification,
-    WpushNotification {}
+    WxPusherBotNotification {}
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { sequelize } from '.';
+import { DataTypes, Model, ModelDefined } from 'sequelize';

 export class App {
  name: string;
@@ -23,14 +24,13 @@ export interface AppToken {
  expiration: number;
 }

-export type AppScope =
-  | 'envs'
-  | 'crons'
-  | 'configs'
-  | 'scripts'
-  | 'logs'
-  | 'system'
-  | 'dashboard';
+export type AppScope = 'envs' | 'crons' | 'configs' | 'scripts' | 'logs' | 'system';

-export type AppInstance = RecordRow<App>;
-export const AppModel = new Repository<App>('App');
+export interface AppInstance extends Model<App, App>, App {}
+export const AppModel = sequelize.define<AppInstance>('App', {
+  name: { type: DataTypes.STRING, unique: 'name' },
+  scopes: DataTypes.JSON,
+  client_id: DataTypes.STRING,
+  client_secret: DataTypes.STRING,
+  tokens: DataTypes.JSON,
+});
@@ -1,25 +0,0 @@
-export type Query = Record<string, any>;
-export type QuerySpec = {
-  where: Query;
-  orderBy?: Record<string, string>[];
-  offset?: number;
-  limit?: number;
-};
-
-export function orderBy(order: string[][]): Record<string, string>[] {
-  return order.map(([field, direction]) => {
-    if (!/^(asc|desc)$/i.test(direction))
-      throw new Error('Invalid sort direction');
-    return { [field]: direction.toLowerCase() };
-  });
-}
-
-export function textSearch(fields: string[], text: string): Query {
-  return {
-    $or: fields.flatMap((field) =>
-      [...new Set([text, encodeURI(text)])].map((value) => ({
-        [field]: { $like: `%${value}%` },
-      })),
-    ),
-  };
-}
@@ -1,54 +0,0 @@
-import { database } from '.';
-import { DatabaseClient } from './databaseClient';
-
-export type RecordRow<T> = T & { id: number; createdAt: Date; updatedAt: Date };
-export type Query = Record<string, any>;
-export type ReadOptions = {
-  fields?: string[];
-  orderBy?: Record<string, string>[];
-  limit?: number;
-  offset?: number;
-};
-
-// A small IPC boundary with MikroORM's native query/operation names. No ORM
-// entities or request identity maps escape the single database worker.
-export class Repository<T> {
-  constructor(
-    private name: string,
-    private client: () => DatabaseClient = () => database,
-  ) {}
-  find(where: Query = {}, options: ReadOptions = {}): Promise<RecordRow<T>[]> {
-    return this.client().request('find', this.name, where, options);
-  }
-  findOne(
-    where: Query,
-    options: ReadOptions = {},
-  ): Promise<RecordRow<T> | null> {
-    return this.client().request('findOne', this.name, where, options);
-  }
-  count(where: Query = {}): Promise<number> {
-    return this.client().request('count', this.name, where);
-  }
-  insert(data: Partial<T>): Promise<RecordRow<T>> {
-    return this.client().request('insert', this.name, data);
-  }
-  nativeUpdate(where: Query, data: Partial<T>): Promise<number> {
-    return this.client().request('nativeUpdate', this.name, where, data);
-  }
-  nativeDelete(where: Query): Promise<number> {
-    return this.client().request('nativeDelete', this.name, where);
-  }
-  async insertMany(data: Partial<T>[]): Promise<RecordRow<T>[]> {
-    return this.client().transaction(async () => {
-      const rows = [];
-      for (const item of data) rows.push(await this.insert(item));
-      return rows;
-    });
-  }
-  async getOrCreate(where: Query): Promise<RecordRow<T>> {
-    return this.client().transaction(
-      async () =>
-        (await this.findOne(where)) || this.insert(where as Partial<T>),
-    );
-  }
-}
@@ -1,46 +0,0 @@
-import { Repository, RecordRow } from './repository';
-
-export enum InstanceStatus {
-  'running' = 0,
-  'finished' = 1,
-  'stopped' = 2,
-  'error' = 3,
-}
-
-export interface RunningInstanceAttributes {
-  id?: number;
-  cron_id: number;
-  pid?: number;
-  log_path?: string;
-  started_at: number;
-  finished_at?: number;
-  status: InstanceStatus;
-  exit_code?: number;
-}
-
-export class RunningInstance {
-  id?: number;
-  cron_id!: number;
-  pid?: number;
-  log_path?: string;
-  started_at!: number;
-  finished_at?: number;
-  status!: InstanceStatus;
-  exit_code?: number;
-
-  constructor(options: RunningInstanceAttributes) {
-    this.id = options.id;
-    this.cron_id = options.cron_id;
-    this.pid = options.pid;
-    this.log_path = options.log_path;
-    this.started_at = options.started_at;
-    this.finished_at = options.finished_at;
-    this.status = options.status;
-    this.exit_code = options.exit_code;
-  }
-}
-
-export type RunningInstanceModel = RecordRow<RunningInstanceAttributes>;
-export const RunningInstanceModel = new Repository<RunningInstanceAttributes>(
-  'RunningInstance',
-);
@@ -1,178 +0,0 @@
-// Persisted SQLite names and types are part of the rollback contract.
-type Field = {
-  type: string;
-  fieldName: string;
-  nullable?: boolean;
-  primary?: boolean;
-  autoincrement?: boolean;
-};
-function entity<Name extends string>(
-  name: Name,
-  tableName: string,
-  groups: Record<string, string[]>,
-  required: string[] = [],
-) {
-  const properties: Record<string, Field> = {
-    id: { type: 'number', fieldName: 'id', primary: true, autoincrement: true },
-  };
-  for (const [type, fields] of Object.entries(groups))
-    for (const field of fields)
-      properties[field] = {
-        type,
-        fieldName: field,
-        nullable: !required.includes(field),
-      };
-  for (const field of ['createdAt', 'updatedAt'])
-    properties[field] = {
-      type: 'legacyDate',
-      fieldName: field,
-      nullable: false,
-    };
-  return { name, tableName, properties };
-}
-export const entityDefinitions = {
-  App: entity(
-    'App',
-    'Apps',
-    {
-      string: ['name', 'client_id', 'client_secret'],
-      json: ['scopes', 'tokens'],
-    },
-    [],
-  ),
-  Auth: entity('Auth', 'Auths', { string: ['ip', 'type'], json: ['info'] }, []),
-  CrontabStat: entity(
-    'CrontabStat',
-    'CrontabStats',
-    {
-      number: [
-        'ref_id',
-        'run_count',
-        'success_count',
-        'fail_count',
-        'total_time',
-        'max_time',
-      ],
-      string: ['date'],
-    },
-    ['ref_id', 'date'],
-  ),
-  CrontabView: entity(
-    'CrontabView',
-    'CrontabViews',
-    {
-      string: ['name', 'filterRelation'],
-      number: ['position', 'isDisabled', 'type'],
-      json: ['filters', 'sorts'],
-    },
-    [],
-  ),
-  Crontab: entity(
-    'Crontab',
-    'Crontabs',
-    {
-      string: [
-        'name',
-        'command',
-        'schedule',
-        'timestamp',
-        'log_path',
-        'queued_token',
-        'task_before',
-        'task_after',
-        'log_name',
-        'work_dir',
-      ],
-      boolean: ['saved'],
-      number: [
-        'status',
-        'isSystem',
-        'pid',
-        'isDisabled',
-        'isPinned',
-        'last_running_time',
-        'last_execution_time',
-        'sub_id',
-        'allow_multiple_instances',
-      ],
-      json: ['labels', 'extra_schedules'],
-    },
-    [],
-  ),
-  Dependence: entity(
-    'Dependence',
-    'Dependences',
-    {
-      string: ['name', 'timestamp', 'remark'],
-      number: ['type', 'status'],
-      json: ['log'],
-    },
-    [],
-  ),
-  Env: entity(
-    'Env',
-    'Envs',
-    {
-      string: ['value', 'timestamp', 'name', 'remarks'],
-      number: ['status', 'position', 'isPinned'],
-      json: ['labels'],
-    },
-    [],
-  ),
-  RunningInstance: entity(
-    'RunningInstance',
-    'RunningInstances',
-    {
-      number: [
-        'cron_id',
-        'pid',
-        'started_at',
-        'finished_at',
-        'status',
-        'exit_code',
-      ],
-      string: ['log_path'],
-    },
-    ['cron_id', 'started_at', 'status'],
-  ),
-  Subscription: entity(
-    'Subscription',
-    'Subscriptions',
-    {
-      string: [
-        'name',
-        'url',
-        'schedule',
-        'type',
-        'whitelist',
-        'blacklist',
-        'dependences',
-        'extensions',
-        'sub_before',
-        'sub_after',
-        'branch',
-        'pull_type',
-        'log_path',
-        'schedule_type',
-        'alias',
-        'proxy',
-      ],
-      json: ['interval_schedule', 'pull_option'],
-      number: ['status', 'pid', 'is_disabled', 'autoAddCron', 'autoDelCron'],
-    },
-    [],
-  ),
-};
-export const initialSchema = [
-  'CREATE TABLE IF NOT EXISTS `Apps` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` VARCHAR(255), `scopes` JSON, `client_id` VARCHAR(255), `client_secret` VARCHAR(255), `tokens` JSON, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, UNIQUE (`name`))',
-  'CREATE TABLE IF NOT EXISTS `Auths` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `ip` VARCHAR(255), `type` VARCHAR(255), `info` JSON, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL)',
-  'CREATE TABLE IF NOT EXISTS `CrontabStats` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `ref_id` NUMBER NOT NULL, `date` VARCHAR(255) NOT NULL, `run_count` NUMBER DEFAULT 0, `success_count` NUMBER DEFAULT 0, `fail_count` NUMBER DEFAULT 0, `total_time` NUMBER DEFAULT 0, `max_time` NUMBER DEFAULT 0, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL)',
-  'CREATE TABLE IF NOT EXISTS `CrontabViews` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` VARCHAR(255), `position` NUMBER, `isDisabled` NUMBER, `filters` JSON, `sorts` JSON, `filterRelation` VARCHAR(255), `type` NUMBER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, UNIQUE (`name`))',
-  'CREATE TABLE IF NOT EXISTS `Crontabs` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` VARCHAR(255), `command` VARCHAR(255), `schedule` VARCHAR(255), `timestamp` VARCHAR(255), `saved` TINYINT(1), `status` NUMBER, `isSystem` NUMBER, `pid` NUMBER, `isDisabled` NUMBER, `isPinned` NUMBER, `log_path` VARCHAR(255), `queued_token` VARCHAR(255), `labels` JSON, `last_running_time` NUMBER, `last_execution_time` NUMBER, `sub_id` NUMBER, `extra_schedules` JSON, `task_before` VARCHAR(255), `task_after` VARCHAR(255), `log_name` VARCHAR(255), `allow_multiple_instances` NUMBER, `work_dir` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, UNIQUE (`name`, `command`, `schedule`))',
-  'CREATE TABLE IF NOT EXISTS `Dependences` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` VARCHAR(255), `type` NUMBER, `timestamp` VARCHAR(255), `status` NUMBER, `log` JSON, `remark` VARCHAR(255), `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL)',
-  'CREATE TABLE IF NOT EXISTS `Envs` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `value` VARCHAR(255), `timestamp` VARCHAR(255), `status` NUMBER, `position` NUMBER, `name` VARCHAR(255), `remarks` VARCHAR(255), `isPinned` NUMBER, `labels` JSON, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, UNIQUE (`value`, `name`))',
-  'CREATE TABLE IF NOT EXISTS `RunningInstances` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `cron_id` NUMBER NOT NULL, `pid` NUMBER, `log_path` VARCHAR(255), `started_at` NUMBER NOT NULL, `finished_at` NUMBER, `status` NUMBER NOT NULL DEFAULT 0, `exit_code` NUMBER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL)',
-  'CREATE TABLE IF NOT EXISTS `Subscriptions` (`id` INTEGER PRIMARY KEY AUTOINCREMENT, `name` VARCHAR(255), `url` VARCHAR(255), `schedule` VARCHAR(255), `interval_schedule` JSON, `type` VARCHAR(255), `whitelist` VARCHAR(255), `blacklist` VARCHAR(255), `status` NUMBER, `dependences` VARCHAR(255), `extensions` VARCHAR(255), `sub_before` VARCHAR(255), `sub_after` VARCHAR(255), `branch` VARCHAR(255), `pull_type` VARCHAR(255), `pull_option` JSON, `pid` NUMBER, `is_disabled` NUMBER, `log_path` VARCHAR(255), `schedule_type` VARCHAR(255), `alias` VARCHAR(255), `proxy` VARCHAR(255), `autoAddCron` NUMBER, `autoDelCron` NUMBER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, UNIQUE (`name`, `url`, `schedule`, `interval_schedule`), UNIQUE (`alias`))',
-  'CREATE INDEX IF NOT EXISTS `crontab_stats_date` ON `CrontabStats` (`date`)',
-  'CREATE UNIQUE INDEX IF NOT EXISTS `crontab_stats_ref_id_date` ON `CrontabStats` (`ref_id`, `date`)',
-];
@@ -2,13 +2,11 @@ export class SockMessage {
  message?: string;
  type?: SockMessageType;
  references?: number[];
-  status?: number | string;

  constructor(options: SockMessage) {
    this.type = options.type;
    this.message = options.message;
    this.references = options.references;
-    this.status = options.status;
  }
 }

@@ -1,45 +0,0 @@
-import { database } from '.';
-
-// Aggregate SQL stays explicit and bound; public input is never used as an SQL
-// identifier. These queries preserve the dashboard response names.
-export const statistics = {
-  async totals(date: string) {
-    const rows = await database.query(
-      `SELECT SUM(run_count) AS total_runs,
-      SUM(success_count) AS total_success, SUM(fail_count) AS total_fail,
-      SUM(total_time) AS total_time FROM CrontabStats WHERE date=?`,
-      [date],
-    );
-    return rows[0];
-  },
-  results(date: string, column: 'success_count' | 'fail_count') {
-    if (!['success_count', 'fail_count'].includes(column))
-      throw new Error('Invalid statistic');
-    return database.query(
-      `SELECT ref_id,SUM(${column}) AS result_count FROM CrontabStats
-      WHERE date=? AND ${column}>0 GROUP BY ref_id ORDER BY result_count DESC,ref_id ASC`,
-      [date],
-    );
-  },
-  trend(dates: string[]) {
-    if (!dates.length) return Promise.resolve([]);
-    return database.query(
-      `SELECT date,SUM(run_count) AS total_runs,
-      SUM(success_count) AS total_success,SUM(fail_count) AS total_fail FROM CrontabStats
-      WHERE date IN (${dates
-        .map(() => '?')
-        .join(',')}) GROUP BY date ORDER BY date ASC`,
-      dates,
-    );
-  },
-  ranking(date: string, metric: 'total_time' | 'run_count') {
-    if (!['total_time', 'run_count'].includes(metric))
-      throw new Error('Invalid statistic');
-    return database.query(
-      `SELECT ref_id,SUM(total_time) AS total_time,SUM(run_count) AS run_count,
-      SUM(success_count) AS success_count,MAX(max_time) AS max_time FROM CrontabStats
-      WHERE date=? AND run_count>0 GROUP BY ref_id ORDER BY SUM(${metric}) DESC LIMIT 5`,
-      [date],
-    );
-  },
-};
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { sequelize } from '.';
+import { DataTypes, Model, ModelDefined } from 'sequelize';
 import { SimpleIntervalSchedule } from 'toad-scheduler';

 type SimpleIntervalScheduleUnit = keyof SimpleIntervalSchedule;
@@ -19,7 +20,7 @@ export class Subscription {
  pull_option?:
    | { private_key: string }
    | { username: string; password: string };
-  pid?: number | null;
+  pid?: number;
  is_disabled?: 1 | 0;
  log_path?: string;
  alias: string;
@@ -69,5 +70,46 @@ export enum SubscriptionStatus {
  'queued',
 }

-export type SubscriptionInstance = RecordRow<Subscription>;
-export const SubscriptionModel = new Repository<Subscription>('Subscription');
+export interface SubscriptionInstance
+  extends Model<Subscription, Subscription>,
+    Subscription {}
+export const SubscriptionModel = sequelize.define<SubscriptionInstance>(
+  'Subscription',
+  {
+    name: {
+      unique: 'compositeIndex',
+      type: DataTypes.STRING,
+    },
+    url: {
+      unique: 'compositeIndex',
+      type: DataTypes.STRING,
+    },
+    schedule: {
+      unique: 'compositeIndex',
+      type: DataTypes.STRING,
+    },
+    interval_schedule: {
+      unique: 'compositeIndex',
+      type: DataTypes.JSON,
+    },
+    type: DataTypes.STRING,
+    whitelist: DataTypes.STRING,
+    blacklist: DataTypes.STRING,
+    status: DataTypes.NUMBER,
+    dependences: DataTypes.STRING,
+    extensions: DataTypes.STRING,
+    sub_before: DataTypes.STRING,
+    sub_after: DataTypes.STRING,
+    branch: DataTypes.STRING,
+    pull_type: DataTypes.STRING,
+    pull_option: DataTypes.JSON,
+    pid: DataTypes.NUMBER,
+    is_disabled: DataTypes.NUMBER,
+    log_path: DataTypes.STRING,
+    schedule_type: DataTypes.STRING,
+    alias: { type: DataTypes.STRING, unique: 'alias' },
+    proxy: { type: DataTypes.STRING, allowNull: true },
+    autoAddCron: { type: DataTypes.NUMBER, allowNull: true },
+    autoDelCron: { type: DataTypes.NUMBER, allowNull: true },
+  },
+);
@@ -1,4 +1,5 @@
-import { Repository, RecordRow } from './repository';
+import { sequelize } from '.';
+import { DataTypes, Model, ModelDefined } from 'sequelize';
 import { NotificationInfo } from './notify';

 export class SystemInfo {
@@ -27,15 +28,9 @@ export enum AuthDataType {
  'removeLogFrequency' = 'removeLogFrequency',
  'systemConfig' = 'systemConfig',
  'authConfig' = 'authConfig',
-  'notifyLog' = 'notifyLog',
 }

-export const NotifyStatus = LoginStatus;
-export type NotifyStatus = LoginStatus;
-
 export interface SystemConfigInfo {
-  lang?: string;
-  panelTitle?: string;
  logRemoveFrequency?: number;
  cronConcurrency?: number;
  dependenceProxy?: string;
@@ -44,8 +39,6 @@ export interface SystemConfigInfo {
  linuxMirror?: string;
  timezone?: string;
  globalSshKey?: string;
-  runningInstanceRetentionDays?: number;
-  cronStatRetentionDays?: number;
 }

 export interface LoginLogInfo {
@@ -56,17 +49,6 @@ export interface LoginLogInfo {
  status?: LoginStatus;
 }

-export interface NotifyLogInfo {
-  timestamp?: number;
-  title?: string;
-  content?: string;
-  status?: NotifyStatus;
-  notifyType?: string;
-  source?: 'system' | 'script';
-  scriptName?: string;
-  taskId?: string;
-}
-
 export interface TokenInfo {
  value: string;
  timestamp: number;
@@ -89,21 +71,26 @@ export interface AuthInfo {
  lastaddr: string;
  platform: string;
  isTwoFactorChecking: boolean;
-  twoFactorExpiresAt?: number;
-  lastTwoFactorStep?: number;
  token: string;
  tokens: Record<string, string | TokenInfo[]>;
  twoFactorActivated: boolean;
  twoFactorSecret: string;
  avatar: string;
-  blockedIps?: string[];
 }

 export type SystemModelInfo = SystemConfigInfo &
  Partial<NotificationInfo> &
  LoginLogInfo &
-  Partial<NotifyLogInfo> &
  Partial<AuthInfo>;

-export type SystemInstance = RecordRow<SystemInfo>;
-export const SystemModel = new Repository<SystemInfo>('Auth');
+export interface SystemInstance
+  extends Model<SystemInfo, SystemInfo>,
+    SystemInfo {}
+export const SystemModel = sequelize.define<SystemInstance>('Auth', {
+  ip: DataTypes.STRING,
+  type: DataTypes.STRING,
+  info: {
+    type: DataTypes.JSON,
+    allowNull: true,
+  },
+});
@@ -1,11 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "module": "node20",
-    "moduleResolution": "node16",
-    "rootDir": "..",
-    "outDir": "../../static/build"
-  },
-  "include": ["./databaseWorker.ts", "./schema.ts"],
-  "exclude": ["node_modules"]
-}
@@ -6,25 +6,23 @@ import { Application } from 'express';
 import linkDeps from './deps';
 import initTask from './initTask';
 import initFile from './initFile';
-import { initializeTrustProxy } from '../shared/trustProxy';

 export default async ({ app }: { app: Application }) => {
  depInjectorLoader();
-  Logger.info('[boot] Dependency loaded');
+  Logger.info('✌️ Dependency loaded');

  await linkDeps();
-  Logger.info('[boot] Link deps loaded');
+  Logger.info('✌️ Link deps loaded');

-  await initFile();
-  Logger.info('[boot] Init file loaded');
+  initFile();
+  Logger.info('✌️ Init file loaded');

  await initData();
-  Logger.info('[boot] Init data loaded');
+  Logger.info('✌️ Init data loaded');

  initTask();
-  Logger.info('[boot] Init task loaded');
+  Logger.info('✌️ Init task loaded');

  expressLoader({ app });
-  await initializeTrustProxy(app);
-  Logger.info('[boot] Express loaded');
+  Logger.info('✌️ Express loaded');
 };
@@ -1,17 +1,59 @@
 import Logger from './logger';
-import { database } from '../data';
-import { initialSchema } from '../data/schema';
-import { migrateSchema } from '../shared/schemaMigrations';
+import { EnvModel } from '../data/env';
+import { CrontabModel } from '../data/cron';
+import { DependenceModel } from '../data/dependence';
+import { AppModel } from '../data/open';
+import { SystemModel } from '../data/system';
+import { SubscriptionModel } from '../data/subscription';
+import { CrontabViewModel } from '../data/cronView';
+import { sequelize } from '../data';

 export default async () => {
  try {
-    await database.transaction(async () => {
-      for (const sql of initialSchema) await database.query(sql);
-      await migrateSchema(database);
-    });
-    Logger.info('[boot] DB loaded');
+    await CrontabModel.sync();
+    await DependenceModel.sync();
+    await AppModel.sync();
+    await SystemModel.sync();
+    await EnvModel.sync();
+    await SubscriptionModel.sync();
+    await CrontabViewModel.sync();
+
+    // 初始化新增字段
+    const migrations = [
+      {
+        table: 'CrontabViews',
+        column: 'filterRelation',
+        type: 'VARCHAR(255)',
+      },
+      { table: 'Subscriptions', column: 'proxy', type: 'VARCHAR(255)' },
+      { table: 'CrontabViews', column: 'type', type: 'NUMBER' },
+      { table: 'Subscriptions', column: 'autoAddCron', type: 'NUMBER' },
+      { table: 'Subscriptions', column: 'autoDelCron', type: 'NUMBER' },
+      { table: 'Crontabs', column: 'sub_id', type: 'NUMBER' },
+      { table: 'Crontabs', column: 'extra_schedules', type: 'JSON' },
+      { table: 'Crontabs', column: 'task_before', type: 'TEXT' },
+      { table: 'Crontabs', column: 'task_after', type: 'TEXT' },
+      { table: 'Crontabs', column: 'log_name', type: 'VARCHAR(255)' },
+      {
+        table: 'Crontabs',
+        column: 'allow_multiple_instances',
+        type: 'NUMBER',
+      },
+      { table: 'Envs', column: 'isPinned', type: 'NUMBER' },
+    ];
+
+    for (const migration of migrations) {
+      try {
+        await sequelize.query(
+          `alter table ${migration.table} add column ${migration.column} ${migration.type}`,
+        );
+      } catch (error) {
+        // Column already exists or other error, continue
+      }
+    }
+
+    Logger.info('✌️ DB loaded');
  } catch (error) {
-    Logger.error('[boot] DB load failed', error);
-    throw error;
+    Logger.error('✌️ DB load failed', error);
  }
 };
@@ -1,9 +1,22 @@
 import path from 'path';
 import fs from 'fs/promises';
 import os from 'os';
+import chokidar from 'chokidar';
 import config from '../config/index';
 import Logger from './logger';

+async function linkToNodeModule(src: string, dst?: string) {
+  const target = path.join(config.rootPath, 'node_modules', dst || src);
+  const source = path.join(config.rootPath, src);
+
+  try {
+    const stats = await fs.lstat(target);
+    if (!stats) {
+      await fs.symlink(source, target, 'dir');
+    }
+  } catch (error) { }
+}
+
 async function linkCommand() {
  const homeDir = os.homedir();
  let userBinDir = path.join(homeDir, 'bin');
@@ -17,50 +30,6 @@ async function linkCommand() {
 }

 async function linkCommandToDir(commandDir: string) {
-  const cliRoot = process.env.QL_CLI_ROOT;
-  if (cliRoot) {
-    if (!path.isAbsolute(cliRoot)) {
-      throw new Error('QL_CLI_ROOT must be an absolute CLI installation path');
-    }
-    const { installCliEntrypoints } = require(path.join(
-      cliRoot,
-      'dist/local/entrypoints.js',
-    ));
-    await installCliEntrypoints(commandDir, cliRoot);
-    const { installCronEntrypoint } = require(path.join(
-      cliRoot,
-      'dist/local/cronEntrypoint.js',
-    ));
-    await installCronEntrypoint(commandDir, cliRoot, config.crontabFile, {
-      ...process.env,
-      QL_DIR: config.rootPath,
-      QL_DATA_DIR: config.dataPath,
-    });
-    // Container-wide legacy links may precede ~/bin. Ensure panel children use
-    // the explicitly selected entries without changing system-wide links.
-    process.env.PATH = [
-      commandDir,
-      ...(process.env.PATH?.split(path.delimiter) ?? []).filter(
-        (entry) => entry !== commandDir,
-      ),
-    ].join(path.delimiter);
-    return;
-  }
-
-  const cronBridge = path.join(commandDir, 'crontab');
-  try {
-    if (
-      (await fs.lstat(cronBridge)).isFile() &&
-      (await fs.readFile(cronBridge, 'utf8')).includes(
-        '// QingLong CLI crontab bridge',
-      )
-    ) {
-      await fs.unlink(cronBridge);
-    }
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-  }
-
  const linkShell = [
    {
      src: 'update.sh',
@@ -83,13 +52,24 @@ async function linkCommandToDir(commandDir: string) {
      if (stats) {
        await fs.unlink(tmpTarget);
      }
-    } catch (error) {}
+    } catch (error) { }

    await fs.symlink(source, tmpTarget);
    await fs.rename(tmpTarget, target);
  }
 }

-export default async () => {
+export default async (src: string = 'deps') => {
  await linkCommand();
+  await linkToNodeModule(src);
+
+  const source = path.join(config.rootPath, src);
+  const watcher = chokidar.watch(source, {
+    ignored: /(^|[\/\\])\../, // ignore dotfiles
+    persistent: true,
+  });
+
+  watcher
+    .on('add', () => linkToNodeModule(src))
+    .on('change', () => linkToNodeModule(src));
 };
@@ -6,76 +6,33 @@ import config from '../config';
 import { UnauthorizedError, expressjwt } from 'express-jwt';
 import { getPlatform, getToken } from '../config/util';
 import rewrite from 'express-urlrewrite';
-import validationErrors from '../middlewares/validationErrors';
+import { errors } from 'celebrate';
 import { serveEnv } from '../config/serverEnv';
-import { shareStore } from '../shared/store';
-import { isValidToken, isDefaultAuthInfo } from '../shared/auth';
-import { AuthInfo } from '../data/system';
+import { IKeyvStore, shareStore } from '../shared/store';
+import { isValidToken } from '../shared/auth';
 import path from 'path';
-import { t } from '../shared/i18n';
-import { AppScope } from '../data/open';
-import uniqueConstraintError from '../middlewares/uniqueConstraintError';
-import protectedPathCase from '../middlewares/protectedPathCase';
-import { withAuthAvailability } from '../middlewares/authAvailability';
-function resolveTrustProxy(value = process.env.QL_TRUST_PROXY) {
-  const setting = value?.trim();
-  if (!setting) {
-    return 'loopback';
-  }
-  if (setting === 'true' || setting === 'false') {
-    return setting === 'true';
-  }
-  if (/^\d+$/.test(setting)) {
-    return Number(setting);
-  }
-  return setting;
-}
+
 export default ({ app }: { app: Application }) => {
-  // Security: Enable strict routing to prevent case-insensitive path bypass
-  app.set('case sensitive routing', true);
-  app.set('strict routing', true);
-  app.set('trust proxy', resolveTrustProxy());
+  app.set('trust proxy', 'loopback');
  app.use(cors());
-  // Security: Reject case variations under protected API namespaces before
-  // authentication checks can interpret the request differently from routing.
-  app.use(protectedPathCase);
-  // Rewrite URLs to strip baseUrl prefix if configured
-  // This allows the rest of the app to work without baseUrl awareness
-  if (config.baseUrl) {
-    app.use(rewrite(`${config.baseUrl}/*`, '/$1'));
-  }
  app.get(`${config.api.prefix}/env.js`, serveEnv);
-  app.use(
-    `${config.api.prefix}/static`,
-    express.static(config.uploadPath, {
-      setHeaders: (res) => {
-        res.setHeader('X-Content-Type-Options', 'nosniff');
-        res.setHeader('Content-Security-Policy', "sandbox; default-src 'none'");
-      },
-    }),
-  );
-  const credentialPaths = ['/api', '/open'].flatMap((prefix) =>
-    ['/user/login', '/user/init', '/user/two-factor/login'].map(
-      (route) => `${prefix}${route}`,
-    ),
-  );
-  app.use(
-    credentialPaths,
-    bodyParser.json({ limit: '16kb' }),
-    bodyParser.urlencoded({ limit: '16kb', extended: false }),
-  );
+  app.use(`${config.api.prefix}/static`, express.static(config.uploadPath));
+
  app.use(bodyParser.json({ limit: '50mb' }));
  app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));
+
  const frontendPath = path.join(config.rootPath, 'static/dist');
  app.use(express.static(frontendPath));
+
  app.use(
    expressjwt({
      secret: config.jwt.secret,
      algorithms: ['HS384'],
    }).unless({
-      path: [...config.apiWhiteList, /^(\/(?!api\/).*)$/i],
+      path: [...config.apiWhiteList, /^\/(?!api\/).*/],
    }),
  );
+
  app.use((req: Request, res, next) => {
    if (!req.headers) {
      req.platform = 'desktop';
@@ -85,92 +42,81 @@ export default ({ app }: { app: Application }) => {
    }
    return next();
  });
-  app.use(
-    withAuthAvailability(async (req: Request, res, next) => {
-      const pathLower = req.path.toLowerCase();
-      if (!['/open/', '/api/'].some((x) => pathLower.startsWith(x))) {
-        return next();
-      }
-      const headerToken = getToken(req);
-      if (pathLower.startsWith('/open/')) {
-        const apps = await shareStore.getApps();
-        const doc = apps?.filter((x) =>
-          x.tokens?.find((y) => y.value === headerToken),
-        )?.[0];
-        if (doc && doc.tokens && doc.tokens.length > 0) {
-          const currentToken = doc.tokens.find((x) => x.value === headerToken);
-          const keyMatch = pathLower.match(/\/open\/([a-z]+)\/*/);
-          const key = keyMatch && keyMatch[1];
-          if (!doc.scopes.includes(key as AppScope)) {
-            const err = new UnauthorizedError('credentials_bad_scheme', {
-              message: t('暂无权限'),
-            });
-            return next(err);
-          }
-          if (
-            !currentToken ||
-            currentToken.expiration < Math.round(Date.now() / 1000)
-          ) {
-            const err = new UnauthorizedError('invalid_token', {
-              message: t('Token 已失效'),
-            });
-            return next(err);
-          }
+
+  app.use(async (req: Request, res, next) => {
+    if (!['/open/', '/api/'].some((x) => req.path.startsWith(x))) {
+      return next();
+    }
+
+    const headerToken = getToken(req);
+    if (req.path.startsWith('/open/')) {
+      const apps = await shareStore.getApps();
+      const doc = apps?.filter((x) =>
+        x.tokens?.find((y) => y.value === headerToken),
+      )?.[0];
+      if (doc && doc.tokens && doc.tokens.length > 0) {
+        const currentToken = doc.tokens.find((x) => x.value === headerToken);
+        const keyMatch = req.path.match(/\/open\/([a-z]+)\/*/);
+        const key = keyMatch && keyMatch[1];
+        if (
+          doc.scopes.includes(key as any) &&
+          currentToken &&
+          currentToken.expiration >= Math.round(Date.now() / 1000)
+        ) {
          return next();
        }
      }
-      const originPath = `${req.baseUrl}${pathLower === '/' ? '' : pathLower}`;
-      if (
-        !headerToken &&
-        originPath &&
-        config.apiWhiteList.includes(originPath)
-      ) {
-        return next();
-      }
-      const authInfo = await shareStore.getAuthInfo();
-      if (
-        isValidToken(authInfo, headerToken, req.platform, config.jwt.secret)
-      ) {
-        return next();
-      }
-      const errorCode = headerToken ? 'invalid_token' : 'credentials_required';
-      const errorMessage = headerToken ? t('Token 已失效') : t('请先登录');
-      const err = new UnauthorizedError(errorCode, { message: errorMessage });
-      next(err);
-    }),
-  );
-  app.use(
-    withAuthAvailability(async (req, res, next) => {
-      const pathLower = req.path.toLowerCase();
-      if (
-        ![
-          '/api/user/init',
-          '/api/user/notification/init',
-          '/open/user/init',
-          '/open/user/notification/init',
-        ].includes(pathLower)
-      ) {
-        return next();
-      }
-      const authInfo = (await shareStore.getAuthInfo()) || ({} as AuthInfo);
-      let isInitialized = !isDefaultAuthInfo(authInfo);
-      if (isInitialized) {
-        return res.send({ code: 450, message: t('未知错误') });
-      } else {
-        return next();
-      }
-    }),
-  );
+    }
+
+    const originPath = `${req.baseUrl}${req.path === '/' ? '' : req.path}`;
+    if (
+      !headerToken &&
+      originPath &&
+      config.apiWhiteList.includes(originPath)
+    ) {
+      return next();
+    }
+
+    const authInfo = await shareStore.getAuthInfo();
+    if (isValidToken(authInfo, headerToken, req.platform)) {
+      return next();
+    }
+
+    const errorCode = headerToken ? 'invalid_token' : 'credentials_required';
+    const errorMessage = headerToken
+      ? 'jwt malformed'
+      : 'No authorization token was found';
+    const err = new UnauthorizedError(errorCode, { message: errorMessage });
+    next(err);
+  });
+
+  app.use(async (req, res, next) => {
+    if (!['/api/user/init', '/api/user/notification/init'].includes(req.path)) {
+      return next();
+    }
+    const authInfo =
+      (await shareStore.getAuthInfo()) || ({} as IKeyvStore['authInfo']);
+
+    let isInitialized = true;
+    if (
+      Object.keys(authInfo).length === 2 &&
+      authInfo.username === 'admin' &&
+      authInfo.password === 'admin'
+    ) {
+      isInitialized = false;
+    }
+
+    if (isInitialized) {
+      return res.send({ code: 450, message: '未知错误' });
+    } else {
+      return next();
+    }
+  });
+
  app.use(rewrite('/open/*', '/api/$1'));
  app.use(config.api.prefix, routes());
-  app.get('*', (req, res, next) => {
-    // Don't serve index.html for API routes
-    if (
-      req.path === config.api.prefix ||
-      req.path.startsWith(`${config.api.prefix}/`)
-    ) {
-      return res.status(404).json({ code: 404, message: 'Not Found' });
-    }
+
+  app.get('*', (_, res, next) => {
    const indexPath = path.join(frontendPath, 'index.html');
    res.sendFile(indexPath, (err) => {
      if (err) {
@@ -180,13 +126,12 @@ export default ({ app }: { app: Application }) => {
      }
    });
  });
-  app.use(validationErrors);
-  app.use(uniqueConstraintError);
+
+  app.use(errors());
+
  app.use(
    (
-      err: Error & {
-        status: number;
-      },
+      err: Error & { status: number },
      req: Request,
      res: Response,
      next: NextFunction,
@@ -200,16 +145,15 @@ export default ({ app }: { app: Application }) => {
      return next(err);
    },
  );
+
  app.use(
    (
-      err: Error & {
-        errors: any[];
-      },
+      err: Error & { errors: any[] },
      req: Request,
      res: Response,
      next: NextFunction,
    ) => {
-      if (err.name === 'DatabaseError') {
+      if (err.name.includes('Sequelize')) {
        return res
          .status(500)
          .send({
@@ -222,11 +166,10 @@ export default ({ app }: { app: Application }) => {
      return next(err);
    },
  );
+
  app.use(
    (
-      err: Error & {
-        status: number;
-      },
+      err: Error & { status: number },
      req: Request,
      res: Response,
      next: NextFunction,
@@ -1,33 +0,0 @@
-import type express from 'express';
-import config from '../config';
-
-export async function createHttpApplication(): Promise<express.Application> {
-  // Only the HTTP worker needs an Express application and its middleware.
-  const [
-    { default: createExpress },
-    { default: helmet },
-    { default: cors },
-    { default: compression },
-    { monitoringMiddleware },
-  ] = await Promise.all([
-    import('express'),
-    import('helmet'),
-    import('cors'),
-    import('compression'),
-    import('../middlewares/monitoring'),
-  ]);
-  const app = createExpress();
-  app.use((req, res, next) => {
-    if (req.query.t) delete req.query.t;
-    next();
-  });
-  app.use(
-    helmet({
-      contentSecurityPolicy: false,
-    }),
-  );
-  app.use(cors(config.cors));
-  app.use(compression());
-  app.use(monitoringMiddleware);
-  return app;
-}
@@ -1,5 +1,3 @@
-import { textSearch } from '../data/queries';
-import { Query, QuerySpec, orderBy } from '../data/queries';
 import DependenceService from '../services/dependence';
 import { exec } from 'child_process';
 import { Container } from 'typedi';
@@ -7,6 +5,7 @@ import { Crontab, CrontabModel, CrontabStatus } from '../data/cron';
 import CronService from '../services/cron';
 import EnvService from '../services/env';
 import { DependenceModel, DependenceStatus } from '../data/dependence';
+import { Op } from 'sequelize';
 import config from '../config';
 import { CrontabViewModel, CronViewType } from '../data/cronView';
 import { initPosition } from '../data/env';
@@ -14,13 +13,12 @@ import { AuthDataType, SystemModel } from '../data/system';
 import SystemService from '../services/system';
 import UserService from '../services/user';
 import { writeFile, readFile } from 'fs/promises';
-import { fileExist, isDemoEnv, safeJSONParse } from '../config/util';
+import { createRandomString, fileExist, safeJSONParse } from '../config/util';
 import OpenService from '../services/open';
 import { shareStore } from '../shared/store';
 import Logger from './logger';
-import cronClient from '../schedule/client';
-import { InstanceStatus, RunningInstanceModel } from '../data/runningInstance';
-import { setLang, systemLang } from '../shared/i18n';
+import { AppModel } from '../data/open';
+
 export default async () => {
  const cronService = Container.get(CronService);
  const envService = Container.get(EnvService);
@@ -28,16 +26,31 @@ export default async () => {
  const systemService = Container.get(SystemService);
  const userService = Container.get(UserService);
  const openService = Container.get(OpenService);
+
  // 初始化增加系统配置
-  await openService.initializeSystemApp();
-  const systemConfig = await SystemModel.getOrCreate({
-    type: AuthDataType.systemConfig,
+  let systemApp = (
+    await AppModel.findOne({
+      where: { name: 'system' },
+    })
+  )?.get({ plain: true });
+  if (!systemApp) {
+    systemApp = await AppModel.create({
+      name: 'system',
+      scopes: ['crons', 'system'],
+      client_id: createRandomString(12, 12),
+      client_secret: createRandomString(24, 24),
+    });
+  }
+  const [systemConfig] = await SystemModel.findOrCreate({
+    where: { type: AuthDataType.systemConfig },
  });
-  await SystemModel.getOrCreate({ type: AuthDataType.notification });
-  const authConfig = await SystemModel.getOrCreate({
-    type: AuthDataType.authConfig,
+  await SystemModel.findOrCreate({
+    where: { type: AuthDataType.notification },
  });
-  if (!authConfig?.info || isDemoEnv()) {
+  const [authConfig] = await SystemModel.findOrCreate({
+    where: { type: AuthDataType.authConfig },
+  });
+  if (!authConfig?.info) {
    let authInfo = {
      username: 'admin',
      password: 'admin',
@@ -51,34 +64,36 @@ export default async () => {
    } catch (error) {
      Logger.warn('Failed to read auth config file, using default credentials');
    }
-    await SystemModel.nativeUpdate(
-      { id: authConfig.id },
-      {
-        info: authInfo,
-        type: AuthDataType.authConfig,
-      },
-    );
+    await SystemModel.upsert({
+      id: authConfig?.id,
+      info: authInfo,
+      type: AuthDataType.authConfig,
+    });
  }
+
  const installDependencies = async () => {
-    const docs = await DependenceModel.find(
-      {},
-      {
-        orderBy: orderBy([
-          ['type', 'DESC'],
-          ['createdAt', 'DESC'],
-        ]),
-      },
-    );
-    await DependenceModel.nativeUpdate(
-      { id: docs.map((x) => x.id!) },
+    const docs = await DependenceModel.findAll({
+      where: {},
+      order: [
+        ['type', 'DESC'],
+        ['createdAt', 'DESC'],
+      ],
+      raw: true,
+    });
+
+    await DependenceModel.update(
      { status: DependenceStatus.queued, log: [] },
+      { where: { id: docs.map((x) => x.id!) } },
    );
+
    setTimeout(async () => {
      await dependenceService.installDependenceOneByOne(docs);
+
      const bootAfterLoader = await import('./bootAfter');
      bootAfterLoader.default();
    }, 5000);
  };
+
  // 初始化更新 linux/python/nodejs 镜像源配置
  if (systemConfig.info?.pythonMirror) {
    systemService.updatePythonMirror({
@@ -101,40 +116,33 @@ export default async () => {
      nodeMirror: systemConfig.info?.nodeMirror,
    });
  }
+
  // 初始化新增默认全部任务视图
-  CrontabViewModel.find({ type: CronViewType.系统, name: '全部任务' }, {}).then(
-    (docs) => {
-      if (docs.length === 0) {
-        CrontabViewModel.insert({
-          name: '全部任务',
-          type: CronViewType.系统,
-          position: initPosition / 2,
-        });
-      }
-    },
-  );
+  CrontabViewModel.findAll({
+    where: { type: CronViewType.系统, name: '全部任务' },
+    raw: true,
+  }).then((docs) => {
+    if (docs.length === 0) {
+      CrontabViewModel.create({
+        name: '全部任务',
+        type: CronViewType.系统,
+        position: initPosition / 2,
+      });
+    }
+  });
+
  // 初始化更新所有任务状态为空闲
-  await CrontabModel.nativeUpdate({}, { status: CrontabStatus.idle });
-  // 清空所有运行中的实例记录（服务重启后进程已不存在）
-  await RunningInstanceModel.nativeUpdate(
-    { status: InstanceStatus.running },
-    {
-      status: InstanceStatus.stopped,
-      finished_at: Math.floor(Date.now() / 1000),
-      // The previous process's exit code cannot be recovered after a restart.
-    },
-  );
+  await CrontabModel.update({ status: CrontabStatus.idle }, { where: {} });
+
  // 初始化时执行一次所有的 ql repo 任务
-  CrontabModel.find(
-    {
-      isDisabled: { ['$ne']: 1 },
-      $or: [
-        ...textSearch(['command'], 'ql repo').$or,
-        ...textSearch(['command'], 'ql raw').$or,
-      ],
+  CrontabModel.findAll({
+    where: {
+      isDisabled: { [Op.ne]: 1 },
+      command: {
+        [Op.or]: [{ [Op.like]: `%ql repo%` }, { [Op.like]: `%ql raw%` }],
+      },
    },
-    {},
-  ).then((docs) => {
+  }).then((docs) => {
    for (let i = 0; i < docs.length; i++) {
      const doc = docs[i];
      if (doc) {
@@ -142,79 +150,74 @@ export default async () => {
      }
    }
  });
+
  // 更新2.11.3以前的脚本路径
-  CrontabModel.find(
-    {
-      $or: ['scripts', 'config', 'log', 'db'].flatMap(
-        (folder) =>
-          textSearch(['command'], `/${config.rootPath}/${folder}/`).$or,
-      ),
+  CrontabModel.findAll({
+    where: {
+      command: {
+        [Op.or]: [
+          { [Op.like]: `%\/${config.rootPath}\/scripts\/%` },
+          { [Op.like]: `%\/${config.rootPath}\/config\/%` },
+          { [Op.like]: `%\/${config.rootPath}\/log\/%` },
+          { [Op.like]: `%\/${config.rootPath}\/db\/%` },
+        ],
+      },
    },
-    {},
-  ).then(async (docs) => {
+  }).then(async (docs) => {
    for (let i = 0; i < docs.length; i++) {
      const doc = docs[i];
      if (doc) {
        if (doc.command.includes(`${config.rootPath}/scripts/`)) {
-          await CrontabModel.nativeUpdate(
-            { id: doc.id },
+          await CrontabModel.update(
            { command: doc.command.replace(`${config.rootPath}/scripts/`, '') },
+            { where: { id: doc.id } },
          );
        }
        if (doc.command.includes(`${config.rootPath}/log/`)) {
-          await CrontabModel.nativeUpdate(
-            { id: doc.id },
+          await CrontabModel.update(
            {
              command: `${config.dataPath}/log/${doc.command.replace(
                `${config.rootPath}/log/`,
                '',
              )}`,
            },
+            { where: { id: doc.id } },
          );
        }
        if (doc.command.includes(`${config.rootPath}/config/`)) {
-          await CrontabModel.nativeUpdate(
-            { id: doc.id },
+          await CrontabModel.update(
            {
              command: `${config.dataPath}/config/${doc.command.replace(
                `${config.rootPath}/config/`,
                '',
              )}`,
            },
+            { where: { id: doc.id } },
          );
        }
        if (doc.command.includes(`${config.rootPath}/db/`)) {
-          await CrontabModel.nativeUpdate(
-            { id: doc.id },
+          await CrontabModel.update(
            {
              command: `${config.dataPath}/db/${doc.command.replace(
                `${config.rootPath}/db/`,
                '',
              )}`,
            },
+            { where: { id: doc.id } },
          );
        }
      }
    }
  });
-  // 初始化语言（必须在 autosave_crontab 之前）
-  const lang = systemConfig.info?.lang || systemLang();
-  setLang(lang);
-  // 确保 lang_env.sh 存在
-  try {
-    const langEnvExist = await fileExist(config.langEnvFile);
-    if (!langEnvExist) {
-      await writeFile(config.langEnvFile, `export QL_LANG='${lang}'\n`);
-    }
-  } catch {}
+
  // 初始化保存一次ck和定时任务数据
-  cronClient.readiness.configure(async () => {
-    await cronService.autosave_crontab(true);
-    await systemService.restoreCronConcurrency();
-  });
-  await cronClient.readiness.recover();
+  await cronService.autosave_crontab();
  await envService.set_envs();
+
  const authInfo = await userService.getAuthInfo();
+  const apps = await openService.findApps();
  await shareStore.updateAuthInfo(authInfo);
-  await openService.refreshApps();
+  if (apps?.length) {
+    await shareStore.updateApps(apps);
+  }
 };
@@ -20,7 +20,6 @@ const uploadPath = path.join(dataPath, 'upload/');
 const bakPath = path.join(dataPath, 'bak/');
 const samplePath = path.join(rootPath, 'sample/');
 const tmpPath = path.join(logPath, '.tmp/');
-const rootTmpPath = path.join(rootPath, '.tmp/');
 const confFile = path.join(configPath, 'config.sh');
 const sampleConfigFile = path.join(samplePath, 'config.sample.sh');
 const sampleTaskShellFile = path.join(samplePath, 'task.sample.sh');
@@ -45,7 +44,6 @@ const directories = [
  preloadPath,
  logPath,
  tmpPath,
-  rootTmpPath,
  uploadPath,
  sshPath,
  bakPath,
@@ -125,5 +123,5 @@ export default async () => {
    }
  }

-  Logger.info('[boot] Init file down');
+  Logger.info('✌️ Init file down');
 };
@@ -6,27 +6,26 @@ import SshKeyService from '../services/sshKey';
 import config from '../config';
 import { fileExist } from '../config/util';
 import { join } from 'path';
-import { t } from '../shared/i18n';
-import Logger from './logger';
-import { assertSubscriptionAlias } from '../shared/subscriptionPath';
+
 export default async () => {
  const systemService = Container.get(SystemService);
  const scheduleService = Container.get(ScheduleService);
  const subscriptionService = Container.get(SubscriptionService);
  const sshKeyService = Container.get(SshKeyService);
+
  // 生成内置token
  let tokenCommand = `ts-node-transpile-only ${join(
    config.rootPath,
    'back/token.ts',
  )}`;
  const tokenFile = join(config.rootPath, 'static/build/token.js');
+
  if (await fileExist(tokenFile)) {
    tokenCommand = `node ${tokenFile}`;
  }
-  tokenCommand += ' --renew';
  const cron = {
    id: NaN,
-    name: t('生成token'),
+    name: '生成token',
    command: tokenCommand,
    runOrigin: 'system',
  } as ScheduleTaskType;
@@ -38,13 +37,14 @@ export default async () => {
    },
    true,
  );
+
  // 运行删除日志任务
  const data = await systemService.getSystemConfig();
  if (data && data.info) {
    if (data.info.logRemoveFrequency) {
      const rmlogCron = {
        id: data.id as number,
-        name: t('删除日志'),
+        name: '删除日志',
        command: `ql rmlog ${data.info.logRemoveFrequency}`,
        runOrigin: 'system' as const,
      };
@@ -57,21 +57,18 @@ export default async () => {
        true,
      );
    }
+
    systemService.updateTimezone(data.info);
+    
    // Apply global SSH key if configured
    if (data.info.globalSshKey) {
      await sshKeyService.addGlobalSSHKey(data.info.globalSshKey, 'global');
    }
  }
+
  await subscriptionService.setSshConfig();
  const subs = await subscriptionService.list();
  for (const sub of subs) {
-    try {
-      const doc = sub;
-      assertSubscriptionAlias(doc.alias);
-      await subscriptionService.handleTask(doc, !sub.is_disabled);
-    } catch (error) {
-      Logger.warn(t('跳过订阅 %s 的无效定时配置: %s'), sub.id, error);
-    }
+    subscriptionService.handleTask(sub.get({ plain: true }), !sub.is_disabled);
  }
 };
@@ -4,7 +4,7 @@ import Sock from './sock';

 export default async ({ server }: { server: Server }) => {
  await Sock({ server });
-  Logger.info('[boot] Sock loaded');
+  Logger.info('✌️ Sock loaded');

  process.on('uncaughtException', (error) => {
    Logger.error('Uncaught exception:', error);
@@ -1,94 +1,35 @@
-import sockJs, { Connection } from 'sockjs';
+import sockJs from 'sockjs';
 import { Server } from 'http';
 import { Container } from 'typedi';
 import SockService from '../services/sock';
 import { getPlatform } from '../config/util';
 import { shareStore } from '../shared/store';
 import { isValidToken } from '../shared/auth';
-import config from '../config';

 export default async ({ server }: { server: Server }) => {
-  const echo = sockJs.createServer({
-    prefix: `${config.baseUrl}/api/ws`,
-    log: () => {},
-  });
+  const echo = sockJs.createServer({ prefix: '/api/ws', log: () => {} });
  const sockService = Container.get(SockService);
-  const sessions = new Map<Connection, { token: string; platform: string }>();
-  let sessionTimer: ReturnType<typeof setInterval> | undefined;
-  let checking = false;
-
-  const checkSessions = async () => {
-    if (checking || sessions.size === 0) return;
-    checking = true;
-    // Connections accepted during this read must not use an older snapshot.
-    const batch = [...sessions];
-    try {
-      const current = await shareStore.getAuthInfo();
-      // Reuse validation only within this synchronous check of one auth snapshot.
-      const validated = new Map<string, Map<string, boolean>>();
-      for (const [conn, { token, platform }] of batch) {
-        if (!sessions.has(conn)) continue;
-        let platforms = validated.get(token);
-        if (!platforms) {
-          platforms = new Map();
-          validated.set(token, platforms);
-        }
-        let valid = platforms.get(platform);
-        if (valid === undefined) {
-          valid = isValidToken(current, token, platform, config.jwt.secret);
-          platforms.set(platform, valid);
-        }
-        if (!valid) conn.close('401');
-      }
-    } catch {
-      for (const [conn] of batch) {
-        if (sessions.has(conn)) conn.close('401');
-      }
-    } finally {
-      checking = false;
-    }
-  };

  echo.on('connection', async (conn) => {
    if (!conn.headers || !conn.url || !conn.pathname) {
      conn.close('404');
-      return;
    }

-    let closed = false;
-    conn.on('close', () => {
-      closed = true;
-      sessions.delete(conn);
-      sockService.removeClient(conn);
-      if (sessions.size === 0 && sessionTimer) {
-        clearInterval(sessionTimer);
-        sessionTimer = undefined;
-      }
-    });
-
-    let authInfo;
-    try {
-      authInfo = await shareStore.getAuthInfo();
-    } catch {
-      if (!closed) conn.close('401');
-      return;
-    }
-    if (closed) return;
+    const authInfo = await shareStore.getAuthInfo();
    const platform = getPlatform(conn.headers['user-agent'] || '') || 'desktop';
    const headerToken = conn.url.replace(`${conn.pathname}?token=`, '');

-    if (isValidToken(authInfo, headerToken, platform, config.jwt.secret)) {
+    if (isValidToken(authInfo, headerToken, platform)) {
      sockService.addClient(conn);
-      sessions.set(conn, { token: headerToken, platform });
-      if (!sessionTimer) {
-        sessionTimer = setInterval(checkSessions, 1000);
-        sessionTimer.unref();
-      }

      conn.on('data', (message) => {
        conn.write(message);
      });

+      conn.on('close', function () {
+        sockService.removeClient(conn);
+      });
+
      return;
    }

@@ -1,18 +0,0 @@
-import type { RequestHandler } from 'express';
-import { t } from '../shared/i18n';
-
-// Express 4 does not forward rejected async middleware promises itself.
-export function withAuthAvailability(handler: RequestHandler): RequestHandler {
-  return (req, res, next) => {
-    void Promise.resolve()
-      .then(() => handler(req, res, next))
-      .catch(() => {
-        res.setHeader('Retry-After', '1');
-        next(
-          Object.assign(new Error(t('认证服务暂时不可用，请稍后重试')), {
-            status: 503,
-          }),
-        );
-      });
-  };
-}
@@ -3,34 +3,46 @@ import Logger from '../loaders/logger';
 import { performance } from 'perf_hooks';
 import { metricsService } from '../services/metrics';

-const UNMONITORED_PATH_SUFFIXES = ['/api/health', '/open/health'];
-const HTTP_METRIC_SAMPLE_INTERVAL = 10;
-let requestSampleOffset = 0;
+interface RequestMetrics {
+  method: string;
+  path: string;
+  duration: number;
+  statusCode: number;
+  timestamp: number;
+  platform?: string;
+}
+
+const requestMetrics: RequestMetrics[] = [];

 export const monitoringMiddleware = (
  req: Request,
  res: Response,
  next: NextFunction,
 ) => {
-  if (UNMONITORED_PATH_SUFFIXES.some((path) => req.path.endsWith(path))) {
-    return next();
-  }
-
  const start = performance.now();
  const originalEnd = res.end;

  res.end = function (chunk?: any, encoding?: any, cb?: any) {
    const duration = performance.now() - start;
-    const shouldSample = requestSampleOffset === 0;
-    requestSampleOffset =
-      (requestSampleOffset + 1) % HTTP_METRIC_SAMPLE_INTERVAL;
-    if (shouldSample) {
-      metricsService.record('http_request', duration, {
-        method: req.method,
-        path: req.path,
-        statusCode: res.statusCode.toString(),
-        ...(req.platform && { platform: req.platform }),
-      });
+    const metric: RequestMetrics = {
+      method: req.method,
+      path: req.path,
+      duration,
+      statusCode: res.statusCode,
+      timestamp: Date.now(),
+      platform: req.platform,
+    };
+
+    requestMetrics.push(metric);
+    metricsService.record('http_request', duration, {
+      method: req.method,
+      path: req.path,
+      statusCode: res.statusCode.toString(),
+      ...(req.platform && { platform: req.platform }),
+    });
+
+    if (requestMetrics.length > 1000) {
+      requestMetrics.shift();
    }

    if (duration > 1000) {
@@ -46,3 +58,23 @@ export const monitoringMiddleware = (

  next();
 };
+
+export const getMetrics = () => {
+  return {
+    totalRequests: requestMetrics.length,
+    averageDuration:
+      requestMetrics.reduce((acc, curr) => acc + curr.duration, 0) /
+      requestMetrics.length,
+    requestsByMethod: requestMetrics.reduce((acc, curr) => {
+      acc[curr.method] = (acc[curr.method] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>),
+    requestsByPlatform: requestMetrics.reduce((acc, curr) => {
+      if (curr.platform) {
+        acc[curr.platform] = (acc[curr.platform] || 0) + 1;
+      }
+      return acc;
+    }, {} as Record<string, number>),
+    recentRequests: requestMetrics.slice(-10),
+  };
+};
@@ -1,23 +0,0 @@
-import type { NextFunction, Request, Response } from 'express';
-
-export default function protectedPathCase(
-  req: Request,
-  res: Response,
-  next: NextFunction,
-) {
-  const originalPath = req.path;
-  const normalizedPath = originalPath.toLowerCase();
-
-  if (
-    originalPath !== normalizedPath &&
-    (normalizedPath.startsWith('/api/') ||
-      normalizedPath.startsWith('/open/'))
-  ) {
-    return res.status(400).json({
-      code: 400,
-      message: 'Invalid path format',
-    });
-  }
-
-  return next();
-}
@@ -1,13 +0,0 @@
-import { ErrorRequestHandler } from 'express';
-import { DatabaseError } from '../data/databaseErrors';
-import { t } from '../shared/i18n';
-// Handle the database constraint itself so concurrent writes are covered too.
-const uniqueConstraintError: ErrorRequestHandler = (err, req, res, next) => {
-  if (!(err instanceof DatabaseError) || err.code !== 'UNIQUE_CONSTRAINT')
-    return next(err);
-  // Constraint details can contain environment values or application credentials.
-  res
-    .status(409)
-    .json({ code: 409, message: t('资源已存在，请检查重复的名称或值') });
-};
-export default uniqueConstraintError;
@@ -1,18 +0,0 @@
-import { errors, isCelebrateError } from 'celebrate';
-import { ErrorRequestHandler } from 'express';
-import { t } from '../shared/i18n';
-
-const respond = errors();
-
-// Schemas are compiled once at startup; resolve their messages per request so
-// changing the system language also changes errors from those existing schemas.
-const validationErrors: ErrorRequestHandler = (error, req, res, next) => {
-  if (isCelebrateError(error)) {
-    for (const detail of error.details.values()) {
-      detail.message = detail.details.map((item) => t(item.message)).join('. ');
-    }
-  }
-  return respond(error, req, res, next);
-};
-
-export default validationErrors;
@@ -151,8 +151,6 @@ enum NotificationMode {
  chronocat = 18;
  ntfy = 19;
  wxPusherBot = 20;
-  wxPusherSpt = 21;
-  wpush = 22;
 }

 message NotificationInfo {
@@ -233,7 +231,6 @@ message NotificationInfo {
  optional string webhookContentType = 57;

  optional string larkKey = 58;
-  optional string larkSecret = 69;

  optional string ntfyUrl = 59;
  optional string ntfyTopic = 60;
@@ -246,12 +243,6 @@ message NotificationInfo {
  optional string wxPusherBotAppToken = 66;
  optional string wxPusherBotTopicIds = 67;
  optional string wxPusherBotUids = 68;
-
-  optional string wxPusherSptList = 70;
-
-  optional string wpushApiKey = 71;
-  optional string wpushChannel = 72;
-  optional string wpushTopicCode = 73;
 }

 message SystemNotifyRequest {
@@ -260,15 +251,6 @@ message SystemNotifyRequest {
  optional NotificationInfo notificationInfo = 3;
 }

-message RecordNotifyLogRequest {
-  string title = 1;
-  string content = 2;
-  bool success = 3;
-  string notifyType = 4;
-  string scriptName = 5;
-  string taskId = 6;
-}
-
 service Api {
  rpc GetEnvs(GetEnvsRequest) returns (EnvsResponse) {}
  rpc CreateEnv(CreateEnvRequest) returns (EnvsResponse) {}
@@ -280,7 +262,6 @@ service Api {
  rpc UpdateEnvNames(UpdateEnvNamesRequest) returns (Response) {}
  rpc GetEnvById(GetEnvByIdRequest) returns (EnvResponse) {}
  rpc SystemNotify(SystemNotifyRequest) returns (Response) {}
-  rpc RecordNotifyLog(RecordNotifyLogRequest) returns (Response) {}
  rpc GetCronDetail(CronDetailRequest) returns (CronDetailResponse) {}
  rpc CreateCron(CreateCronRequest) returns (CronResponse) {}
  rpc UpdateCron(UpdateCronRequest) returns (CronResponse) {}
@@ -290,4 +271,4 @@ service Api {
  rpc EnableCrons(EnableCronsRequest) returns (Response) {}
  rpc DisableCrons(DisableCronsRequest) returns (Response) {}
  rpc RunCrons(RunCronsRequest) returns (Response) {}
-}
+}
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
 //   protoc-gen-ts_proto  v2.6.1
-//   protoc               v6.31.1
+//   protoc               v3.17.3
 // source: back/protos/api.proto

 /* eslint-disable */
@@ -43,8 +43,6 @@ export enum NotificationMode {
  chronocat = 18,
  ntfy = 19,
  wxPusherBot = 20,
-  wxPusherSpt = 21,
-  wpush = 22,
  UNRECOGNIZED = -1,
 }

@@ -113,12 +111,6 @@ export function notificationModeFromJSON(object: any): NotificationMode {
    case 20:
    case "wxPusherBot":
      return NotificationMode.wxPusherBot;
-    case 21:
-    case "wxPusherSpt":
-      return NotificationMode.wxPusherSpt;
-    case 22:
-    case "wpush":
-      return NotificationMode.wpush;
    case -1:
    case "UNRECOGNIZED":
    default:
@@ -170,10 +162,6 @@ export function notificationModeToJSON(object: NotificationMode): string {
      return "ntfy";
    case NotificationMode.wxPusherBot:
      return "wxPusherBot";
-    case NotificationMode.wxPusherSpt:
-      return "wxPusherSpt";
-    case NotificationMode.wpush:
-      return "wpush";
    case NotificationMode.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
@@ -394,7 +382,6 @@ export interface NotificationInfo {
  webhookMethod?: string | undefined;
  webhookContentType?: string | undefined;
  larkKey?: string | undefined;
-  larkSecret?: string | undefined;
  ntfyUrl?: string | undefined;
  ntfyTopic?: string | undefined;
  ntfyPriority?: string | undefined;
@@ -405,10 +392,6 @@ export interface NotificationInfo {
  wxPusherBotAppToken?: string | undefined;
  wxPusherBotTopicIds?: string | undefined;
  wxPusherBotUids?: string | undefined;
-  wxPusherSptList?: string | undefined;
-  wpushApiKey?: string | undefined;
-  wpushChannel?: string | undefined;
-  wpushTopicCode?: string | undefined;
 }

 export interface SystemNotifyRequest {
@@ -417,15 +400,6 @@ export interface SystemNotifyRequest {
  notificationInfo?: NotificationInfo | undefined;
 }

-export interface RecordNotifyLogRequest {
-  title: string;
-  content: string;
-  success: boolean;
-  notifyType: string;
-  scriptName: string;
-  taskId: string;
-}
-
 function createBaseEnvItem(): EnvItem {
  return {
    id: undefined,
@@ -2973,7 +2947,6 @@ function createBaseNotificationInfo(): NotificationInfo {
    webhookMethod: undefined,
    webhookContentType: undefined,
    larkKey: undefined,
-    larkSecret: undefined,
    ntfyUrl: undefined,
    ntfyTopic: undefined,
    ntfyPriority: undefined,
@@ -2984,10 +2957,6 @@ function createBaseNotificationInfo(): NotificationInfo {
    wxPusherBotAppToken: undefined,
    wxPusherBotTopicIds: undefined,
    wxPusherBotUids: undefined,
-    wxPusherSptList: undefined,
-    wpushApiKey: undefined,
-    wpushChannel: undefined,
-    wpushTopicCode: undefined,
  };
 }

@@ -3167,9 +3136,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
    if (message.larkKey !== undefined) {
      writer.uint32(466).string(message.larkKey);
    }
-    if (message.larkSecret !== undefined) {
-      writer.uint32(554).string(message.larkSecret);
-    }
    if (message.ntfyUrl !== undefined) {
      writer.uint32(474).string(message.ntfyUrl);
    }
@@ -3200,18 +3166,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
    if (message.wxPusherBotUids !== undefined) {
      writer.uint32(546).string(message.wxPusherBotUids);
    }
-    if (message.wxPusherSptList !== undefined) {
-      writer.uint32(562).string(message.wxPusherSptList);
-    }
-    if (message.wpushApiKey !== undefined) {
-      writer.uint32(570).string(message.wpushApiKey);
-    }
-    if (message.wpushChannel !== undefined) {
-      writer.uint32(578).string(message.wpushChannel);
-    }
-    if (message.wpushTopicCode !== undefined) {
-      writer.uint32(586).string(message.wpushTopicCode);
-    }
    return writer;
  },

@@ -3686,14 +3640,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
          message.larkKey = reader.string();
          continue;
        }
-        case 69: {
-          if (tag !== 554) {
-            break;
-          }
-
-          message.larkSecret = reader.string();
-          continue;
-        }
        case 59: {
          if (tag !== 474) {
            break;
@@ -3774,38 +3720,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
          message.wxPusherBotUids = reader.string();
          continue;
        }
-        case 70: {
-          if (tag !== 562) {
-            break;
-          }
-
-          message.wxPusherSptList = reader.string();
-          continue;
-        }
-        case 71: {
-          if (tag !== 570) {
-            break;
-          }
-
-          message.wpushApiKey = reader.string();
-          continue;
-        }
-        case 72: {
-          if (tag !== 578) {
-            break;
-          }
-
-          message.wpushChannel = reader.string();
-          continue;
-        }
-        case 73: {
-          if (tag !== 586) {
-            break;
-          }
-
-          message.wpushTopicCode = reader.string();
-          continue;
-        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
@@ -3883,7 +3797,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
      webhookMethod: isSet(object.webhookMethod) ? globalThis.String(object.webhookMethod) : undefined,
      webhookContentType: isSet(object.webhookContentType) ? globalThis.String(object.webhookContentType) : undefined,
      larkKey: isSet(object.larkKey) ? globalThis.String(object.larkKey) : undefined,
-      larkSecret: isSet(object.larkSecret) ? globalThis.String(object.larkSecret) : undefined,
      ntfyUrl: isSet(object.ntfyUrl) ? globalThis.String(object.ntfyUrl) : undefined,
      ntfyTopic: isSet(object.ntfyTopic) ? globalThis.String(object.ntfyTopic) : undefined,
      ntfyPriority: isSet(object.ntfyPriority) ? globalThis.String(object.ntfyPriority) : undefined,
@@ -3898,10 +3811,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
        ? globalThis.String(object.wxPusherBotTopicIds)
        : undefined,
      wxPusherBotUids: isSet(object.wxPusherBotUids) ? globalThis.String(object.wxPusherBotUids) : undefined,
-      wxPusherSptList: isSet(object.wxPusherSptList) ? globalThis.String(object.wxPusherSptList) : undefined,
-      wpushApiKey: isSet(object.wpushApiKey) ? globalThis.String(object.wpushApiKey) : undefined,
-      wpushChannel: isSet(object.wpushChannel) ? globalThis.String(object.wpushChannel) : undefined,
-      wpushTopicCode: isSet(object.wpushTopicCode) ? globalThis.String(object.wpushTopicCode) : undefined,
    };
  },

@@ -4081,9 +3990,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
    if (message.larkKey !== undefined) {
      obj.larkKey = message.larkKey;
    }
-    if (message.larkSecret !== undefined) {
-      obj.larkSecret = message.larkSecret;
-    }
    if (message.ntfyUrl !== undefined) {
      obj.ntfyUrl = message.ntfyUrl;
    }
@@ -4114,18 +4020,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
    if (message.wxPusherBotUids !== undefined) {
      obj.wxPusherBotUids = message.wxPusherBotUids;
    }
-    if (message.wxPusherSptList !== undefined) {
-      obj.wxPusherSptList = message.wxPusherSptList;
-    }
-    if (message.wpushApiKey !== undefined) {
-      obj.wpushApiKey = message.wpushApiKey;
-    }
-    if (message.wpushChannel !== undefined) {
-      obj.wpushChannel = message.wpushChannel;
-    }
-    if (message.wpushTopicCode !== undefined) {
-      obj.wpushTopicCode = message.wpushTopicCode;
-    }
    return obj;
  },

@@ -4192,7 +4086,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
    message.webhookMethod = object.webhookMethod ?? undefined;
    message.webhookContentType = object.webhookContentType ?? undefined;
    message.larkKey = object.larkKey ?? undefined;
-    message.larkSecret = object.larkSecret ?? undefined;
    message.ntfyUrl = object.ntfyUrl ?? undefined;
    message.ntfyTopic = object.ntfyTopic ?? undefined;
    message.ntfyPriority = object.ntfyPriority ?? undefined;
@@ -4203,10 +4096,6 @@ export const NotificationInfo: MessageFns<NotificationInfo> = {
    message.wxPusherBotAppToken = object.wxPusherBotAppToken ?? undefined;
    message.wxPusherBotTopicIds = object.wxPusherBotTopicIds ?? undefined;
    message.wxPusherBotUids = object.wxPusherBotUids ?? undefined;
-    message.wxPusherSptList = object.wxPusherSptList ?? undefined;
-    message.wpushApiKey = object.wpushApiKey ?? undefined;
-    message.wpushChannel = object.wpushChannel ?? undefined;
-    message.wpushTopicCode = object.wpushTopicCode ?? undefined;
    return message;
  },
 };
@@ -4305,146 +4194,6 @@ export const SystemNotifyRequest: MessageFns<SystemNotifyRequest> = {
  },
 };

-function createBaseRecordNotifyLogRequest(): RecordNotifyLogRequest {
-  return { title: "", content: "", success: false, notifyType: "", scriptName: "", taskId: "" };
-}
-
-export const RecordNotifyLogRequest: MessageFns<RecordNotifyLogRequest> = {
-  encode(message: RecordNotifyLogRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.title !== "") {
-      writer.uint32(10).string(message.title);
-    }
-    if (message.content !== "") {
-      writer.uint32(18).string(message.content);
-    }
-    if (message.success !== false) {
-      writer.uint32(24).bool(message.success);
-    }
-    if (message.notifyType !== "") {
-      writer.uint32(34).string(message.notifyType);
-    }
-    if (message.scriptName !== "") {
-      writer.uint32(42).string(message.scriptName);
-    }
-    if (message.taskId !== "") {
-      writer.uint32(50).string(message.taskId);
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): RecordNotifyLogRequest {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseRecordNotifyLogRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-
-          message.title = reader.string();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-
-          message.content = reader.string();
-          continue;
-        }
-        case 3: {
-          if (tag !== 24) {
-            break;
-          }
-
-          message.success = reader.bool();
-          continue;
-        }
-        case 4: {
-          if (tag !== 34) {
-            break;
-          }
-
-          message.notifyType = reader.string();
-          continue;
-        }
-        case 5: {
-          if (tag !== 42) {
-            break;
-          }
-
-          message.scriptName = reader.string();
-          continue;
-        }
-        case 6: {
-          if (tag !== 50) {
-            break;
-          }
-
-          message.taskId = reader.string();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): RecordNotifyLogRequest {
-    return {
-      title: isSet(object.title) ? globalThis.String(object.title) : "",
-      content: isSet(object.content) ? globalThis.String(object.content) : "",
-      success: isSet(object.success) ? globalThis.Boolean(object.success) : false,
-      notifyType: isSet(object.notifyType) ? globalThis.String(object.notifyType) : "",
-      scriptName: isSet(object.scriptName) ? globalThis.String(object.scriptName) : "",
-      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : "",
-    };
-  },
-
-  toJSON(message: RecordNotifyLogRequest): unknown {
-    const obj: any = {};
-    if (message.title !== "") {
-      obj.title = message.title;
-    }
-    if (message.content !== "") {
-      obj.content = message.content;
-    }
-    if (message.success !== false) {
-      obj.success = message.success;
-    }
-    if (message.notifyType !== "") {
-      obj.notifyType = message.notifyType;
-    }
-    if (message.scriptName !== "") {
-      obj.scriptName = message.scriptName;
-    }
-    if (message.taskId !== "") {
-      obj.taskId = message.taskId;
-    }
-    return obj;
-  },
-
-  create<I extends Exact<DeepPartial<RecordNotifyLogRequest>, I>>(base?: I): RecordNotifyLogRequest {
-    return RecordNotifyLogRequest.fromPartial(base ?? ({} as any));
-  },
-  fromPartial<I extends Exact<DeepPartial<RecordNotifyLogRequest>, I>>(object: I): RecordNotifyLogRequest {
-    const message = createBaseRecordNotifyLogRequest();
-    message.title = object.title ?? "";
-    message.content = object.content ?? "";
-    message.success = object.success ?? false;
-    message.notifyType = object.notifyType ?? "";
-    message.scriptName = object.scriptName ?? "";
-    message.taskId = object.taskId ?? "";
-    return message;
-  },
-};
-
 export type ApiService = typeof ApiService;
 export const ApiService = {
  getEnvs: {
@@ -4537,15 +4286,6 @@ export const ApiService = {
    responseSerialize: (value: Response) => Buffer.from(Response.encode(value).finish()),
    responseDeserialize: (value: Buffer) => Response.decode(value),
  },
-  recordNotifyLog: {
-    path: "/com.ql.api.Api/RecordNotifyLog",
-    requestStream: false,
-    responseStream: false,
-    requestSerialize: (value: RecordNotifyLogRequest) => Buffer.from(RecordNotifyLogRequest.encode(value).finish()),
-    requestDeserialize: (value: Buffer) => RecordNotifyLogRequest.decode(value),
-    responseSerialize: (value: Response) => Buffer.from(Response.encode(value).finish()),
-    responseDeserialize: (value: Buffer) => Response.decode(value),
-  },
  getCronDetail: {
    path: "/com.ql.api.Api/GetCronDetail",
    requestStream: false,
@@ -4640,7 +4380,6 @@ export interface ApiServer extends UntypedServiceImplementation {
  updateEnvNames: handleUnaryCall<UpdateEnvNamesRequest, Response>;
  getEnvById: handleUnaryCall<GetEnvByIdRequest, EnvResponse>;
  systemNotify: handleUnaryCall<SystemNotifyRequest, Response>;
-  recordNotifyLog: handleUnaryCall<RecordNotifyLogRequest, Response>;
  getCronDetail: handleUnaryCall<CronDetailRequest, CronDetailResponse>;
  createCron: handleUnaryCall<CreateCronRequest, CronResponse>;
  updateCron: handleUnaryCall<UpdateCronRequest, CronResponse>;
@@ -4803,21 +4542,6 @@ export interface ApiClient extends Client {
    options: Partial<CallOptions>,
    callback: (error: ServiceError | null, response: Response) => void,
  ): ClientUnaryCall;
-  recordNotifyLog(
-    request: RecordNotifyLogRequest,
-    callback: (error: ServiceError | null, response: Response) => void,
-  ): ClientUnaryCall;
-  recordNotifyLog(
-    request: RecordNotifyLogRequest,
-    metadata: Metadata,
-    callback: (error: ServiceError | null, response: Response) => void,
-  ): ClientUnaryCall;
-  recordNotifyLog(
-    request: RecordNotifyLogRequest,
-    metadata: Metadata,
-    options: Partial<CallOptions>,
-    callback: (error: ServiceError | null, response: Response) => void,
-  ): ClientUnaryCall;
  getCronDetail(
    request: CronDetailRequest,
    callback: (error: ServiceError | null, response: CronDetailResponse) => void,
@@ -5,7 +5,6 @@ package com.ql.cron;
 service Cron {
  rpc addCron(AddCronRequest) returns (AddCronResponse);
  rpc delCron(DeleteCronRequest) returns (DeleteCronResponse);
-  rpc setConcurrency(SetConcurrencyRequest) returns (AddCronResponse);
 }

 message ISchedule { string schedule = 1; }
@@ -18,16 +17,10 @@ message ICron {
  string name = 5;
 }

-message AddCronRequest {
-  repeated ICron crons = 1;
-  bool replace = 2;
-}
+message AddCronRequest { repeated ICron crons = 1; }

 message AddCronResponse {}

 message DeleteCronRequest { repeated string ids = 1; }

 message DeleteCronResponse {}
-
-// Zero restores the default limit.
-message SetConcurrencyRequest { int32 concurrency = 1; }
@@ -1,7 +1,7 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
 //   protoc-gen-ts_proto  v2.6.1
-//   protoc               v5.28.3
+//   protoc               v3.17.3
 // source: back/protos/cron.proto

 /* eslint-disable */
@@ -35,7 +35,6 @@ export interface ICron {

 export interface AddCronRequest {
  crons: ICron[];
-  replace: boolean;
 }

 export interface AddCronResponse {
@@ -48,11 +47,6 @@ export interface DeleteCronRequest {
 export interface DeleteCronResponse {
 }

-/** Zero restores the default limit. */
-export interface SetConcurrencyRequest {
-  concurrency: number;
-}
-
 function createBaseISchedule(): ISchedule {
  return { schedule: "" };
 }
@@ -238,7 +232,7 @@ export const ICron: MessageFns<ICron> = {
 };

 function createBaseAddCronRequest(): AddCronRequest {
-  return { crons: [], replace: false };
+  return { crons: [] };
 }

 export const AddCronRequest: MessageFns<AddCronRequest> = {
@@ -246,9 +240,6 @@ export const AddCronRequest: MessageFns<AddCronRequest> = {
    for (const v of message.crons) {
      ICron.encode(v!, writer.uint32(10).fork()).join();
    }
-    if (message.replace !== false) {
-      writer.uint32(16).bool(message.replace);
-    }
    return writer;
  },

@@ -267,14 +258,6 @@ export const AddCronRequest: MessageFns<AddCronRequest> = {
          message.crons.push(ICron.decode(reader, reader.uint32()));
          continue;
        }
-        case 2: {
-          if (tag !== 16) {
-            break;
-          }
-
-          message.replace = reader.bool();
-          continue;
-        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
@@ -285,10 +268,7 @@ export const AddCronRequest: MessageFns<AddCronRequest> = {
  },

  fromJSON(object: any): AddCronRequest {
-    return {
-      crons: globalThis.Array.isArray(object?.crons) ? object.crons.map((e: any) => ICron.fromJSON(e)) : [],
-      replace: isSet(object.replace) ? globalThis.Boolean(object.replace) : false,
-    };
+    return { crons: globalThis.Array.isArray(object?.crons) ? object.crons.map((e: any) => ICron.fromJSON(e)) : [] };
  },

  toJSON(message: AddCronRequest): unknown {
@@ -296,9 +276,6 @@ export const AddCronRequest: MessageFns<AddCronRequest> = {
    if (message.crons?.length) {
      obj.crons = message.crons.map((e) => ICron.toJSON(e));
    }
-    if (message.replace !== false) {
-      obj.replace = message.replace;
-    }
    return obj;
  },

@@ -308,7 +285,6 @@ export const AddCronRequest: MessageFns<AddCronRequest> = {
  fromPartial<I extends Exact<DeepPartial<AddCronRequest>, I>>(object: I): AddCronRequest {
    const message = createBaseAddCronRequest();
    message.crons = object.crons?.map((e) => ICron.fromPartial(e)) || [];
-    message.replace = object.replace ?? false;
    return message;
  },
 };
@@ -457,64 +433,6 @@ export const DeleteCronResponse: MessageFns<DeleteCronResponse> = {
  },
 };

-function createBaseSetConcurrencyRequest(): SetConcurrencyRequest {
-  return { concurrency: 0 };
-}
-
-export const SetConcurrencyRequest: MessageFns<SetConcurrencyRequest> = {
-  encode(message: SetConcurrencyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    if (message.concurrency !== 0) {
-      writer.uint32(8).int32(message.concurrency);
-    }
-    return writer;
-  },
-
-  decode(input: BinaryReader | Uint8Array, length?: number): SetConcurrencyRequest {
-    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseSetConcurrencyRequest();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-
-          message.concurrency = reader.int32();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-
-  fromJSON(object: any): SetConcurrencyRequest {
-    return { concurrency: isSet(object.concurrency) ? globalThis.Number(object.concurrency) : 0 };
-  },
-
-  toJSON(message: SetConcurrencyRequest): unknown {
-    const obj: any = {};
-    if (message.concurrency !== 0) {
-      obj.concurrency = Math.round(message.concurrency);
-    }
-    return obj;
-  },
-
-  create<I extends Exact<DeepPartial<SetConcurrencyRequest>, I>>(base?: I): SetConcurrencyRequest {
-    return SetConcurrencyRequest.fromPartial(base ?? ({} as any));
-  },
-  fromPartial<I extends Exact<DeepPartial<SetConcurrencyRequest>, I>>(object: I): SetConcurrencyRequest {
-    const message = createBaseSetConcurrencyRequest();
-    message.concurrency = object.concurrency ?? 0;
-    return message;
-  },
-};
-
 export type CronService = typeof CronService;
 export const CronService = {
  addCron: {
@@ -535,21 +453,11 @@ export const CronService = {
    responseSerialize: (value: DeleteCronResponse) => Buffer.from(DeleteCronResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer) => DeleteCronResponse.decode(value),
  },
-  setConcurrency: {
-    path: "/com.ql.cron.Cron/setConcurrency",
-    requestStream: false,
-    responseStream: false,
-    requestSerialize: (value: SetConcurrencyRequest) => Buffer.from(SetConcurrencyRequest.encode(value).finish()),
-    requestDeserialize: (value: Buffer) => SetConcurrencyRequest.decode(value),
-    responseSerialize: (value: AddCronResponse) => Buffer.from(AddCronResponse.encode(value).finish()),
-    responseDeserialize: (value: Buffer) => AddCronResponse.decode(value),
-  },
 } as const;

 export interface CronServer extends UntypedServiceImplementation {
  addCron: handleUnaryCall<AddCronRequest, AddCronResponse>;
  delCron: handleUnaryCall<DeleteCronRequest, DeleteCronResponse>;
-  setConcurrency: handleUnaryCall<SetConcurrencyRequest, AddCronResponse>;
 }

 export interface CronClient extends Client {
@@ -583,21 +491,6 @@ export interface CronClient extends Client {
    options: Partial<CallOptions>,
    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
  ): ClientUnaryCall;
-  setConcurrency(
-    request: SetConcurrencyRequest,
-    callback: (error: ServiceError | null, response: AddCronResponse) => void,
-  ): ClientUnaryCall;
-  setConcurrency(
-    request: SetConcurrencyRequest,
-    metadata: Metadata,
-    callback: (error: ServiceError | null, response: AddCronResponse) => void,
-  ): ClientUnaryCall;
-  setConcurrency(
-    request: SetConcurrencyRequest,
-    metadata: Metadata,
-    options: Partial<CallOptions>,
-    callback: (error: ServiceError | null, response: AddCronResponse) => void,
-  ): ClientUnaryCall;
 }

 export const CronClient = makeGenericClientConstructor(CronService, "com.ql.cron.Cron") as unknown as {
@@ -1,113 +1,54 @@
-import { ServerUnaryCall, sendUnaryData, status } from '@grpc/grpc-js';
+import { ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js';
 import { AddCronRequest, AddCronResponse } from '../protos/cron';
-import { createCronJob, CronJob } from '../shared/cronScheduler';
-import { isValidCronSchedule } from '../shared/cronSchedule';
+import nodeSchedule from 'node-schedule';
 import { scheduleStacks } from './data';
 import { runCron } from '../shared/runCron';
 import Logger from '../loaders/logger';
-import { t, tf } from '../shared/i18n';
-
-// Validate the entire batch before replacing any existing jobs.
-const isValidCronField = (cron: string): boolean => {
-  return isValidCronSchedule(cron);
-};

 const addCron = (
  call: ServerUnaryCall<AddCronRequest, AddCronResponse>,
  callback: sendUnaryData<AddCronResponse>,
 ) => {
-  // ===== 第一遍：预校验所有 cron 表达式 =====
-  const validationErrors: string[] = [];
-
  for (const item of call.request.crons) {
-    const { id, schedule, extra_schedules } = item;
-
-    if (!isValidCronField(schedule)) {
-      validationErrors.push(
-        tf('任务ID %s: 无效的 cron 表达式 "%s"', String(id), schedule),
-      );
+    const { id, schedule, command, extra_schedules, name } = item;
+    if (scheduleStacks.has(id)) {
+      scheduleStacks.get(id)?.forEach((x) => x.cancel());
    }

+    Logger.info(
+      '[schedule][创建定时任务] 任务ID: %s, 名称: %s, cron: %s, 执行命令: %s',
+      id,
+      name,
+      schedule,
+      command,
+    );
+
    if (extra_schedules?.length) {
      extra_schedules.forEach((x) => {
-        if (!isValidCronField(x.schedule)) {
-          validationErrors.push(
-            tf(
-              '任务ID %s (extra_schedule): 无效的 cron 表达式 "%s"',
-              String(id),
-              x.schedule,
-            ),
-          );
-        }
+        Logger.info(
+          '[schedule][创建定时任务] 任务ID: %s, 名称: %s, cron: %s, 执行命令: %s',
+          id,
+          name,
+          x.schedule,
+          command,
+        );
      });
    }
-  }

-  if (validationErrors.length > 0) {
-    const details = validationErrors.join('\n');
-    const err: any = new Error(details);
-    err.code = status.INVALID_ARGUMENT;
-    err.details = details;
-    callback(err, null);
-    return;
-  }
-
-  // Prepare stopped jobs first: construction errors must preserve the old snapshot.
-  const prepared = new Map<string, CronJob[]>();
-  try {
-    for (const item of call.request.crons) {
-      const jobs: CronJob[] = [];
-      prepared.get(item.id)?.forEach((job) => job.cancel());
-      prepared.set(item.id, jobs);
-      for (const schedule of [
-        item.schedule,
-        ...(item.extra_schedules || []).map((x) => x.schedule),
-      ]) {
-        jobs.push(
-          createCronJob(
-            schedule,
-            async () => {
-              Logger.info(t('[schedule][准备运行任务] 命令: %s'), item.command);
-              await runCron(
-                item.command,
-                item,
-                () => scheduleStacks.get(item.id) === jobs,
-              );
-            },
-            {
-              name: `${item.id}: ${item.name || ''}`,
-              logger: Logger,
-              start: false,
-            },
-          ),
-        );
-      }
-    }
-  } catch (error) {
-    for (const jobs of prepared.values()) jobs.forEach((job) => job.cancel());
-    const err: any = new Error(
-      error instanceof Error ? error.message : String(error),
-    );
-    err.code = status.INVALID_ARGUMENT;
-    err.details = err.message;
-    callback(err, null);
-    return;
-  }
-
-  if (call.request.replace) {
-    for (const jobs of scheduleStacks.values())
-      jobs.forEach((job) => job?.cancel());
-    scheduleStacks.clear();
-  }
-  for (const [id, jobs] of prepared) {
-    scheduleStacks.get(id)?.forEach((job) => job.cancel());
-    scheduleStacks.set(id, jobs);
-    jobs.forEach((job) => job.start());
-    Logger.info(
-      t('[schedule][创建定时任务] 任务ID: %s, 规则数: %s'),
-      id,
-      jobs.length,
-    );
+    scheduleStacks.set(id, [
+      nodeSchedule.scheduleJob(id, schedule, async () => {
+        Logger.info(`[schedule][准备运行任务] 命令: ${command}`);
+        runCron(command, item);
+      }),
+      ...(extra_schedules?.length
+        ? extra_schedules.map((x) =>
+            nodeSchedule.scheduleJob(id, x.schedule, async () => {
+              Logger.info(`[schedule][准备运行任务] 命令: ${command}`);
+              runCron(command, item);
+            }),
+          )
+        : []),
+    ]);
  }

  callback(null, null);
@@ -16,7 +16,6 @@ import {
  MoveEnvRequest,
  Response,
  SystemNotifyRequest,
-  RecordNotifyLogRequest,
  UpdateEnvNamesRequest,
  UpdateEnvRequest,
 } from '../protos/api';
@@ -39,7 +38,9 @@ import {
  RunCronsRequest,
 } from '../protos/api';
 import { NotificationInfo } from '../data/notify';
+
 Container.set('logger', LoggerInstance);
+
 export const getEnvs = async (
  call: ServerUnaryCall<GetEnvsRequest, EnvsResponse>,
  callback: sendUnaryData<EnvsResponse>,
@@ -59,6 +60,7 @@ export const getEnvs = async (
    });
  }
 };
+
 export const createEnv = async (
  call: ServerUnaryCall<CreateEnvRequest, EnvsResponse>,
  callback: sendUnaryData<EnvsResponse>,
@@ -71,6 +73,7 @@ export const createEnv = async (
    callback(e);
  }
 };
+
 export const updateEnv = async (
  call: ServerUnaryCall<UpdateEnvRequest, EnvResponse>,
  callback: sendUnaryData<EnvResponse>,
@@ -83,6 +86,7 @@ export const updateEnv = async (
        message: 'id parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    const data = await envService.update(
      pick(call.request.env, ['id', 'name', 'value', 'remarks']) as EnvItem,
@@ -92,6 +96,7 @@ export const updateEnv = async (
    callback(e);
  }
 };
+
 export const deleteEnvs = async (
  call: ServerUnaryCall<DeleteEnvsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -103,6 +108,7 @@ export const deleteEnvs = async (
        message: 'ids parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    await envService.remove(call.request.ids);
    callback(null, { code: 200 });
@@ -110,6 +116,7 @@ export const deleteEnvs = async (
    callback(e);
  }
 };
+
 export const moveEnv = async (
  call: ServerUnaryCall<MoveEnvRequest, EnvResponse>,
  callback: sendUnaryData<EnvResponse>,
@@ -122,6 +129,7 @@ export const moveEnv = async (
        message: 'id parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    const data = await envService.move(call.request.id, {
      fromIndex: call.request.fromIndex,
@@ -132,6 +140,7 @@ export const moveEnv = async (
    callback(e);
  }
 };
+
 export const disableEnvs = async (
  call: ServerUnaryCall<DisableEnvsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -143,6 +152,7 @@ export const disableEnvs = async (
        message: 'ids parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    await envService.disabled(call.request.ids);
    callback(null, { code: 200 });
@@ -150,6 +160,7 @@ export const disableEnvs = async (
    callback(e);
  }
 };
+
 export const enableEnvs = async (
  call: ServerUnaryCall<EnableEnvsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -161,6 +172,7 @@ export const enableEnvs = async (
        message: 'ids parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    await envService.enabled(call.request.ids);
    callback(null, { code: 200 });
@@ -168,6 +180,7 @@ export const enableEnvs = async (
    callback(e);
  }
 };
+
 export const updateEnvNames = async (
  call: ServerUnaryCall<UpdateEnvNamesRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -179,6 +192,7 @@ export const updateEnvNames = async (
        message: 'ids parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    await envService.updateNames({
      ids: call.request.ids,
@@ -189,6 +203,7 @@ export const updateEnvNames = async (
    callback(e);
  }
 };
+
 export const getEnvById = async (
  call: ServerUnaryCall<GetEnvByIdRequest, EnvResponse>,
  callback: sendUnaryData<EnvResponse>,
@@ -201,6 +216,7 @@ export const getEnvById = async (
        message: 'id parameter is required',
      });
    }
+
    const envService = Container.get(EnvService);
    const data = await envService.getDb({ id: call.request.id });
    callback(null, {
@@ -211,6 +227,7 @@ export const getEnvById = async (
    callback(e);
  }
 };
+
 export const systemNotify = async (
  call: ServerUnaryCall<SystemNotifyRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -220,46 +237,26 @@ export const systemNotify = async (
    const data = await systemService.notify({
      title: call.request.title,
      content: call.request.content,
-      notificationInfo: call.request
-        .notificationInfo as unknown as NotificationInfo,
+      notificationInfo: call.request.notificationInfo as unknown as NotificationInfo,
    });
    callback(null, data);
  } catch (e: any) {
    callback(e);
  }
 };
-export const recordNotifyLog = async (
-  call: ServerUnaryCall<RecordNotifyLogRequest, Response>,
-  callback: sendUnaryData<Response>,
-) => {
-  try {
-    await Container.get(SystemService).recordNotifyLog({
-      title: call.request.title,
-      content: call.request.content,
-      status: call.request.success ? 0 : 1,
-      notifyType: call.request.notifyType,
-      source: 'script',
-      scriptName: call.request.scriptName,
-      taskId: call.request.taskId,
-    });
-    callback(null, { code: 200 });
-  } catch (error: any) {
-    callback(error);
-  }
-};
+
 const normalizeCronData = (data: CronItem | null): CronItem | undefined => {
  if (!data) return undefined;
-  const cron = data;
  return {
-    ...cron,
-    labels: cron.labels ?? [],
-    sub_id: cron.sub_id ?? undefined,
-    extra_schedules: cron.extra_schedules ?? [],
-    pid: cron.pid ?? undefined,
-    task_before: cron.task_before ?? undefined,
-    task_after: cron.task_after ?? undefined,
+    ...data,
+    sub_id: data.sub_id ?? undefined,
+    extra_schedules: data.extra_schedules ?? undefined,
+    pid: data.pid ?? undefined,
+    task_before: data.task_before ?? undefined,
+    task_after: data.task_after ?? undefined,
  };
 };
+
 export const getCronDetail = async (
  call: ServerUnaryCall<CronDetailRequest, CronDetailResponse>,
  callback: sendUnaryData<CronDetailResponse>,
@@ -281,6 +278,7 @@ export const getCronDetail = async (
    callback(e);
  }
 };
+
 export const createCron = async (
  call: ServerUnaryCall<CreateCronRequest, CronResponse>,
  callback: sendUnaryData<CronResponse>,
@@ -293,6 +291,7 @@ export const createCron = async (
    callback(e);
  }
 };
+
 export const updateCron = async (
  call: ServerUnaryCall<UpdateCronRequest, CronResponse>,
  callback: sendUnaryData<CronResponse>,
@@ -300,6 +299,7 @@ export const updateCron = async (
  try {
    const cronService = Container.get(CronService);
    const { id, ...fields } = call.request;
+
    const updateRequest = {
      id,
      ...Object.entries(fields).reduce((acc: any, [key, value]) => {
@@ -309,12 +309,14 @@ export const updateCron = async (
        return acc;
      }, {}),
    } as UpdateCronRequest;
+
    const data = (await cronService.update(updateRequest)) as CronItem;
    callback(null, { code: 200, data: normalizeCronData(data) });
  } catch (e: any) {
    callback(e);
  }
 };
+
 export const deleteCrons = async (
  call: ServerUnaryCall<DeleteCronsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -327,6 +329,7 @@ export const deleteCrons = async (
    callback(e);
  }
 };
+
 export const getCrons = async (
  call: ServerUnaryCall<GetCronsRequest, CronsResponse>,
  callback: sendUnaryData<CronsResponse>,
@@ -354,6 +357,7 @@ export const getCrons = async (
    });
  }
 };
+
 export const getCronById = async (
  call: ServerUnaryCall<GetCronByIdRequest, CronResponse>,
  callback: sendUnaryData<CronResponse>,
@@ -366,6 +370,7 @@ export const getCronById = async (
        message: 'id parameter is required',
      });
    }
+
    const cronService = Container.get(CronService);
    const data = (await cronService.getDb({ id: call.request.id })) as CronItem;
    callback(null, { code: 200, data: normalizeCronData(data) });
@@ -377,6 +382,7 @@ export const getCronById = async (
    });
  }
 };
+
 export const enableCrons = async (
  call: ServerUnaryCall<EnableCronsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -388,6 +394,7 @@ export const enableCrons = async (
        message: 'ids parameter is required',
      });
    }
+
    const cronService = Container.get(CronService);
    await cronService.enabled(call.request.ids);
    callback(null, { code: 200 });
@@ -395,6 +402,7 @@ export const enableCrons = async (
    callback(e);
  }
 };
+
 export const disableCrons = async (
  call: ServerUnaryCall<DisableCronsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -406,6 +414,7 @@ export const disableCrons = async (
        message: 'ids parameter is required',
      });
    }
+
    const cronService = Container.get(CronService);
    await cronService.disabled(call.request.ids);
    callback(null, { code: 200 });
@@ -413,6 +422,7 @@ export const disableCrons = async (
    callback(e);
  }
 };
+
 export const runCrons = async (
  call: ServerUnaryCall<RunCronsRequest, Response>,
  callback: sendUnaryData<Response>,
@@ -424,6 +434,7 @@ export const runCrons = async (
        message: 'ids parameter is required',
      });
    }
+
    const cronService = Container.get(CronService);
    await cronService.run(call.request.ids);
    callback(null, { code: 200 });
@@ -1,4 +1,4 @@
-import { credentials, status, Metadata } from '@grpc/grpc-js';
+import { credentials } from '@grpc/grpc-js';
 import {
  AddCronRequest,
  AddCronResponse,
@@ -7,122 +7,30 @@ import {
  DeleteCronResponse,
 } from '../protos/cron';
 import config from '../config';
-import { getGrpcCerts } from '../config/grpcCerts';
-
-import { HealthService } from '../protos/health';
-import { SchedulerReadiness } from '../shared/schedulerReadiness';

 class Client {
-  readonly readiness = new SchedulerReadiness(() => this.probe());
+  private client = new CronClient(
+    `0.0.0.0:${config.grpcPort}`,
+    credentials.createInsecure(),
+    { 'grpc.enable_http_proxy': 0 },
+  );

-  private async waitForReady(timeoutMs: number) {
-    try {
-      await new Promise<void>((resolve, reject) => {
-        this.client.waitForReady(Date.now() + timeoutMs, (err) =>
-          err ? reject(err) : resolve()
-        );
-      });
-    } catch (error) {
-      this.readiness.invalidate();
-      throw Object.assign(
-        error instanceof Error ? error : new Error(String(error)),
-        { status: 503 }
-      );
-    }
-  }
-
-  private async probe(): Promise<void> {
-    await this.waitForReady(1000);
-    await new Promise<void>((resolve, reject) => {
-      this.client.makeUnaryRequest(
-        HealthService.check.path,
-        HealthService.check.requestSerialize,
-        HealthService.check.responseDeserialize,
-        { service: 'scheduler' },
-        { deadline: Date.now() + 1000 },
-        (err, res) => err ? reject(err) : res?.status === 1 ? resolve() : reject(new Error('Scheduler unavailable')),
-      );
-    });
-  }
-  private _client: CronClient | null = null;
-
-  private get client(): CronClient {
-    if (!this._client) {
-      const tlsConfig = getGrpcCerts()!;
-      this._client = new CronClient(
-        `localhost:${config.grpcPort}`,
-        credentials.createSsl(
-          Buffer.from(tlsConfig.caCert),
-          Buffer.from(tlsConfig.clientKey),
-          Buffer.from(tlsConfig.clientCert),
-        ),
-        { 'grpc.enable_http_proxy': 0 },
-      );
-    }
-    return this._client;
-  }
-
-  async setConcurrency(concurrency: number): Promise<void> {
-    await this.waitForReady(2000);
+  addCron(request: AddCronRequest['crons']): Promise<AddCronResponse> {
    return new Promise((resolve, reject) => {
-      this.client.setConcurrency(
-        { concurrency }, new Metadata(), { deadline: Date.now() + 5000 },
-        (err) => {
-          if (err) {
-            if (err.code === status.UNAVAILABLE || err.code === status.DEADLINE_EXCEEDED) {
-              this.readiness.invalidate();
-              Object.assign(err, { status: 503 });
-            }
-            return reject(err);
-          }
-          resolve();
-        },
-      );
-    });
-  }
-
-  async addCron(
-    request: AddCronRequest['crons'],
-    replace = false
-  ): Promise<AddCronResponse> {
-    await this.waitForReady(2000);
-    // Include every rule in a recovery snapshot, but bound a stuck worker.
-    const ruleCount = request.reduce(
-      (count, item) => count + 1 + (item.extra_schedules?.length || 0),
-      0,
-    );
-    const registrationTimeoutMs = Math.min(120000, 5000 + ruleCount * 5);
-    return new Promise((resolve, reject) => {
-      this.client.addCron(
-        { crons: request, replace },
-        new Metadata(),
-        { deadline: Date.now() + registrationTimeoutMs },
-        (err, res) => {
-          if (err) {
-            if (err.code === status.UNAVAILABLE || err.code === status.DEADLINE_EXCEEDED) {
-              // A timed-out write may already have reached the scheduler.
-              // Reconcile its state from the DB instead of replaying the RPC.
-              this.readiness.invalidate();
-              Object.assign(err, { status: 503 });
-            }
-            return reject(err);
-          }
-          resolve(res);
-        }
-      );
-    });
-  }
-
-  async delCron(request: DeleteCronRequest['ids']): Promise<DeleteCronResponse> {
-    await this.waitForReady(2000);
-    return new Promise((resolve, reject) => {
-      this.client.delCron({ ids: request }, new Metadata(), { deadline: Date.now() + 5000 }, (err, res) => {
+      this.client.addCron({ crons: request }, (err, res) => {
        if (err) {
-          if (err.code === status.UNAVAILABLE || err.code === status.DEADLINE_EXCEEDED) {
-            this.readiness.invalidate();
-            Object.assign(err, { status: 503 });
-          }
-          return reject(err);
+          reject(err);
+        }
+        resolve(res);
+      });
+    });
+  }
+
+  delCron(request: DeleteCronRequest['ids']): Promise<DeleteCronResponse> {
+    return new Promise((resolve, reject) => {
+      this.client.delCron({ ids: request }, (err, res) => {
+        if (err) {
+          reject(err);
        }
        resolve(res);
      });
@@ -1,6 +1,6 @@
-import { CronJob } from '../shared/cronScheduler';
+import nodeSchedule from 'node-schedule';
 import { ToadScheduler } from 'toad-scheduler';

-export const scheduleStacks = new Map<string, CronJob[]>();
+export const scheduleStacks = new Map<string, nodeSchedule.Job[]>();

 export const intervalSchedule = new ToadScheduler();
@@ -1,4 +1,3 @@
-import { t } from '../shared/i18n';
 import { ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js';
 import { DeleteCronRequest, DeleteCronResponse } from '../protos/cron';
 import { scheduleStacks } from './data';
@@ -10,24 +9,11 @@ const delCron = (
 ) => {
  for (const id of call.request.ids) {
    if (scheduleStacks.has(id)) {
-      Logger.info(t('[schedule][取消定时任务] 任务ID: %s'), id);
-      // 防御性过滤历史调度栈中的空任务，
-      // 否则对 null 调 cancel() 会让整个取消流程抛出 UNKNOWN 错误，
-      // 进而导致 HTTP 端的 remove() 跳过 setCrontab()，造成 crontab.list 残留。
-      scheduleStacks
-        .get(id)
-        ?.filter((x) => x != null)
-        .forEach((x) => {
-          try {
-            x.cancel();
-          } catch (error: any) {
-            Logger.warn(
-              t('[schedule][取消任务失败] 任务ID: %s, 错误: %s'),
-              id,
-              error?.message || error,
-            );
-          }
-        });
+      Logger.info(
+        '[schedule][取消定时任务] 任务ID: %s',
+        id,
+      );
+      scheduleStacks.get(id)?.forEach(x => x.cancel());
      scheduleStacks.delete(id);
    }
  }
@@ -1,108 +1,28 @@
 import { ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js';
-import fs from 'fs/promises';
-import path from 'path';
-import { request } from 'undici';
 import { HealthCheckRequest, HealthCheckResponse } from '../protos/health';
 import config from '../config';
-import { database } from '../data';
-
-function formatError(error: unknown): string {
-  if (!(error instanceof Error)) {
-    return String(error);
-  }
-
-  const detailedError = error as Error & {
-    cause?: unknown;
-    code?: string;
-    errors?: unknown[];
-  };
-  const details = [error.message, detailedError.code];
-  if (Array.isArray(detailedError.errors)) {
-    details.push(...detailedError.errors.map(formatError));
-  } else if (detailedError.cause) {
-    details.push(formatError(detailedError.cause));
-  }
-
-  return [...new Set(details.filter(Boolean))].join(': ') || error.name;
-}
-
-async function getRecentSystemLog(lineLimit = 300): Promise<string> {
-  try {
-    const entries = await fs.readdir(config.systemLogPath);
-    const latestLog = entries
-      .filter((entry) => entry.endsWith('.log'))
-      .sort()
-      .at(-1);
-    if (!latestLog) {
-      return `No system log found in ${config.systemLogPath}`;
-    }
-    const content = await fs.readFile(
-      path.join(config.systemLogPath, latestLog),
-      'utf8',
-    );
-    return content.split('\n').slice(-lineLimit).join('\n').trim();
-  } catch (error) {
-    return `Unable to read system log from ${config.systemLogPath}: ${
-      error instanceof Error ? error.message : String(error)
-    }`;
-  }
-}
+import { promiseExec } from '../config/util';

 const check = async (
  call: ServerUnaryCall<HealthCheckRequest, HealthCheckResponse>,
  callback: sendUnaryData<HealthCheckResponse>,
 ) => {
  switch (call.request.service) {
-    // Local scheduler liveness only: never call HTTP from this probe.
-    case 'scheduler':
-      return callback(null, { status: database.healthy ? 1 : 2 });
-    case 'cron': {
-      const healthUrl = `http://localhost:${config.port}${
-        config.baseUrl || ''
-      }/api/health`;
-      let failure = '';
-      try {
-        const response = await request(healthUrl, {
-          method: 'GET',
-          headersTimeout: 5000,
-          bodyTimeout: 5000,
-        });
-        const body = (await response.body.json()) as {
-          code?: number;
-          data?: { status?: string };
-        };
-        if (
-          response.statusCode >= 200 &&
-          response.statusCode < 300 &&
-          body.code === 200 &&
-          body.data?.status === 'ok'
-        ) {
-          return callback(null, { status: 1 });
-        }
-        failure = `HTTP ${response.statusCode}: ${JSON.stringify(body)}`;
-      } catch (error) {
-        failure = formatError(error);
+    case 'cron':
+      const res = await promiseExec(
+        `curl -s --noproxy '*' http://0.0.0.0:${config.port}/api/system`,
+      );
+
+      if (res.includes('200')) {
+        return callback(null, { status: 1 });
      }

-      const systemLog = await getRecentSystemLog();
-      const containerHint =
-        process.env.QL_CONTAINER === 'true'
-          ? 'PM2 file logging is disabled in containers. Check `docker logs <container>` for early startup errors.'
-          : 'Check `pm2 logs qinglong --lines 300` for early startup errors.';
+      const qinglongErrLog = await promiseExec(
+        `tail -n 300 ~/.pm2/logs/qinglong-error.log`,
+      );
      return callback(
-        new Error(
-          [
-            `HTTP health check failed: ${healthUrl}`,
-            failure,
-            containerHint,
-            `Recent system log (${config.systemLogPath}):`,
-            systemLog,
-          ]
-            .filter(Boolean)
-            .join('\n'),
-        ),
+        new Error(`${qinglongErrLog || ''}\n${res}`.trim()),
      );
-    }

    default:
      return callback(null, { status: 1 });
@@ -1,26 +0,0 @@
-import { ServerUnaryCall, sendUnaryData, status } from '@grpc/grpc-js';
-import os from 'os';
-import { AddCronResponse, SetConcurrencyRequest } from '../protos/cron';
-import taskLimit from '../shared/pLimit';
-
-export async function setConcurrency(
-  call: ServerUnaryCall<SetConcurrencyRequest, AddCronResponse>,
-  callback: sendUnaryData<AddCronResponse>,
-) {
-  const limit = call.request.concurrency;
-  if (!Number.isInteger(limit) || limit < 0 || limit > 2147483647) {
-    callback(
-      Object.assign(new Error('Invalid concurrency'), {
-        code: status.INVALID_ARGUMENT,
-      }),
-      null,
-    );
-    return;
-  }
-  try {
-    await taskLimit.setCustomLimit(limit || Math.max(os.cpus().length, 4));
-    callback(null, {});
-  } catch (error) {
-    callback(error as Error, null);
-  }
-}
@@ -1,10 +1,9 @@
-import { Service } from 'typedi';
+import { Service, Inject } from 'typedi';
+import path, { join } from 'path';
 import config from '../config';
 import { getFileContentByName } from '../config/util';
-import { t } from '../shared/i18n';
 import { Response } from 'express';
 import { request } from 'undici';
-import { resolveFileAccess } from '../shared/fileAccess';

@Service()
 export default class ConfigService {
@@ -12,16 +11,19 @@ export default class ConfigService {

  public async getFile(filePath: string, res: Response) {
    let content = '';
-    if (!filePath || filePath.startsWith('data/scripts/')) {
-      return res.send({ code: 403, message: t('文件无法访问') });
-    }
-    const resolved = resolveFileAccess(
-      config.configPath,
-      [filePath],
-      config.blackFileList,
+    const avaliablePath = [config.rootPath, config.configPath].map((x) =>
+      path.resolve(x, filePath),
    );
-    if (!resolved) {
-      return res.send({ code: 403, message: t('文件无法访问') });
+
+    if (
+      config.blackFileList.includes(filePath) ||
+      avaliablePath.every(
+        (x) =>
+          !x.startsWith(config.scriptPath) && !x.startsWith(config.configPath),
+      ) ||
+      !filePath
+    ) {
+      return res.send({ code: 403, message: '文件无法访问' });
    }

    if (filePath.startsWith('sample/')) {
@@ -29,8 +31,10 @@ export default class ConfigService {
        `https://gitlab.com/whyour/qinglong/-/raw/master/${filePath}`,
      );
      content = await res.body.text();
+    } else if (filePath.startsWith('data/scripts/')) {
+      content = await getFileContentByName(join(config.rootPath, filePath));
    } else {
-      content = await getFileContentByName(resolved);
+      content = await getFileContentByName(join(config.configPath, filePath));
    }

    res.send({ code: 200, data: content });
@@ -1,4 +1,3 @@
-import { Query, QuerySpec, orderBy } from '../data/queries';
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import { CrontabView, CrontabViewModel } from '../data/cronView';
@@ -8,12 +7,12 @@ import {
  minPosition,
  stepPosition,
 } from '../data/env';
+import { FindOptions } from 'sequelize';
+
@Service()
 export default class CronViewService {
-  constructor(
-    @Inject('logger')
-    private logger: winston.Logger,
-  ) {}
+  constructor(@Inject('logger') private logger: winston.Logger) {}
+
  public async create(payload: CrontabView): Promise<CrontabView> {
    let position = initPosition;
    const views = await this.list();
@@ -23,51 +22,61 @@ export default class CronViewService {
    position = position / 2;
    const tab = new CrontabView({ ...payload, position });
    const doc = await this.insert(tab);
+
    await this.checkPosition(tab.position!);
    return doc;
  }
+
  public async insert(payload: CrontabView): Promise<CrontabView> {
-    return await CrontabViewModel.insert(payload);
+    return await CrontabViewModel.create(payload, { returning: true });
  }
+
  public async update(payload: CrontabView): Promise<CrontabView> {
    const doc = await this.getDb({ id: payload.id });
    const tab = new CrontabView({ ...doc, ...payload });
    const newDoc = await this.updateDb(tab);
    return newDoc;
  }
+
  public async updateDb(payload: CrontabView): Promise<CrontabView> {
-    await CrontabViewModel.nativeUpdate({ id: payload.id }, payload);
+    await CrontabViewModel.update(payload, { where: { id: payload.id } });
    return await this.getDb({ id: payload.id });
  }
+
  public async remove(ids: number[]) {
-    await CrontabViewModel.nativeDelete({ id: ids });
+    await CrontabViewModel.destroy({ where: { id: ids } });
  }
+
  public async list(): Promise<CrontabView[]> {
    try {
-      const result = await CrontabViewModel.find(
-        {},
-        {
-          orderBy: orderBy([['position', 'DESC']]),
-        },
-      );
+      const result = await CrontabViewModel.findAll({
+        where: {},
+        order: [['position', 'DESC']],
+      });
      return result;
    } catch (error) {
      throw error;
    }
  }
-  public async getDb(query: QuerySpec['where']): Promise<CrontabView> {
-    const doc: any = await CrontabViewModel.findOne({ ...query }, {});
+
+  public async getDb(
+    query: FindOptions<CrontabView>['where'],
+  ): Promise<CrontabView> {
+    const doc: any = await CrontabViewModel.findOne({ where: { ...query } });
    if (!doc) {
      throw new Error(`CronView ${JSON.stringify(query)} not found`);
    }
-    return doc;
+    return doc.get({ plain: true });
  }
+
  public async disabled(ids: number[]) {
-    await CrontabViewModel.nativeUpdate({ id: ids }, { isDisabled: 1 });
+    await CrontabViewModel.update({ isDisabled: 1 }, { where: { id: ids } });
  }
+
  public async enabled(ids: number[]) {
-    await CrontabViewModel.nativeUpdate({ id: ids }, { isDisabled: 0 });
+    await CrontabViewModel.update({ isDisabled: 0 }, { where: { id: ids } });
  }
+
  private async checkPosition(position: number) {
    const precisionPosition = parseFloat(position.toPrecision(16));
    if (precisionPosition < minPosition || precisionPosition > maxPosition) {
@@ -79,9 +88,11 @@ export default class CronViewService {
      }
    }
  }
+
  private getPrecisionPosition(position: number): number {
    return parseFloat(position.toPrecision(16));
  }
+
  public async move({
    id,
    fromIndex,
@@ -107,6 +118,7 @@ export default class CronViewService {
      id,
      position: this.getPrecisionPosition(targetPosition),
    });
+
    await this.checkPosition(targetPosition);
    return newDoc;
  }
@@ -1,5 +1,3 @@
-import { textSearch } from '../data/queries';
-import { Query, QuerySpec, orderBy } from '../data/queries';
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import config from '../config';
@@ -12,32 +10,30 @@ import {
 } from '../data/dependence';
 import { spawn } from 'cross-spawn';
 import SockService from './sock';
+import { FindOptions, Op } from 'sequelize';
 import {
  fileExist,
  getPid,
  killTask,
  promiseExecSuccess,
-  concurrentRun,
  getInstallCommand,
  getUninstallCommand,
  getGetCommand,
-  isPythonSourceDependency,
 } from '../config/util';
 import dayjs from 'dayjs';
 import taskLimit from '../shared/pLimit';
 import { detectOS } from '../config/util';
 import { LINUX_DEPENDENCE_COMMAND } from '../config/const';
-import { t, tf } from '../shared/i18n';
+
@Service()
 export default class DependenceService {
  constructor(
-    @Inject('logger')
-    private logger: winston.Logger,
+    @Inject('logger') private logger: winston.Logger,
    private sockService: SockService,
-  ) {}
+  ) { }
+
  public async create(payloads: Dependence[]): Promise<Dependence[]> {
    const tabs = payloads.map((x) => {
-      getInstallCommand(x.type, x.name);
      const tab = new Dependence({ ...x, status: DependenceStatus.queued });
      return tab;
    });
@@ -45,14 +41,14 @@ export default class DependenceService {
    this.installDependenceOneByOne(docs);
    return docs;
  }
+
  public async insert(payloads: Dependence[]): Promise<Dependence[]> {
-    const docs = await DependenceModel.insertMany(payloads);
+    const docs = await DependenceModel.bulkCreate(payloads);
    return docs;
  }
+
  public async update(
-    payload: Dependence & {
-      id: string;
-    },
+    payload: Dependence & { id: string },
  ): Promise<Dependence> {
    const { id, ...other } = payload;
    const doc = await this.getDb({ id });
@@ -61,43 +57,44 @@ export default class DependenceService {
      ...other,
      status: DependenceStatus.queued,
    });
-    getInstallCommand(tab.type, tab.name);
    const newDoc = await this.updateDb(tab);
    this.installDependenceOneByOne([newDoc]);
    return newDoc;
  }
+
  private async updateDb(payload: Dependence): Promise<Dependence> {
-    await DependenceModel.nativeUpdate({ id: payload.id }, payload);
+    await DependenceModel.update(payload, { where: { id: payload.id } });
    return await this.getDb({ id: payload.id });
  }
+
  public async remove(ids: number[], force = false): Promise<Dependence[]> {
-    const docs = await DependenceModel.find({ id: ids }, {});
+    const docs = await DependenceModel.findAll({ where: { id: ids } });
    for (const doc of docs) {
      taskLimit.removeQueuedDependency(doc);
    }
+    const unInstalledDeps = docs.filter(
+      (x) => x.status !== DependenceStatus.installed,
+    );
    const installedDeps = docs.filter(
-      (x) =>
-        x.status === DependenceStatus.installed ||
-        // Older list refreshes marked unprobeable sources as failed. They may
-        // still have installed distributions (including partial pip installs).
-        (x.status === DependenceStatus.installFailed &&
-          x.type === DependenceTypes.python3 &&
-          isPythonSourceDependency(x.name)),
+      (x) => x.status === DependenceStatus.installed,
    );
-    const unInstalledDeps = docs.filter((x) => !installedDeps.includes(x));
    await this.removeDb(unInstalledDeps.map((x) => x.id!));
+
    if (installedDeps.length) {
-      await DependenceModel.nativeUpdate(
-        { id: installedDeps.map((x) => x.id!) },
+      await DependenceModel.update(
        { status: DependenceStatus.queued, log: [] },
+        { where: { id: ids } },
      );
-      this.installDependenceOneByOne(installedDeps, false, force);
+
+      this.installDependenceOneByOne(docs, false, force);
    }
    return docs;
  }
+
  public async removeDb(ids: number[]) {
-    await DependenceModel.nativeDelete({ id: ids });
+    await DependenceModel.destroy({ where: { id: ids } });
  }
+
  public async dependencies(
    {
      searchValue,
@@ -112,19 +109,20 @@ export default class DependenceService {
    query: any = {},
  ): Promise<Dependence[]> {
    let condition = query;
-    const dependenceType =
-      type && DependenceTypes[type] !== undefined
-        ? DependenceTypes[type]
-        : undefined;
-    await this.refreshInstalledStatuses(dependenceType);
-    if (type && DependenceTypes[type] !== undefined) {
+    if (DependenceTypes[type]) {
      condition.type = DependenceTypes[type];
    }
    if (status) {
      condition.status = status.split(',').map(Number);
    }
    if (searchValue) {
-      Object.assign(condition, textSearch(['name'], searchValue));
+      const encodeText = encodeURI(searchValue);
+      condition.name = {
+        [Op.or]: [
+          { [Op.like]: `%${searchValue}%` },
+          { [Op.like]: `%${encodeText}%` },
+        ],
+      };
    }
    try {
      return await this.find(condition, sort);
@@ -132,73 +130,7 @@ export default class DependenceService {
      throw error;
    }
  }
-  private async refreshInstalledStatuses(type?: DependenceTypes) {
-    const cacheDependenceTypes = [
-      DependenceTypes.nodejs,
-      DependenceTypes.python3,
-    ];
-    if (type !== undefined && !cacheDependenceTypes.includes(type)) {
-      return;
-    }
-    const docs = await DependenceModel.find(
-      {
-        status: DependenceStatus.installed,
-        type: type === undefined ? { ['$in']: cacheDependenceTypes } : type,
-      },
-      {},
-    );
-    const checks = await concurrentRun(
-      docs
-        .filter(
-          (doc) =>
-            doc.type !== DependenceTypes.python3 ||
-            !isPythonSourceDependency(doc.name),
-        )
-        .map((doc) => async () => {
-          return (await this.isDependenceInstalled(doc)) ? undefined : doc.id;
-        }),
-      5,
-    );
-    const missingIds = (checks || []).filter(
-      (id): id is number => id !== undefined,
-    );
-    if (missingIds.length) {
-      await DependenceModel.nativeUpdate(
-        { id: missingIds },
-        { status: DependenceStatus.installFailed },
-      );
-    }
-  }
-  private async isDependenceInstalled(dependency: Dependence) {
-    let depName = dependency.name.trim();
-    const depVersionStr = versionDependenceCommandTypes[dependency.type];
-    let depVersion = '';
-    if (
-      dependency.type !== DependenceTypes.python3 &&
-      depName.includes(depVersionStr)
-    ) {
-      const symbolRegx = new RegExp(
-        `(.*)${depVersionStr}([0-9\\.\\-\\+a-zA-Z]*)`,
-      );
-      const [, parsedName, parsedVersion] = depName.match(symbolRegx) || [];
-      if (parsedVersion && parsedName) {
-        depName = parsedName;
-        depVersion = parsedVersion;
-      }
-    }
-    const depInfo = (
-      await promiseExecSuccess(getGetCommand(dependency.type, depName))
-    )
-      .replace(/\s{2,}/, ' ')
-      .replace(/\s+$/, '');
-    const nameMatches =
-      (dependency.type === DependenceTypes.nodejs &&
-        depInfo.split(' ')?.[0] === depName) ||
-      dependency.type === DependenceTypes.python3;
-    return Boolean(
-      depInfo && nameMatches && (!depVersion || depInfo.includes(depVersion)),
-    );
-  }
+
  public installDependenceOneByOne(
    docs: Dependence[],
    isInstall: boolean = true,
@@ -207,27 +139,32 @@ export default class DependenceService {
    docs.forEach((dep) => {
      this.installOrUninstallDependency(dep, isInstall, force);
    });
+
    return taskLimit.waitDependencyQueueDone();
  }
+
  public async reInstall(ids: number[]): Promise<Dependence[]> {
-    await DependenceModel.nativeUpdate(
-      { id: ids },
+    await DependenceModel.update(
      { status: DependenceStatus.queued, log: [] },
+      { where: { id: ids } },
    );
-    const docs = await DependenceModel.find({ id: ids }, {});
+
+    const docs = await DependenceModel.findAll({ where: { id: ids } });
    for (const doc of docs) {
      taskLimit.removeQueuedDependency(doc);
    }
    this.installDependenceOneByOne(docs, true, true);
    return docs;
  }
+
  public async cancel(ids: number[]) {
-    const docs = await DependenceModel.find({ id: ids }, {});
+    const docs = await DependenceModel.findAll({ where: { id: ids } });
    for (const doc of docs) {
      taskLimit.removeQueuedDependency(doc);
      let depInstallCommand = getInstallCommand(doc.type, doc.name);
      let depUnInstallCommand = getUninstallCommand(doc.type, doc.name);
      const isLinuxDependence = doc.type === DependenceTypes.linux;
+
      if (isLinuxDependence) {
        const osType = await detectOS();
        if (!osType) {
@@ -245,70 +182,57 @@ export default class DependenceService {
        pid && (await killTask(pid));
      }
    }
-    await DependenceModel.nativeUpdate(
-      { id: ids },
+    await DependenceModel.update(
      { status: DependenceStatus.cancelled },
+      { where: { id: ids } },
    );
  }
+
  private async find(query: any, sort: any = []): Promise<Dependence[]> {
-    const docs = await DependenceModel.find(
-      { ...query },
-      {
-        orderBy: orderBy([...sort, ['createdAt', 'DESC']]),
-      },
-    );
+    const docs = await DependenceModel.findAll({
+      where: { ...query },
+      order: [...sort, ['createdAt', 'DESC']],
+    });
    return docs;
  }
-  public async getDb(query: QuerySpec['where']): Promise<Dependence> {
-    const doc: any = await DependenceModel.findOne({ ...query }, {});
+
+  public async getDb(
+    query: FindOptions<Dependence>['where'],
+  ): Promise<Dependence> {
+    const doc: any = await DependenceModel.findOne({ where: { ...query } });
    if (!doc) {
      throw new Error(`Dependency ${JSON.stringify(query)} not found`);
    }
-    return doc;
+    return doc.get({ plain: true });
  }
+
  private async updateLog(ids: number[], log: string): Promise<void> {
    taskLimit.updateDepLog(async () => {
-      const docs = await DependenceModel.find({ id: ids }, {});
+      const docs = await DependenceModel.findAll({ where: { id: ids } });
      for (const doc of docs) {
        const newLog = doc?.log ? [...doc.log, log] : [log];
-        await DependenceModel.nativeUpdate({ id: doc.id }, { log: newLog });
+        await DependenceModel.update(
+          { log: newLog },
+          { where: { id: doc.id } },
+        );
      }
      return null;
    });
  }
+
  public installOrUninstallDependency(
    dependency: Dependence,
    isInstall: boolean = true,
    force: boolean = false,
  ) {
    return taskLimit.runDependeny(dependency, () => {
-      let validatedCommand: string;
-      try {
-        validatedCommand = isInstall
-          ? getInstallCommand(dependency.type, dependency.name.trim())
-          : getUninstallCommand(dependency.type, dependency.name.trim());
-      } catch (error) {
-        taskLimit.removeQueuedDependency(dependency);
-        if (!isInstall && force) {
-          return this.removeDb([dependency.id!]).then(() => null);
-        }
-        return DependenceModel.nativeUpdate(
-          { id: dependency.id },
-          {
-            status: isInstall
-              ? DependenceStatus.installFailed
-              : DependenceStatus.removeFailed,
-            log: [String(error)],
-          },
-        ).then(() => null);
-      }
      return new Promise(async (resolve) => {
        if (taskLimit.firstDependencyId !== dependency.id) {
          return resolve(null);
        }
        const depIds = [dependency.id!];
        let depName = dependency.name.trim();
-        const actionText = isInstall ? t('安装') : t('删除');
+        const actionText = isInstall ? '安装' : '删除';
        const socketMessageType = isInstall
          ? 'installDependence'
          : 'uninstallDependence';
@@ -320,70 +244,62 @@ export default class DependenceService {
        taskLimit.removeQueuedDependency(dependency);
        if (isLinuxDependence) {
          if (!osType) {
-            await DependenceModel.nativeUpdate(
-              { id: depIds },
+            await DependenceModel.update(
              { status: DependenceStatus.installFailed },
+              { where: { id: depIds } },
            );
            const startTime = dayjs();
-            const message = tf(
-              '开始%s依赖 %s，开始时间 %s\n\n当前系统不支持\n\n依赖%s失败，结束时间 %s，耗时 %s 秒',
-              actionText,
-              depName,
-              startTime.format('YYYY-MM-DD HH:mm:ss'),
-              actionText,
-              startTime.format('YYYY-MM-DD HH:mm:ss'),
-              String(startTime.diff(startTime, 'second')),
-            );
+            const message = `开始${actionText}依赖 ${depName}，开始时间 ${startTime.format(
+              'YYYY-MM-DD HH:mm:ss',
+            )}\n\n当前系统不支持\n\n依赖${actionText}失败，结束时间 ${startTime.format(
+              'YYYY-MM-DD HH:mm:ss',
+            )}，耗时 ${startTime.diff(startTime, 'second')} 秒`;
            this.sockService.sendMessage({
              type: socketMessageType,
              message,
              references: depIds,
-              status: DependenceStatus.installFailed,
            });
            this.updateLog(depIds, message);
            return resolve(null);
          }
          linuxCommand = LINUX_DEPENDENCE_COMMAND[osType];
        }
+
        const status = isInstall
          ? DependenceStatus.installing
          : DependenceStatus.removing;
-        await DependenceModel.nativeUpdate({ id: depIds }, { status });
-        let command = validatedCommand;
+        await DependenceModel.update({ status }, { where: { id: depIds } });
+
+        let command = isInstall
+          ? getInstallCommand(dependency.type, depName)
+          : getUninstallCommand(dependency.type, depName);
        if (isLinuxDependence) {
          command = isInstall
            ? `${linuxCommand.install} ${depName.trim()}`
            : `${linuxCommand.uninstall} ${depName.trim()}`;
        }
        const startTime = dayjs();
-        const message = tf(
-          '开始%s依赖 %s，开始时间 %s\n\n',
-          actionText,
-          depName,
-          startTime.format('YYYY-MM-DD HH:mm:ss'),
-        );
+
+        const message = `开始${actionText}依赖 ${depName}，开始时间 ${startTime.format(
+          'YYYY-MM-DD HH:mm:ss',
+        )}\n\n`;
        this.sockService.sendMessage({
          type: socketMessageType,
          message,
          references: depIds,
-          status,
        });
        this.updateLog(depIds, message);
+
        // 判断是否已经安装过依赖
-        // pip must resolve optional dependencies even if the base distribution
-        // is already present; its version alone cannot prove extras are ready.
-        if (
-          isInstall &&
-          !force &&
-          !(isPythonDependence && depName.includes('['))
-        ) {
+        if (isInstall && !force) {
          let getCommand = getGetCommand(dependency.type, depName);
          const depVersionStr = versionDependenceCommandTypes[dependency.type];
          if (isLinuxDependence) {
            getCommand = `${linuxCommand.info} ${depName}`;
          }
+
          let depVersion = '';
-          if (!isPythonDependence && depName.includes(depVersionStr)) {
+          if (depName.includes(depVersionStr)) {
            const symbolRegx = new RegExp(
              `(.*)${depVersionStr}([0-9\\.\\-\\+a-zA-Z]*)`,
            );
@@ -396,6 +312,7 @@ export default class DependenceService {
          const depInfo = (await promiseExecSuccess(getCommand))
            .replace(/\s{2,}/, ' ')
            .replace(/\s+$/, '');
+
          if (
            depInfo &&
            ((isNodeDependence && depInfo.split(' ')?.[0] === depName) ||
@@ -405,24 +322,18 @@ export default class DependenceService {
            (!depVersion || depInfo.includes(depVersion))
          ) {
            const endTime = dayjs();
-            const _message = tf(
-              '检测到已经安装 %s\n\n%s\n\n跳过安装\n\n依赖%s成功，结束时间 %s，耗时 %s 秒',
-              depName,
-              depInfo,
-              actionText,
-              endTime.format('YYYY-MM-DD HH:mm:ss'),
-              String(endTime.diff(startTime, 'second')),
-            );
+            const _message = `检测到已经安装 ${depName}\n\n${depInfo}\n\n跳过安装\n\n依赖${actionText}成功，结束时间 ${endTime.format(
+              'YYYY-MM-DD HH:mm:ss',
+            )}，耗时 ${endTime.diff(startTime, 'second')} 秒`;
            this.sockService.sendMessage({
              type: socketMessageType,
              message: _message,
              references: depIds,
-              status: DependenceStatus.installed,
            });
            this.updateLog(depIds, _message);
-            await DependenceModel.nativeUpdate(
-              { id: depIds },
+            await DependenceModel.update(
              { status: DependenceStatus.installed },
+              { where: { id: depIds } },
            );
            return resolve(null);
          }
@@ -436,74 +347,76 @@ export default class DependenceService {
        const cp = spawn(`${proxyStr} ${command}`, {
          shell: '/bin/bash',
        });
+
        cp.stdout.on('data', async (data) => {
          this.sockService.sendMessage({
            type: socketMessageType,
            message: data.toString(),
            references: depIds,
-            status,
          });
          this.updateLog(depIds, data.toString());
        });
+
        cp.stderr.on('data', async (data) => {
          this.sockService.sendMessage({
            type: socketMessageType,
            message: data.toString(),
            references: depIds,
-            status,
          });
          this.updateLog(depIds, data.toString());
        });
+
        cp.on('error', async (err) => {
          this.sockService.sendMessage({
            type: socketMessageType,
            message: JSON.stringify(err),
            references: depIds,
-            status,
          });
          this.updateLog(depIds, JSON.stringify(err));
        });
+
        cp.on('exit', async (code) => {
          const endTime = dayjs();
          const isSucceed = code === 0;
-          const resultText = isSucceed ? t('成功') : t('失败');
-          const message =
-            '\n' +
-            tf(
-              '依赖%s%s，结束时间 %s，耗时 %s 秒',
-              actionText,
-              resultText,
-              endTime.format('YYYY-MM-DD HH:mm:ss'),
-              String(endTime.diff(startTime, 'second')),
-            );
-          const exitStatus = isSucceed
-            ? isInstall
-              ? DependenceStatus.installed
-              : DependenceStatus.removed
-            : isInstall
-            ? DependenceStatus.installFailed
-            : DependenceStatus.removeFailed;
+          const resultText = isSucceed ? '成功' : '失败';
+
+          const message = `\n依赖${actionText}${resultText}，结束时间 ${endTime.format(
+            'YYYY-MM-DD HH:mm:ss',
+          )}，耗时 ${endTime.diff(startTime, 'second')} 秒`;
          this.sockService.sendMessage({
            type: socketMessageType,
            message,
            references: depIds,
-            status: exitStatus,
          });
          this.updateLog(depIds, message);
-          const docs = await DependenceModel.find({ id: depIds }, {});
+
+          let status: number;
+          if (isSucceed) {
+            status = isInstall
+              ? DependenceStatus.installed
+              : DependenceStatus.removed;
+          } else {
+            status = isInstall
+              ? DependenceStatus.installFailed
+              : DependenceStatus.removeFailed;
+          }
+          const docs = await DependenceModel.findAll({ where: { id: depIds } });
          const _docIds = docs
            .filter((x) => x.status !== DependenceStatus.cancelled)
            .map((x) => x.id!);
+
          if (_docIds.length > 0) {
-            await DependenceModel.nativeUpdate(
-              { id: _docIds },
-              { status: exitStatus },
+            await DependenceModel.update(
+              { status },
+              { where: { id: _docIds } },
            );
          }
+
          // 如果删除依赖成功或者强制删除
          if ((isSucceed || force) && !isInstall) {
            this.removeDb(depIds);
          }
+
          resolve(null);
        });
      });
@@ -1,6 +1,5 @@
-import { textSearch } from '../data/queries';
-import { Query, QuerySpec, orderBy } from '../data/queries';
 import groupBy from 'lodash/groupBy';
+import { FindOptions, Op } from 'sequelize';
 import { Inject, Service } from 'typedi';
 import winston from 'winston';
 import config from '../config';
@@ -14,13 +13,11 @@ import {
  stepPosition,
 } from '../data/env';
 import { writeFileWithLock } from '../shared/utils';
-import { database } from '../data';
+
@Service()
 export default class EnvService {
-  constructor(
-    @Inject('logger')
-    private logger: winston.Logger,
-  ) {}
+  constructor(@Inject('logger') private logger: winston.Logger) {}
+
  public async create(payloads: Env[]): Promise<Env[]> {
    const envs = await this.envs();
    let position = initPosition;
@@ -29,7 +26,7 @@ export default class EnvService {
      envs.length > 0 &&
      typeof envs[envs.length - 1].position === 'number'
    ) {
-      position = this.getPrecisionPosition(envs[envs.length - 1].position!);
+      position = envs[envs.length - 1].position!;
    }
    const tabs = payloads.map((x) => {
      position = position - stepPosition;
@@ -41,14 +38,16 @@ export default class EnvService {
    await this.checkPosition(tabs[tabs.length - 1].position!);
    return docs;
  }
+
  public async insert(payloads: Env[]): Promise<Env[]> {
    const result: Env[] = [];
    for (const env of payloads) {
-      const doc = await EnvModel.insert(env);
+      const doc = await EnvModel.create(env, { returning: true });
      result.push(doc);
    }
    return result;
  }
+
  public async update(payload: Env): Promise<Env> {
    const doc = await this.getDb({ id: payload.id });
    const tab = new Env({ ...doc, ...payload });
@@ -56,14 +55,17 @@ export default class EnvService {
    await this.set_envs();
    return newDoc;
  }
+
  private async updateDb(payload: Env): Promise<Env> {
-    await EnvModel.nativeUpdate({ id: payload.id }, { ...payload });
+    await EnvModel.update({ ...payload }, { where: { id: payload.id } });
    return await this.getDb({ id: payload.id });
  }
+
  public async remove(ids: number[]) {
-    await EnvModel.nativeDelete({ id: ids });
+    await EnvModel.destroy({ where: { id: ids } });
    await this.set_envs();
  }
+
  public async move(
    id: number,
    {
@@ -86,15 +88,18 @@ export default class EnvService {
        ? (envs[toIndex].position! + envs[toIndex - 1].position!) / 2
        : (envs[toIndex].position! + envs[toIndex + 1].position!) / 2;
    }
+
    const newDoc = await this.update({
      id,
      position: this.getPrecisionPosition(targetPosition),
    });
+
    await this.checkPosition(targetPosition, envs[toIndex].position!);
    return newDoc;
  }
+
  private async checkPosition(position: number, edge: number = 0) {
-    const precisionPosition = this.getPrecisionPosition(position);
+    const precisionPosition = parseFloat(position.toPrecision(16));
    if (
      precisionPosition < minPosition ||
      precisionPosition > maxPosition ||
@@ -108,15 +113,35 @@ export default class EnvService {
      }
    }
  }
+
  private getPrecisionPosition(position: number): number {
-    return Math.trunc(parseFloat(position.toPrecision(16)));
+    return parseFloat(position.toPrecision(16));
  }
+
  public async envs(searchText: string = '', query: any = {}): Promise<Env[]> {
    let condition = { ...query };
    if (searchText) {
+      const encodeText = encodeURI(searchText);
+      const reg = {
+        [Op.or]: [
+          { [Op.like]: `%${searchText}%` },
+          { [Op.like]: `%${encodeText}%` },
+        ],
+      };
+
      condition = {
        ...condition,
-        ...textSearch(['name', 'value', 'remarks'], searchText),
+        [Op.or]: [
+          {
+            name: reg,
+          },
+          {
+            value: reg,
+          },
+          {
+            remarks: reg,
+          },
+        ],
      };
    }
    try {
@@ -130,73 +155,52 @@ export default class EnvService {
      throw error;
    }
  }
+
  private async find(query: any, sort: any = []): Promise<Env[]> {
-    const docs = await EnvModel.find(
-      { ...query },
-      {
-        orderBy: orderBy([...sort]),
-      },
-    );
-    return docs.map((x) => x);
+    const docs = await EnvModel.findAll({
+      where: { ...query },
+      order: [...sort],
+    });
+    return docs.map((x) => x.get({ plain: true }));
  }
-  public async getDb(query: QuerySpec['where']): Promise<Env> {
-    const doc: any = await EnvModel.findOne({ ...query }, {});
+
+  public async getDb(query: FindOptions<Env>['where']): Promise<Env> {
+    const doc: any = await EnvModel.findOne({ where: { ...query } });
    if (!doc) {
      throw new Error(`Env ${JSON.stringify(query)} not found`);
    }
-    return doc;
+    return doc.get({ plain: true });
  }
+
  public async disabled(ids: number[]) {
-    await EnvModel.nativeUpdate({ id: ids }, { status: EnvStatus.disabled });
+    await EnvModel.update(
+      { status: EnvStatus.disabled },
+      { where: { id: ids } },
+    );
    await this.set_envs();
  }
+
  public async enabled(ids: number[]) {
-    await EnvModel.nativeUpdate({ id: ids }, { status: EnvStatus.normal });
+    await EnvModel.update({ status: EnvStatus.normal }, { where: { id: ids } });
    await this.set_envs();
  }
+
  public async updateNames({ ids, name }: { ids: number[]; name: string }) {
-    await EnvModel.nativeUpdate({ id: ids }, { name });
+    await EnvModel.update({ name }, { where: { id: ids } });
    await this.set_envs();
  }
+
  public async pin(ids: number[]) {
-    await EnvModel.nativeUpdate({ id: ids }, { isPinned: 1 });
+    await EnvModel.update({ isPinned: 1 }, { where: { id: ids } });
  }
+
  public async unPin(ids: number[]) {
-    await EnvModel.nativeUpdate({ id: ids }, { isPinned: 0 });
-  }
-  public async addLabels(ids: number[], labels: string[]) {
-    await database.transaction(async () => {
-      const docs = await EnvModel.find({ id: ids }, {});
-      for (const doc of docs) {
-        const env = doc;
-        await EnvModel.nativeUpdate(
-          { id: env.id },
-          { labels: Array.from(new Set([...(env.labels || []), ...labels])) },
-        );
-      }
-    });
-    return await this.find({ id: ids });
-  }
-  public async removeLabels(ids: number[], labels: string[]) {
-    await database.transaction(async () => {
-      const docs = await EnvModel.find({ id: ids }, {});
-      for (const doc of docs) {
-        const env = doc;
-        await EnvModel.nativeUpdate(
-          { id: env.id },
-          {
-            labels: (env.labels || []).filter(
-              (label: string) => !labels.includes(label),
-            ),
-          },
-        );
-      }
-    });
-    return await this.find({ id: ids });
+    await EnvModel.update({ isPinned: 0 }, { where: { id: ids } });
  }
+
  public async set_envs() {
    const envs = await this.envs('', {
-      name: { ['$ne']: null },
+      name: { [Op.not]: null },
      status: EnvStatus.normal,
    });
    const groups = groupBy(envs, 'name');
@@ -206,6 +210,7 @@ export default class EnvService {
    for (const key in groups) {
      if (Object.prototype.hasOwnProperty.call(groups, key)) {
        const group = groups[key];
+
        // 忽略不符合bash要求的环境变量名称
        if (/^[a-zA-Z_][0-9a-zA-Z_]*$/.test(key)) {
          let value = group
@@ -218,9 +223,10 @@ export default class EnvService {
            .map((x) => x.value)
            .join('&')
            .replace(/\\/g, '\\\\')}`;
-          js_env_string += `process.env[${JSON.stringify(
-            key,
-          )}]=${JSON.stringify(group.map((x) => x.value).join('&'))};\n`;
+          js_env_string += `process.env.${key}=\`${_env_value.replace(
+            /\`/g,
+            '\\`',
+          )}\`;\n`;
          py_env_string += `os.environ['${key}']='''${_env_value.replace(
            /\'/g,
            "\\'",
@@ -4,7 +4,6 @@ import { HealthService } from '../protos/health';
 import { ApiService } from '../protos/api';
 import { addCron } from '../schedule/addCron';
 import { delCron } from '../schedule/delCron';
-import { setConcurrency } from '../schedule/setConcurrency';
 import { check } from '../schedule/health';
 import * as Api from '../schedule/api';
 import Logger from '../loaders/logger';
@@ -12,59 +11,30 @@ import { promisify } from 'util';
 import config from '../config';
 import { metricsService } from './metrics';
 import { Service } from 'typedi';
-import { initGrpcCerts } from '../config/grpcCerts';

@Service()
 export class GrpcServerService {
  private server: Server = new Server({ 'grpc.enable_http_proxy': 0 });

-  private formatGrpcAddress(host: string, port: number): string {
-    if (host === '::') {
-      return `[::]:${port}`;
-    }
-    return `${host}:${port}`;
-  }
-
  async initialize() {
    try {
      this.server.addService(HealthService, { check });
-      this.server.addService(CronService, { addCron, delCron, setConcurrency });
+      this.server.addService(CronService, { addCron, delCron });
      this.server.addService(ApiService, Api);

-      const tlsConfig = await initGrpcCerts();
-      const credentials = ServerCredentials.createSsl(
-        Buffer.from(tlsConfig.caCert),
-        [{ cert_chain: Buffer.from(tlsConfig.serverCert), private_key: Buffer.from(tlsConfig.serverKey) }],
-        true,
-      );
-
      const grpcPort = config.grpcPort;
-      const hostsToTry = [
-        config.bindHostGrpc,
-        ...(config.bindHostGrpc === '::' ? ['0.0.0.0'] : [])
-      ];
      const bindAsync = promisify(this.server.bindAsync).bind(this.server);
+      await bindAsync(
+        `0.0.0.0:${grpcPort}`,
+        ServerCredentials.createInsecure(),
+      );
+      Logger.debug(`✌️ gRPC service started successfully`);

-      let lastError: Error | null = null;
+      metricsService.record('grpc_service_start', 1, {
+        port: grpcPort.toString(),
+      });

-      for (const host of hostsToTry) {
-        try {
-          const address = this.formatGrpcAddress(host, grpcPort);
-          const boundPort = await bindAsync(address, credentials);
-          Logger.debug(`[boot] gRPC service started successfully on ${address}`);
-          metricsService.record('grpc_service_start', 1, {
-            port: grpcPort.toString(),
-            host
-          });
-          return boundPort;
-        } catch (err) {
-          lastError = err as Error;
-          Logger.warn(`Failed to bind gRPC on ${host}:${grpcPort}, trying next...`, err);
-        }
-      }
-
-      Logger.error('Failed to start gRPC service on all hosts');
-      throw lastError || new Error('Failed to start gRPC service');
+      return grpcPort;
    } catch (err) {
      Logger.error('Failed to start gRPC service:', err);
      throw err;
@@ -1,17 +1,13 @@
-import { database } from '../data';
 import { Service } from 'typedi';
 import Logger from '../loaders/logger';
-import cronClient from '../schedule/client';
+import { GrpcServerService } from './grpc';
 import { HttpServerService } from './http';
-import { runtimeBuild } from '../shared/runtimeBuild';

 interface HealthStatus {
-  build: typeof runtimeBuild;
  status: 'ok' | 'error';
  services: {
    http: boolean;
    grpc: boolean;
-    database: boolean;
  };
  metrics: {
    uptime: number;
@@ -26,16 +22,17 @@ interface HealthStatus {
 export class HealthService {
  private startTime = Date.now();

-  constructor(private httpServerService: HttpServerService) {}
+  constructor(
+    private grpcServerService: GrpcServerService,
+    private httpServerService: HttpServerService,
+  ) {}

  async check(): Promise<HealthStatus> {
    const status: HealthStatus = {
-      build: runtimeBuild,
      status: 'ok',
      services: {
        http: true,
        grpc: true,
-        database: database.healthy,
      },
      metrics: {
        uptime: Math.floor((Date.now() - this.startTime) / 1000),
@@ -59,7 +56,8 @@ export class HealthService {
    }

    try {
-      if (!(await cronClient.readiness.check())) {
+      const grpcServer = this.grpcServerService.getServer();
+      if (!grpcServer) {
        status.services.grpc = false;
        status.status = 'error';
      }
@@ -69,7 +67,6 @@ export class HealthService {
      Logger.error('gRPC server check failed:', err);
    }

-    if (!status.services.database) status.status = 'error';
    return status;
  }
 }
@@ -3,57 +3,31 @@ import Logger from '../loaders/logger';
 import { metricsService } from './metrics';
 import { Service } from 'typedi';
 import { Server } from 'http';
-import config from '../config';

@Service()
 export class HttpServerService {
  private server?: Server = undefined;

  async initialize(expressApp: express.Application, port: number) {
-    const hostsToTry = [
-      config.bindHost,
-      ...(config.bindHost === '::' ? ['0.0.0.0'] : [])
-    ];
-
-    let lastError: Error | null = null;
-
-    for (const host of hostsToTry) {
-      try {
-        const server = await this.tryListen(expressApp, port, host);
-        Logger.debug(`[boot] HTTP service started successfully on ${host}:${port}`);
-        metricsService.record('http_service_start', 1, {
-          port: port.toString(),
-          host
+    try {
+      return new Promise((resolve, reject) => {
+        this.server = expressApp.listen(port, '0.0.0.0', () => {
+          Logger.debug(`✌️ HTTP service started successfully`);
+          metricsService.record('http_service_start', 1, {
+            port: port.toString(),
+          });
+          resolve(this.server);
        });
-        this.server = server;
-        return server;
-      } catch (err) {
-        lastError = err as Error;
-        Logger.warn(`Failed to bind HTTP on ${host}:${port}, trying next...`, err);
-      }
+
+        this.server?.on('error', (err: Error) => {
+          Logger.error('Failed to start HTTP service:', err);
+          reject(err);
+        });
+      });
+    } catch (err) {
+      Logger.error('Failed to start HTTP service:', err);
+      throw err;
    }
-
-    Logger.error('Failed to start HTTP service on all hosts');
-    throw lastError || new Error('Failed to start HTTP service');
-  }
-
-  private async tryListen(expressApp: express.Application, port: number, host: string): Promise<Server> {
-    return new Promise((resolve, reject) => {
-      // There is one HTTP worker; accepting here avoids primary IPC handoff
-      // for every connection. Restore shared listening for custom clusters.
-      const server = expressApp.listen({
-        port,
-        host,
-        exclusive: process.env.QL_HTTP_SHARED_LISTEN !== 'true',
-      }, () => {
-        resolve(server);
-      });
-
-      server.on('error', (err: Error) => {
-        server.close();
-        reject(err);
-      });
-    });
  }

  async shutdown() {
@@ -1,4 +1,4 @@
-import { resolveFileAccess } from '../shared/fileAccess';
+import path from 'path';
 import { Inject, Service } from 'typedi';
 import winston from 'winston';
 import config from '../config';
@@ -8,6 +8,7 @@ export default class LogService {
  constructor(@Inject('logger') private logger: winston.Logger) {}

  public checkFilePath(filePath: string, fileName: string) {
-    return resolveFileAccess(config.logPath, [filePath || '', fileName]);
+    const finalPath = path.resolve(config.logPath, filePath, fileName);
+    return finalPath.startsWith(config.logPath) ? finalPath : '';
  }
 }
@@ -1,4 +1,3 @@
-import { t } from '../shared/i18n';
 import { performance } from 'perf_hooks';
 import Logger from '../loaders/logger';

@@ -9,19 +8,16 @@ interface Metric {
  tags?: Record<string, string>;
 }

-export const MAX_METRIC_SAMPLES = 1000;
-const METRIC_RETENTION_MS = 60 * 60 * 1000;
-
-export class MetricsService {
-  private metrics: Array<Metric | undefined> = new Array(MAX_METRIC_SAMPLES);
-  private metricCount = 0;
-  private nextMetricIndex = 0;
+class MetricsService {
+  private metrics: Metric[] = [];
  private static instance: MetricsService;

  private constructor() {
    // 定期清理旧数据
-    const cleanupTimer = setInterval(() => this.removeExpiredMetrics(), 60000);
-    cleanupTimer.unref();
+    setInterval(() => {
+      const oneHourAgo = Date.now() - 3600000;
+      this.metrics = this.metrics.filter(m => m.timestamp > oneHourAgo);
+    }, 60000);
  }

  static getInstance(): MetricsService {
@@ -32,14 +28,12 @@ export class MetricsService {
  }

  record(name: string, value: number, tags?: Record<string, string>) {
-    this.metrics[this.nextMetricIndex] = {
+    this.metrics.push({
      name,
      value,
      timestamp: Date.now(),
      tags,
-    };
-    this.nextMetricIndex = (this.nextMetricIndex + 1) % MAX_METRIC_SAMPLES;
-    this.metricCount = Math.min(this.metricCount + 1, MAX_METRIC_SAMPLES);
+    });
  }

  measure(name: string, fn: () => void, tags?: Record<string, string>) {
@@ -52,11 +46,7 @@ export class MetricsService {
    }
  }

-  async measureAsync(
-    name: string,
-    fn: () => Promise<void>,
-    tags?: Record<string, string>,
-  ) {
+  async measureAsync(name: string, fn: () => Promise<void>, tags?: Record<string, string>) {
    const start = performance.now();
    try {
      await fn();
@@ -67,69 +57,36 @@ export class MetricsService {
  }

  getMetrics(name?: string, tags?: Record<string, string>) {
-    this.removeExpiredMetrics();
-    let filtered = this.getMetricSnapshot();
-
+    let filtered = this.metrics;
+    
    if (name) {
-      filtered = filtered.filter((m) => m.name === name);
+      filtered = filtered.filter(m => m.name === name);
    }
-
+    
    if (tags) {
-      filtered = filtered.filter((m) => {
+      filtered = filtered.filter(m => {
        if (!m.tags) return false;
-        return Object.entries(tags).every(
-          ([key, value]) => m.tags![key] === value,
-        );
+        return Object.entries(tags).every(([key, value]) => m.tags![key] === value);
      });
    }

-    const values = filtered.map((metric) => metric.value);
    return {
      count: filtered.length,
-      average: values.length
-        ? values.reduce((acc, value) => acc + value, 0) / values.length
-        : 0,
-      min: values.length ? Math.min(...values) : 0,
-      max: values.length ? Math.max(...values) : 0,
+      average: filtered.reduce((acc, curr) => acc + curr.value, 0) / filtered.length,
+      min: Math.min(...filtered.map(m => m.value)),
+      max: Math.max(...filtered.map(m => m.value)),
      metrics: filtered,
    };
  }

-  private getMetricSnapshot(): Metric[] {
-    if (this.metricCount < MAX_METRIC_SAMPLES) {
-      return this.metrics.slice(0, this.metricCount) as Metric[];
-    }
-    return [
-      ...this.metrics.slice(this.nextMetricIndex),
-      ...this.metrics.slice(0, this.nextMetricIndex),
-    ] as Metric[];
-  }
-
-  private removeExpiredMetrics() {
-    const oldestTimestamp = Date.now() - METRIC_RETENTION_MS;
-    const retained = this.getMetricSnapshot().filter(
-      (metric) => metric.timestamp > oldestTimestamp,
-    );
-    if (retained.length === this.metricCount) return;
-
-    this.metrics = new Array(MAX_METRIC_SAMPLES);
-    this.metricCount = 0;
-    this.nextMetricIndex = 0;
-    for (const metric of retained) {
-      this.metrics[this.nextMetricIndex] = metric;
-      this.nextMetricIndex = (this.nextMetricIndex + 1) % MAX_METRIC_SAMPLES;
-      this.metricCount++;
-    }
-  }
-
  report() {
    const report = {
      timestamp: Date.now(),
      metrics: this.getMetrics(),
    };
-    Logger.info(t('性能指标报告:'), report);
+    Logger.info('性能指标报告:', report);
    return report;
  }
 }

-export const metricsService = MetricsService.getInstance();
+export const metricsService = MetricsService.getInstance(); 
@@ -1,10 +1,8 @@
-import { persistNotificationAudit } from '../shared/notificationAudit';
 import crypto from 'crypto';
 import nodemailer from 'nodemailer';
 import { Inject, Service } from 'typedi';
 import { parseBody, parseHeaders } from '../config/util';
 import { NotificationInfo } from '../data/notify';
-import { t } from '../shared/i18n';
 import UserService from './user';
 import { httpClient } from '../config/http';
 import { ProxyAgent } from 'undici';
@@ -36,9 +34,6 @@ export default class NotificationService {
    ['chronocat', this.chronocat],
    ['ntfy', this.ntfy],
    ['wxPusherBot', this.wxPusherBot],
-    ['wxPusherSpt', this.wxPusherSpt],
-    ['openiLink', this.openiLink],
-    ['wpush', this.wpush],
  ]);

  private title = '';
@@ -56,33 +51,27 @@ export default class NotificationService {
    content: string,
    notificationInfo?: NotificationInfo,
  ): Promise<boolean | undefined> {
-    let type: string | undefined;
-    let success = false;
-    try {
-      const saved = await this.userService.getNotificationMode();
-      type = notificationInfo?.type || saved.type;
-      if (type) {
-        this.title = title;
-        this.content = content;
-        const { type: _, ...overrides } = notificationInfo || {};
-        const { type: _saved, ...rest } = saved;
-        this.params = { ...rest, ...overrides };
-        try {
-          success = !!(await this.modeMap.get(type)?.call(this));
-        } catch (error) {
-          console.error(error);
-        }
-      }
-      return success;
-    } finally {
-      await persistNotificationAudit({
-        title,
-        content,
-        notifyType: type,
-        source: 'system',
-        status: success ? 0 : 1,
-      });
+    let { type, ...rest } = await this.userService.getNotificationMode();
+    if (notificationInfo?.type) {
+      type = notificationInfo?.type;
    }
+    if (type) {
+      this.title = title;
+      this.content = content;
+      let params = rest;
+      if (notificationInfo) {
+        const { type: _, ...others } = notificationInfo;
+        params = { ...rest, ...others };
+      }
+      this.params = params;
+      const notificationModeAction = this.modeMap.get(type);
+      try {
+        return await notificationModeAction?.call(this);
+      } catch (error: any) {
+        console.error(error);
+      }
+    }
+    return false;
  }

  public async testNotify(
@@ -91,31 +80,14 @@ export default class NotificationService {
    content: string,
  ) {
    const { type, ...rest } = info;
-    if (!type) return true;
-    let success = false;
-    try {
+    if (type) {
      this.title = title;
      this.content = content;
      this.params = rest;
-      success = !!(await this.modeMap.get(type)?.call(this));
-      return success;
-    } finally {
-      await persistNotificationAudit({
-        title,
-        content,
-        notifyType: type,
-        source: 'system',
-        status: success ? 0 : 1,
-      });
+      const notificationModeAction = this.modeMap.get(type);
+      return await notificationModeAction?.call(this);
    }
-  }
-
-  private parseMailRecipients(value?: string) {
-    const recipients = (value || '')
-      .split(/[;；]/)
-      .map((item) => item.trim())
-      .filter(Boolean);
-    return recipients.length > 0 ? recipients : undefined;
+    return true;
  }

  private async gotify() {
@@ -383,7 +355,7 @@ export default class NotificationService {
          {
            title: `${this.title}`,
            thumb_media_id,
-            author: t('智能助手'),
+            author: `智能助手`,
            content_source_url: ``,
            content: `${this.content.replace(/\n/g, '<br/>')}`,
            digest: `${this.content}`,
@@ -399,7 +371,7 @@ export default class NotificationService {
            title: `${this.title}`,
            description: `${this.content}`,
            url: 'https://github.com/whyour/qinglong',
-            btntxt: t('更多'),
+            btntxt: '更多',
          },
        };
        break;
@@ -450,7 +422,7 @@ export default class NotificationService {
          roomName: `${aibotkName}`,
          message: {
            type: 1,
-            content: `【${t('青龙快讯')}】\n\n${this.title}\n${this.content}`,
+            content: `【青龙快讯】\n\n${this.title}\n${this.content}`,
          },
        };
        break;
@@ -461,7 +433,7 @@ export default class NotificationService {
          name: `${aibotkName}`,
          message: {
            type: 1,
-            content: `【${t('青龙快讯')}】\n\n${this.title}\n${this.content}`,
+            content: `【青龙快讯】\n\n${this.title}\n${this.content}`,
          },
        };
        break;
@@ -619,7 +591,6 @@ export default class NotificationService {

  private async email() {
    const { emailPass, emailService, emailUser, emailTo } = this.params;
-    const recipients = this.parseMailRecipients(emailTo) || emailUser;

    try {
      const transporter = nodemailer.createTransport({
@@ -631,8 +602,8 @@ export default class NotificationService {
      });

      const info = await transporter.sendMail({
-        from: `"${t('青龙快讯')}" <${emailUser}>`,
-        to: recipients,
+        from: `"青龙快讯" <${emailUser}>`,
+        to: emailTo ? emailTo.split(';') : emailUser,
        subject: `${this.title}`,
        html: `${this.content.replace(/\n/g, '<br/>')}`,
      });
@@ -746,7 +717,7 @@ export default class NotificationService {

    // topic_ids 和 uids 至少要有一个
    if (!topicIds.length && !uids.length) {
-      throw new Error(t('wxPusher 服务的 TopicIds 和 Uids 至少配置一个才行'));
+      throw new Error('wxPusher 服务的 TopicIds 和 Uids 至少配置一个才行');
    }

    const url = `https://wxpusher.zjiecode.com/api/send/message`;
@@ -774,52 +745,6 @@ export default class NotificationService {
    }
  }

-  private async wxPusherSpt() {
-    const { wxPusherSptList } = this.params;
-    // 处理 SPT，将逗号分隔的字符串转为数组
-    const spts = wxPusherSptList
-      ? wxPusherSptList
-          .split(',')
-          .map((spt) => spt.trim())
-          .filter((spt) => spt)
-      : [];
-
-    if (!spts.length) {
-      throw new Error(t('wxPusher SPT 不能为空'));
-    }
-    if (spts.length > 10) {
-      throw new Error(t('wxPusher SPT 最多支持 10 个'));
-    }
-
-    const url = `https://wxpusher.zjiecode.com/api/send/message/simple-push`;
-    const json: any = {
-      content: `<h1>${this.title}</h1><br/><div style='white-space: pre-wrap;'>${this.content}</div>`,
-      summary: this.title,
-      contentType: 2,
-    };
-    // 单个 SPT 用 spt，多个用 sptList
-    if (spts.length === 1) {
-      json.spt = spts[0];
-    } else {
-      json.sptList = spts;
-    }
-
-    try {
-      const res = await httpClient.post(url, {
-        ...this.gotOption,
-        json,
-      });
-
-      if (res.code === 1000) {
-        return true;
-      } else {
-        throw new Error(JSON.stringify(res));
-      }
-    } catch (error: any) {
-      throw new Error(error.response ? error.response.body : error);
-    }
-  }
-
  private async chronocat() {
    const { chronocatURL, chronocatQQ, chronocatToken } = this.params;
    try {
@@ -888,7 +813,7 @@ export default class NotificationService {
    } = this.params;

    if (!webhookUrl?.includes('$title') && !webhookBody?.includes('$title')) {
-      throw new Error(t('Url 或者 Body 中必须包含 $title'));
+      throw new Error('Url 或者 Body 中必须包含 $title');
    }

    const headers = parseHeaders(webhookHeaders);
@@ -933,62 +858,4 @@ export default class NotificationService {
    }
    return {};
  }
-
-  private async openiLink() {
-    const { openiLinkAppToken, openiLinkHubUrl, openiLinkContextToken } =
-      this.params;
-    const baseUrl =
-      openiLinkHubUrl?.replace(/\/$/, '') || 'https://hub.openilink.com';
-    const url = `${baseUrl}/bot/v1/message/send`;
-    const body: Record<string, string> = {
-      type: 'text',
-      content: `${this.title}\n\n${this.content}`,
-    };
-    if (openiLinkContextToken) {
-      body.context_token = openiLinkContextToken;
-    }
-    try {
-      const res = await httpClient.post(url, {
-        ...this.gotOption,
-        json: body,
-        headers: {
-          'Content-Type': 'application/json',
-          Authorization: `Bearer ${openiLinkAppToken}`,
-        },
-      });
-      if (res.ok) {
-        return true;
-      } else {
-        throw new Error(JSON.stringify(res));
-      }
-    } catch (error: any) {
-      throw new Error(error.response ? error.response.body : error);
-    }
-  }
-  private async wpush() {
-    const { wpushApiKey, wpushChannel, wpushTopicCode } = this.params;
-    const url = 'https://api.wpush.cn/api/v1/send';
-    const json: Record<string, string> = {
-      apikey: `${wpushApiKey}`,
-      title: `${this.title}`,
-      content: `${this.content}`,
-      channel: `${wpushChannel || 'wechat'}`,
-    };
-    if (wpushTopicCode) {
-      json.topic_code = `${wpushTopicCode}`;
-    }
-    try {
-      const res = await httpClient.post(url, {
-        ...this.gotOption,
-        json,
-      });
-      if (res.code === 0) {
-        return true;
-      } else {
-        throw new Error(JSON.stringify(res));
-      }
-    } catch (error: any) {
-      throw new Error(error.response ? error.response.body : error);
-    }
-  }
 }
@@ -1,81 +1,35 @@
-import { textSearch } from '../data/queries';
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import { createRandomString } from '../config/util';
 import { App, AppModel } from '../data/open';
 import { v4 as uuidV4 } from 'uuid';
+import sequelize, { Op } from 'sequelize';
 import { shareStore } from '../shared/store';
-import { t } from '../shared/i18n';
-import { lock } from 'proper-lockfile';
-import path from 'path';
-import os from 'os';
-import { writeFile, rename, rm, stat, chmod } from 'fs/promises';
-import config from '../config';
+
@Service()
 export default class OpenService {
-  constructor(
-    @Inject('logger')
-    private logger: winston.Logger,
-  ) {}
-  // Every database mutation and full authentication-cache publication shares
-  // this cross-process lock. Lock a separate marker, not token.json itself.
-  private async withAppsLock<T>(operation: () => Promise<T>): Promise<T> {
-    const target = path.join(config.configPath, '.apps-state');
-    const release = await lock(target, {
-      realpath: false,
-      stale: 10000,
-      retries: { retries: 10, factor: 2, minTimeout: 100, maxTimeout: 3000 },
-    });
-    try {
-      return await operation();
-    } finally {
-      await release();
-    }
-  }
-  public async initializeSystemApp(): Promise<void> {
-    await this.withAppsLock(async () => {
-      const doc = await AppModel.findOne({ name: 'system' }, {});
-      const app = doc;
-      if (!app) {
-        await this.insert({
-          name: 'system',
-          scopes: ['crons', 'system', 'dashboard'],
-          client_id: createRandomString(12, 12),
-          client_secret: createRandomString(24, 24),
-        });
-      } else if (!app.scopes.includes('dashboard')) {
-        await AppModel.nativeUpdate(
-          { id: app.id },
-          { scopes: [...app.scopes, 'dashboard'] },
-        );
-      }
-      await shareStore.updateApps(await this.find({}));
-    });
-  }
-  public async refreshApps(): Promise<void> {
-    await this.withAppsLock(async () => {
-      await shareStore.updateApps(await this.find({}));
-    });
-  }
+  constructor(@Inject('logger') private logger: winston.Logger) {}
+
  public async findApps(): Promise<App[] | null> {
    const docs = await this.find({});
    return docs;
  }
+
  public async create(payload: App): Promise<App> {
-    return this.withAppsLock(async () => {
-      const tab = { ...payload };
-      tab.client_id = createRandomString(12, 12);
-      tab.client_secret = createRandomString(24, 24);
-      const doc = await this.insert(tab);
-      const apps = await this.find({});
-      await shareStore.updateApps(apps);
-      return { ...doc, tokens: [] };
-    });
+    const tab = { ...payload };
+    tab.client_id = createRandomString(12, 12);
+    tab.client_secret = createRandomString(24, 24);
+    const doc = await this.insert(tab);
+    const apps = await this.find({});
+    await shareStore.updateApps(apps);
+    return { ...doc, tokens: [] };
  }
-  private async insert(payload: App): Promise<App> {
-    const doc = await AppModel.insert(payload);
-    return doc;
+
+  public async insert(payload: App): Promise<App> {
+    const doc = await AppModel.create(payload, { returning: true });
+    return doc.get({ plain: true });
  }
+
  public async update(payload: App): Promise<App> {
    const newDoc = await this.updateDb({
      name: payload.name,
@@ -84,28 +38,28 @@ export default class OpenService {
    } as App);
    return { ...newDoc, tokens: [] };
  }
+
  private async updateDb(payload: Partial<App>): Promise<App> {
-    return this.withAppsLock(async () => {
-      await AppModel.nativeUpdate({ id: payload.id }, payload);
-      const apps = await this.find({});
-      await shareStore.updateApps(apps);
-      return apps?.find((x) => x.id === payload.id) as App;
-    });
+    await AppModel.update(payload, { where: { id: payload.id } });
+    const apps = await this.find({});
+    await shareStore.updateApps(apps);
+    return apps?.find((x) => x.id === payload.id) as App;
  }
+
  public async getDb(query: Record<string, any>): Promise<App> {
-    const doc = await AppModel.findOne(query, {});
+    const doc = await AppModel.findOne({ where: query });
    if (!doc) {
      throw new Error(`App ${JSON.stringify(query)} not found`);
    }
-    return doc;
+    return doc.get({ plain: true });
  }
+
  public async remove(ids: number[]) {
-    return this.withAppsLock(async () => {
-      await AppModel.nativeDelete({ id: ids });
-      const apps = await this.find({});
-      await shareStore.updateApps(apps);
-    });
+    await AppModel.destroy({ where: { id: ids } });
+    const apps = await this.find({});
+    await shareStore.updateApps(apps);
  }
+
  public async resetSecret(id: number): Promise<App> {
    const tab: Partial<App> = {
      client_secret: createRandomString(24, 24),
@@ -121,6 +75,7 @@ export default class OpenService {
    const newDoc = await this.updateDb(tab);
    return newDoc;
  }
+
  public async list(
    searchText: string = '',
    sort: any = {},
@@ -128,7 +83,18 @@ export default class OpenService {
  ): Promise<App[]> {
    let condition = { ...query };
    if (searchText) {
-      condition = { ...condition, ...textSearch(['name'], searchText) };
+      const encodeText = encodeURI(searchText);
+      const reg = {
+        [Op.or]: [
+          { [Op.like]: `%${searchText}%` },
+          { [Op.like]: `%${encodeText}%` },
+        ],
+      };
+
+      condition = {
+        ...condition,
+        name: reg,
+      };
    }
    try {
      const result = await this.find(condition);
@@ -139,18 +105,13 @@ export default class OpenService {
      throw error;
    }
  }
+
  private async find(query: Record<string, any>, sort?: any): Promise<App[]> {
-    const docs = await AppModel.find({ ...query }, {});
-    return docs.map((x) => x);
+    const docs = await AppModel.findAll({ where: { ...query } });
+    return docs.map((x) => x.get({ plain: true }));
  }
-  public async authToken(credentials: {
-    client_id: string;
-    client_secret: string;
-  }): Promise<any> {
-    return this.withAppsLock(() => this.issueToken(credentials));
-  }
-  // Caller holds withAppsLock through database update and cache publication.
-  private async issueToken({
+
+  public async authToken({
    client_id,
    client_secret,
  }: {
@@ -159,7 +120,7 @@ export default class OpenService {
  }): Promise<any> {
    let token = uuidV4();
    const expiration = Math.round(Date.now() / 1000) + 2592000; // 2592000 30天
-    const doc = await AppModel.findOne({ client_id, client_secret }, {});
+    const doc = await AppModel.findOne({ where: { client_id, client_secret } });
    if (doc) {
      const timestamp = Math.round(Date.now() / 1000);
      const invalidTokens = (doc.tokens || []).filter(
@@ -175,7 +136,10 @@ export default class OpenService {
      } else {
        tokens = [...invalidTokens, { value: token, expiration }];
      }
-      await AppModel.nativeUpdate({ client_id, client_secret }, { tokens });
+      await AppModel.update(
+        { tokens },
+        { where: { client_id, client_secret } },
+      );
      const apps = await this.find({});
      await shareStore.updateApps(apps);
      return {
@@ -187,50 +151,31 @@ export default class OpenService {
        },
      };
    } else {
-      return { code: 400, message: t('client_id 或 client_seret 有误') };
+      return { code: 400, message: 'client_id 或 client_seret 有误' };
    }
  }
-  public async generateSystemToken(renew = false): Promise<{
+
+  public async generateSystemToken(): Promise<{
    value: string;
    expiration: number;
  }> {
-    return this.withAppsLock(async () => {
-      // Read after acquiring the lock; a concurrent issuer may have renewed.
-      const systemApp = await this.getDb({ name: 'system' });
-      const now = Math.round(Date.now() / 1000);
-      let appToken = systemApp.tokens
-        ?.filter((token) => token.expiration > now)
-        .sort((left, right) => right.expiration - left.expiration)[0];
-      if (renew || !appToken) {
-        const { data } = await this.issueToken({
-          client_id: systemApp.client_id,
-          client_secret: systemApp.client_secret,
-        });
-        appToken = { value: data.token, expiration: data.expiration };
-      } else {
-        // Recover a prior database commit whose cache publication failed.
-        await shareStore.updateApps(await this.find({}));
-      }
-      const tokenFile = path.join(config.configPath, 'token.json');
-      const temporaryFile = `${tokenFile}.${process.pid}.tmp`;
-      const mode = await stat(tokenFile).then(
-        (file) => file.mode & 0o777,
-        (error: NodeJS.ErrnoException) => {
-          if (error.code === 'ENOENT') return 0o600;
-          throw error;
-        },
-      );
-      try {
-        await writeFile(temporaryFile, `${JSON.stringify(appToken)}${os.EOL}`, {
-          mode,
-        });
-        await chmod(temporaryFile, mode);
-        // Shell readers see a complete old or new document, never a partial one.
-        await rename(temporaryFile, tokenFile);
-      } finally {
-        await rm(temporaryFile, { force: true });
-      }
-      return appToken;
+    const apps = await shareStore.getApps();
+    const systemApp = apps?.find((x) => x.name === 'system');
+    if (!systemApp) {
+      throw new Error('system app not found');
+    }
+    const now = Math.round(Date.now() / 1000);
+    const currentToken = systemApp.tokens?.find((x) => x.expiration > now);
+    if (currentToken) {
+      return currentToken;
+    }
+    const { data } = await this.authToken({
+      client_id: systemApp.client_id,
+      client_secret: systemApp.client_secret,
    });
+    return {
+      ...data,
+      value: data.token,
+    };
  }
 }
@@ -1,139 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import dayjs from 'dayjs';
-import { Service } from 'typedi';
-import config from '../config';
-import { CrontabStatModel } from '../data/cronStats';
-import { database } from '../data';
-import { InstanceStatus, RunningInstanceModel } from '../data/runningInstance';
-import { AuthDataType, SystemModel } from '../data/system';
-import {
-  DependenceCacheType,
-  getDirectorySize,
-  isDependenceCacheType,
-  normalizeRetentionPolicy,
-  RetentionPolicy,
-} from '../shared/retention';
-export interface StorageCleanupRequest extends RetentionPolicy {
-  dependenceCacheTypes?: DependenceCacheType[];
-  compactDatabase?: boolean;
-}
-function runningInstanceWhere(days: number) {
-  const cutoff = dayjs().subtract(days, 'day').unix();
-  return {
-    status: { ['$ne']: InstanceStatus.running },
-    ['$or']: [
-      { finished_at: { ['$lt']: cutoff } },
-      {
-        finished_at: { ['$eq']: null },
-        started_at: { ['$lt']: cutoff },
-      },
-    ],
-  };
-}
-function cronStatWhere(days: number) {
-  return {
-    date: { ['$lt']: dayjs().subtract(days, 'day').format('YYYY-MM-DD') },
-  };
-}
-@Service()
-export default class RetentionService {
-  public async updatePolicy(policy: Partial<RetentionPolicy>) {
-    const normalized = normalizeRetentionPolicy(policy);
-    const systemConfig = await SystemModel.findOne(
-      { type: AuthDataType.systemConfig },
-      {},
-    );
-    if (!systemConfig) {
-      throw new Error('System config not found');
-    }
-    await SystemModel.nativeUpdate(
-      { id: systemConfig.id },
-      {
-        info: {
-          ...systemConfig.info,
-          ...normalized,
-        },
-      },
-    );
-    return normalized;
-  }
-  public async preview(request: StorageCleanupRequest) {
-    const policy = normalizeRetentionPolicy(request);
-    const dependenceCacheTypes = (request.dependenceCacheTypes || []).filter(
-      isDependenceCacheType,
-    );
-    const [runningInstances, cronStats, dependenceCaches] = await Promise.all([
-      policy.runningInstanceRetentionDays > 0
-        ? RunningInstanceModel.count(
-            runningInstanceWhere(policy.runningInstanceRetentionDays),
-          )
-        : 0,
-      policy.cronStatRetentionDays > 0
-        ? CrontabStatModel.count(cronStatWhere(policy.cronStatRetentionDays))
-        : 0,
-      Promise.all(
-        dependenceCacheTypes.map(async (type) => ({
-          type,
-          bytes: await getDirectorySize(
-            path.join(config.dependenceCachePath, type),
-          ),
-        })),
-      ),
-    ]);
-    return {
-      policy,
-      runningInstances,
-      cronStats,
-      dependenceCaches,
-      dependenceCacheBytes: dependenceCaches.reduce(
-        (total, cache) => total + cache.bytes,
-        0,
-      ),
-      compactDatabase: Boolean(request.compactDatabase),
-    };
-  }
-  public async cleanup(request: StorageCleanupRequest) {
-    const preview = await this.preview(request);
-    const deleted = await database.transaction(async () => {
-      const runningInstances =
-        preview.policy.runningInstanceRetentionDays > 0
-          ? await RunningInstanceModel.nativeDelete(
-              runningInstanceWhere(preview.policy.runningInstanceRetentionDays),
-            )
-          : 0;
-      const cronStats =
-        preview.policy.cronStatRetentionDays > 0
-          ? await CrontabStatModel.nativeDelete(
-              cronStatWhere(preview.policy.cronStatRetentionDays),
-            )
-          : 0;
-      return { runningInstances, cronStats };
-    });
-    const dependenceCaches = [];
-    for (const cache of preview.dependenceCaches) {
-      await fs.rm(path.join(config.dependenceCachePath, cache.type), {
-        recursive: true,
-        force: true,
-      });
-      dependenceCaches.push(cache);
-    }
-    if (
-      request.compactDatabase &&
-      (deleted.runningInstances || deleted.cronStats)
-    ) {
-      await database.query('VACUUM');
-    }
-    return {
-      deleted: {
-        ...deleted,
-        dependenceCaches,
-        dependenceCacheBytes: preview.dependenceCacheBytes,
-      },
-      compactedDatabase: Boolean(
-        request.compactDatabase &&
-          (deleted.runningInstances || deleted.cronStats),
-      ),
-    };
-  }
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
whyour	33b2f2da77	更新 npm 版本 v2.20.0	2025-12-11 01:57:01 +08:00
whyour	4bdcb1a1e9	移除 init_nginx	2025-12-11 01:56:52 +08:00
whyour	f99e92f28d	更新 pipeline	2025-12-11 01:53:51 +08:00
whyour	ffa187cb36	增加用户 qinglong	2025-12-11 01:53:51 +08:00
whyour	b1ca19bdd7	增加 packageManager	2025-12-11 01:53:51 +08:00
whyour	644ad1737b	更新 npm 版本 v2.19.2-2	2025-12-11 01:53:51 +08:00
whyour	d3e6fdf018	更新 npm 版本 v2.19.1-0	2025-12-11 01:53:51 +08:00
whyour	5673bc635e	修复 apt 命令	2025-12-11 01:53:51 +08:00
whyour	88ae00580a	更新 npm 版本 v2.19.0-10	2025-12-11 01:53:50 +08:00
whyour	7d4d871d5a	修改 linux 启动文件逻辑	2025-12-11 01:53:50 +08:00
whyour	0d02e85cfc	修复发布 npm包依赖文件	2025-12-11 01:53:50 +08:00
whyour	ba81732996	修复 npm 启动脚本	2025-12-11 01:53:50 +08:00
whyour	5679857025	移除自动清除 deb	2025-12-11 01:53:50 +08:00
whyour	3b0dc2e76e	修复 command 变量	2025-12-11 01:53:50 +08:00
whyour	360dbac033	更新 npm 版本 v2.18.3-3	2025-12-11 01:53:50 +08:00
whyour	d351a1844e	更新 nodejs 版本	2025-12-11 01:53:50 +08:00
whyour	db66691cf9	更新 npm 版本 v2.18.2-6	2025-12-11 01:53:50 +08:00
whyour	671be89446	修复系统安装依赖提示	2025-12-11 01:53:50 +08:00
whyour	4fa6adc590	写入文件增加文件锁	2025-12-11 01:53:50 +08:00
whyour	77bb9fd8a9	更新 npm 版本 v2.17.13	2025-12-11 01:53:50 +08:00
whyour	2080ced834	修改本地服务启动提示	2025-12-11 01:53:50 +08:00
whyour	7f99cb6e7d	更新 npm 版本 v2.17.12	2025-12-11 01:53:50 +08:00
whyour	fd340806b1	修改 debian 版本为 12 bookworm	2025-12-11 01:53:50 +08:00
whyour	9ab3d9367e	更新 npm 版本 v2.17.11	2025-12-11 01:53:50 +08:00
whyour	54ed0fd0fa	更新 npm 版本 v2.17.10	2025-12-11 01:53:50 +08:00
whyour	e13c5052b0	更新 npm 版本 v2.17.9	2025-12-11 01:53:50 +08:00
whyour	32495911a1	修复 qinglong 命令	2025-12-11 01:53:50 +08:00
whyour	b93ce700f8	更新 npm 版本 v2.17.8	2025-12-11 01:53:50 +08:00
whyour	78591dc2bc	npm 启动增加 reload 逻辑	2025-12-11 01:53:50 +08:00
whyour	b4f5a416ac	修改 ts 文件执行依赖	2025-12-11 01:53:50 +08:00
whyour	28d03cb3a9	更新 npm 版本 v0.21.2	2025-12-11 01:53:50 +08:00
whyour	9853a368b4	修改 apt 命令	2025-12-11 01:53:50 +08:00
whyour	b9380c53d6	安装 linux 依赖自动识别 alpine 和 debian	2025-12-11 01:53:50 +08:00
whyour	f942b83eb6	更新 npm 版本 v0.20.4	2025-12-11 01:53:50 +08:00
whyour	e81f633d1c	修复 debian netcat 包名	2025-12-11 01:53:50 +08:00
whyour	f76d3ef15c	更新 npm 版本 v0.19.9	2025-12-11 01:53:50 +08:00
whyour	eef6ff8dcf	修改 npm 安装启动命令	2025-12-11 01:53:49 +08:00
whyour	91c77342ee	更新 npm 版本 v0.18.0	2025-12-11 01:53:49 +08:00
whyour	5a8ec34453	更新 npm 版本 v0.17.0	2025-12-11 01:53:49 +08:00
whyour	6200a7d2b7	修复 linux 镜像源	2025-12-11 01:53:49 +08:00
whyour	41ad55f42b	更新 npm 版本 v0.16.0	2025-12-11 01:53:49 +08:00
whyour	635bc7ce65	更新 workflow action 版本	2025-12-11 01:53:49 +08:00
whyour	3747681a70	增加 npx 命令	2025-12-11 01:53:49 +08:00
whyour	830f312853	更新 npm 版本 v0.14.5	2025-12-11 01:53:49 +08:00
whyour	81dc3926df	修复 workflow	2025-12-11 01:53:49 +08:00
whyour	db150d8c75	移除 qinglong 命令 npm 默认镜像源	2025-12-11 01:53:49 +08:00
whyour	e466caee42	修复 qinglong 命令	2025-12-11 01:53:49 +08:00
whyour	4c6d820481	修改切换 linux 镜像源	2025-12-11 01:53:49 +08:00
whyour	9719584e7d	增加 debian 开发版本	2025-12-11 01:53:49 +08:00
whyour	bcfa5ab075	更新 npm 版本 v0.13.2	2025-12-11 01:53:49 +08:00
whyour	5079cd39c6	修复 qinglong 命令	2025-12-11 01:53:49 +08:00
whyour	f9951ba7d5	修复 shell check_server	2025-12-11 01:53:49 +08:00
whyour	91d9df3df8	修复拉取私有仓库	2025-12-11 01:53:49 +08:00
dream10201	cea7f5132e	修复linux依赖检测 (#2082 )	2025-12-11 01:53:49 +08:00
whyour	f7c6dc999d	更新 npm v0.8.4	2025-12-11 01:53:49 +08:00
whyour	153789e670	更新 npm 版本 0.7.7	2025-12-11 01:53:48 +08:00
whyour	85c03ce960	修复 debian apt 命令，支持 qinglong 命令	2025-12-11 01:53:48 +08:00
whyour	9753618480	增加 debian-slim 基础镜像	2025-12-11 01:53:48 +08:00
whyour	7a580e816f	修改获取示例文件 api path	2025-12-11 01:53:48 +08:00