修复拷贝deps

修复dep目录
更新版本 v2.10.7
2026-08-11 19:05:20 +08:00 · 2021-11-13 22:05:54 +08:00 · 2021-11-13 21:54:45 +08:00 · 2021-11-13 21:21:35 +08:00 · 2021-11-13 20:58:27 +08:00 · 2021-11-13 19:05:34 +08:00
260 changed files with 18431 additions and 57860 deletions
@@ -1,11 +1,9 @@
-GRPC_PORT=5500
+MONGODB_URI='mongodb://'
-BACK_PORT=5700
+YIYAN_MONGODB_URI=''
-LOG_LEVEL='info'
+CRON_PORT=5500
 PORT=5600
-JWT_SECRET=
+LOG_LEVEL='debug'
 JWT_EXPIRES_IN=
-QINIU_AK=
+SECRET='whyour'
 QINIU_SK=
 QINIU_SCOPE=
@@ -1,42 +0,0 @@
 name: "\U0001F41E Bug report"
 description: Create a report to help us improve
 body:
  - type: input
    id: version
    attributes:
      label: Qinglong version
    validations:
      required: true
  - type: textarea
    id: steps-to-reproduce
    attributes:
      label: Steps to reproduce
      description: |
        What do we need to do after opening your repro in order to make the bug happen? Clear and concise reproduction instructions are important for us to be able to triage your issue in a timely manner. Note that you can use [Markdown](https://guides.github.com/features/mastering-markdown/) to format lists and code.
      placeholder: Steps to reproduce
    validations:
      required: true
  - type: textarea
    id: expected
    attributes:
      label: What is expected?
    validations:
      required: true
  - type: textarea
    id: actually-happening
    attributes:
      label: What is actually happening?
    validations:
      required: true
  - type: textarea
    id: system-info
    attributes:
      label: System Info
      description: Output of `npx envinfo --system --binaries --browsers`
      render: shell
      placeholder: System, Binaries, Browsers
  - type: textarea
    id: additional-comments
    attributes:
      label: Any additional comments?
      description: e.g. some background/context of how you ran into this bug.
@@ -1,8 +0,0 @@
 blank_issues_enabled: false
 contact_links:
  - name: Telegram Chat
    url: https://t.me/jiao_long
    about: Ask questions and discuss with other Qinglong users in real time.
  - name: Questions & Discussions
    url: https://github.com/whyour/qinglong/discussions/new?category=q-a
    about: Use GitHub discussions for message-board style questions and discussions.
@@ -1,40 +0,0 @@
 name: "\U0001F680 New feature proposal"
 description: Suggest an idea for this project
 labels: [":sparkles: feature request"]
 body:
  - type: markdown
    attributes:
      value: |
        Thanks for your interest in the project and taking the time to fill out this feature report!
  - type: textarea
    id: feature-description
    attributes:
      label: Clear and concise description of the problem
      description: "Explain your use case, context, and rationale behind this feature request. More importantly, what is the **end user experience** you are trying to build that led to the need for this feature?"
    validations:
      required: true
  - type: textarea
    id: suggested-solution
    attributes:
      label: Suggested solution
      description: "In module [xy] we could provide following implementation..."
    validations:
      required: true
  - type: textarea
    id: alternative
    attributes:
      label: Alternative
      description: Clear and concise description of any alternative solutions or features you've considered.
  - type: textarea
    id: additional-context
    attributes:
      label: Additional context
      description: Any other context or screenshots about the feature request here.
  - type: checkboxes
    id: checkboxes
    attributes:
      label: Validations
      description: Before submitting the issue, please make sure you do the following
      options:
        - label: Check that there isn't already an issue that request the same feature to avoid creating a duplicate.
          required: true
@@ -1,31 +0,0 @@
 ## PR Type
 What kind of change does this PR introduce?
 <!-- Please check the one that applies to this PR using "x". -->
 - [ ] Bugfix
 - [ ] Feature
 - [ ] Code style update (formatting, local variables)
 - [ ] Refactoring (no functional changes, no api changes)
 - [ ] Other... Please describe:
 ## What is the current behavior?
 <!-- Please describe the current behavior that you are modifying, or link to a relevant issue. -->
 Issue Number: N/A
 ## What is the new behavior?
 ## Does this PR introduce a breaking change?
 - [ ] Yes
 - [ ] No
 <!-- If this PR contains a breaking change, please describe the impact and migration path for existing applications below. -->
 ## Other information
@@ -1,4 +0,0 @@
 ---
 name: Bug Fixer
 description: Fix this issue following our error handling pattern.
 ---
@@ -1,7 +0,0 @@
 # Comment to be posted to on PRs from first time contributors in your repository
 newPRWelcomeComment: |
  💖 Thanks for opening this pull request! 💖
  Please be patient and we will get back to you as soon as we can.
 # Comment to be posted to on pull requests merged by a first time user
 firstPRMergeComment: >
  Congrats on merging your first pull request! 🎉🎉🎉
@@ -1,263 +0,0 @@
 name: Build And Push Docker Image
 on:
  push:
    paths-ignore:
      - "*.md"
    branches:
      - "master"
      - "develop"
    tags:
      - "v*"
  schedule:
    - cron: "00 20 * * *"
  workflow_dispatch:
 jobs:
  code_gitlab:
    runs-on: ubuntu-latest
    steps:
      - 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"
          force_update: true
  code_gitee:
    runs-on: ubuntu-latest
    steps:
      - 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@v4
        with:
          cache: "pnpm"
      - name: build front and back
        run: |
          pnpm install --frozen-lockfile
          pnpm build:front
          pnpm build:back
      - name: copy to static repo
        env:
          GITHUB_REPO: github.com/${{ github.repository_owner }}/qinglong-static
          GITHUB_BRANCH: ${{ github.ref_name }}
          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: |
          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
    steps:
      - 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
  static_gitee:
    needs: build-static
    runs-on: ubuntu-latest
    steps:
      - 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
  build:
    needs: build-static
    runs-on: ubuntu-22.04
    permissions:
      packages: write
      contents: read
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v3
        with:
          version: "8.3.1"
      - uses: actions/setup-node@v4
        with:
          cache: "pnpm"
      - name: Setup timezone
        uses: szenius/set-timezone@v2.0
        with:
          timezoneLinux: Asia/Shanghai
      - name: Login to DockerHub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Login to GHCR
        uses: docker/login-action@v3
        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@v5
        with:
          images: |
            ${{ github.repository }}
            ghcr.io/${{ github.repository }}
          # generate Docker tags based on the following events/attributes
          #   nightly, master, pr-2, 1.2.3, 1.2, 1
          flavor: |
            latest=false
          tags: |
            type=schedule,pattern=nightly
            type=edge
            type=ref,event=pr
            type=ref,event=branch,enable=${{ github.ref != format('refs/heads/{0}', 'master') }}
            type=raw,value=latest,enable=${{ github.ref == format('refs/heads/{0}', 'master') }}
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=semver,pattern={{major}}
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      - name: Build and push
        id: docker_build
        uses: docker/build-push-action@v6
        with:
          build-args: |
            MAINTAINER=${{ github.repository_owner }}
            QL_BRANCH=${{ github.ref_name }}
            SOURCE_COMMIT=${{ github.sha }}
          network: host
          # linux/s390x npm 暂不可用
          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/386
          context: .
          file: ./docker/Dockerfile
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=registry,ref=whyour/qinglong:cache
          cache-to: type=registry,ref=whyour/qinglong:cache,mode=max
      - name: Image digest
        run: |
          echo ${{ steps.docker_build.outputs.digest }}
  build310:
    if: ${{ github.ref_name == 'master' }}
    needs: build-static
    runs-on: ubuntu-22.04
    permissions:
      packages: write
      contents: read
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v3
        with:
          version: "8.3.1"
      - uses: actions/setup-node@v4
        with:
          cache: "pnpm"
      - name: Setup timezone
        uses: szenius/set-timezone@v2.0
        with:
          timezoneLinux: Asia/Shanghai
      - name: Login to DockerHub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Login to GHCR
        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@v3
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      - name: Build and push python3.10
        id: docker_build_310
        uses: docker/build-push-action@v6
        with:
          build-args: |
            MAINTAINER=${{ github.repository_owner }}
            QL_BRANCH=${{ github.ref_name }}
            SOURCE_COMMIT=${{ github.sha }}
          network: host
          # linux/s390x npm 暂不可用
          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/386
          context: .
          file: ./docker/310.Dockerfile
          push: true
          tags: whyour/qinglong:python3.10
          cache-from: type=registry,ref=whyour/qinglong:cache-python3.10
          cache-to: type=registry,ref=whyour/qinglong:cache-python3.10,mode=max
      - name: Image digest
        run: |
          echo ${{ steps.docker_build_310.outputs.digest }}
@@ -0,0 +1,113 @@
 name: Build And Push Docker Image
 on:
  push:
    branches:
      - 'master'
      - 'develop'
    # Sequence of patterns matched against refs/tags
    tags:
      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
  schedule:
    # 参考 https://jasonet.co/posts/scheduled-actions/
    # note: 这里是GMT时间，北京时间减去八小时即可。如北京时间 22:30 => GMT 14:30
    # minute hour day month dayOfWeek
    - cron: '00 14 * * *' # GMT 14:00 => 北京时间 22:00
    #- cron: '30 16 * * *' # GMT 16:30（前一天） => 北京时间 00:30
  workflow_dispatch:
 jobs:
  build-static:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v1
        with:
          node-version: '14'
      - name: build front and back
        run: |
          yarn install
          yarn build
          yarn build-back
      - name: copy to static repo
        env:
          GITHUB_REPO: github.com/${{ github.repository_owner }}/qinglong-static
          GITHUB_BRANCH: ${{ github.ref_name }}
        run: |
          mkdir -p static
          cd ./static
          cp -rf ../dist ./ && cp -rf ../build ./
          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}
  build:
    needs: build-static
    runs-on: ubuntu-latest
    permissions:
      packages: write
      contents: read
    steps:
      - uses: actions/checkout@v2
      - name: Set time zone
        uses: szenius/set-timezone@v1.0
        with:
          timezoneLinux: "Asia/Shanghai"
          timezoneMacos: "Asia/Shanghai"
          timezoneWindows: "China Standard Time"
      - name: Login to DockerHub
        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      - name: Login to GHCR
        uses: docker/login-action@v1
        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@v3
        with:
          images: |
            ${{ github.repository }}
            ghcr.io/${{ github.repository }}
          # generate Docker tags based on the following events/attributes
          #   nightly, master, pr-2, 1.2.3, 1.2, 1
          tags: |
            type=schedule,pattern=nightly
            type=edge
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=semver,pattern={{major}}
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v1
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1
      - name: Build and push
        id: docker_build
        uses: docker/build-push-action@v2
        with:
          build-args: MAINTAINER=${{ github.repository_owner }}, QL_BRANCH=${{ github.ref_name }}
          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/s390x
          context: docker/
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
@@ -0,0 +1,31 @@
 name: PublishDockerImage
 on:
  workflow_dispatch:
 jobs:
  build:
    name: Build
    runs-on: ubuntu-latest
    steps:
      - name: Checkout base
        uses: actions/checkout@v2
        with:
          fetch-depth: 0
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v1
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1
      - name: Docker login
        env:
          DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
          DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
        run: |
          echo "${DOCKER_PASSWORD}" | docker login --username "${DOCKER_USERNAME}" --password-stdin
      - name: Docker buildx image and push on master branch
        env:
          SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }}
        run: |
          docker buildx build --build-arg SSH_PRIVATE_KEY="${SSH_PRIVATE_KEY}" --output "type=image,push=true" --platform=linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/s390x --tag whyour/qinglong:latest docker/
@@ -4,12 +4,12 @@
 /node_modules
 /npm-debug.log*
 /yarn-error.log
-/yarn.lock
+/pnpm-lock.yaml
 /package-lock.json
 # production
-/static
+/dist
-/data
+/build
 # misc
 .DS_Store
@@ -22,9 +22,10 @@
 .env
 .history
 .version.ts
-/.tmp
+
-__pycache__
+/config
-/shell/preload/env.*
+/log
-/shell/preload/notify.*
+/db
-/shell/preload/*-notify.json
+/manual_log
-/shell/preload/__ql_notify__.*
+/scripts
 /bak
@@ -1 +0,0 @@
 strict-peer-dependencies=false
@@ -2,23 +2,7 @@
 **/*.svg
 **/*.ejs
 **/*.html
-/.umi
+package.json
-/.umi-production
+.umi
-/.umi-test
+.umi-production
-/.history
+.umi-test
 /.tmp
 /node_modules
 npm-debug.log*
 yarn-error.log
 yarn.lock
 package-lock.json
 /static
 /data
 DS_Store
 /src/.umi
 /src/.umi-production
 /src/.umi-test
 .env.local
 .env
 version.ts
 /.tmp
@@ -1,29 +1,25 @@
-import { defineConfig } from '@umijs/max';
+import { defineConfig } from 'umi';
 const CompressionPlugin = require('compression-webpack-plugin');
 const baseUrl = process.env.QlBaseUrl || '/';
 export default defineConfig({
  hash: true,
-  jsMinifier: 'terser',
+  layout: false,
-  antd: {},
+  nodeModulesTransform: {
-  locale: {
+    type: 'none',
    antd: true,
    title: true,
    baseNavigator: true,
  },
-  outputPath: 'static/dist',
+  fastRefresh: {},
-  fastRefresh: true,
+  dynamicImport: {
-  favicons: [`https://qn.whyour.cn/favicon.svg`],
+    loading: '@/components/pageLoading',
-  publicPath: process.env.NODE_ENV === 'production' ? './' : '/',
+  },
  favicon: '/images/g5.ico',
  proxy: {
-    [`${baseUrl}api`]: {
+    '/api': {
-      target: 'http://127.0.0.1:5700/',
+      target: 'http://127.0.0.1:5600/',
      changeOrigin: true,
      ws: true,
      pathRewrite: { [`^${baseUrl}api`]: '/api' },
    },
  },
-  chainWebpack: ((config: any) => {
+  chainWebpack: (config) => {
    config.plugin('compression-webpack-plugin').use(
      new CompressionPlugin({
        algorithm: 'gzip',
@@ -32,13 +28,22 @@ export default defineConfig({
        minRatio: 0.6,
      }),
    );
-  }) as any,
+  },
-  headScripts: [`./api/env.js`],
+  externals: {
-  copy: [
+    react: 'window.React',
-    {
+    'react-dom': 'window.ReactDOM',
-      from: 'node_modules/monaco-editor/min/vs',
+    darkreader: 'window.DarkReader',
-      to: 'static/dist/monaco-editor/min/vs',
+    codemirror: 'window.CodeMirror',
-    },
+    'sockjs-client': 'window.SockJS',
  },
  scripts: [
    'https://gw.alipayobjects.com/os/lib/react/16.13.1/umd/react.production.min.js',
    'https://gw.alipayobjects.com/os/lib/react-dom/16.13.1/umd/react-dom.production.min.js',
    'https://cdn.jsdelivr.net/npm/darkreader@4/darkreader.min.js',
    'https://cdn.jsdelivr.net/npm/codemirror@5/lib/codemirror.min.js',
    'https://cdn.jsdelivr.net/npm/codemirror@5/mode/shell/shell.js',
    'https://cdn.jsdelivr.net/npm/codemirror@5/mode/python/python.js',
    'https://cdn.jsdelivr.net/npm/codemirror@5/mode/javascript/javascript.js',
    'https://cdn.jsdelivr.net/npm/sockjs-client@1/dist/sockjs.min.js',
  ],
  npmClient: 'pnpm',
 });
@@ -1,359 +0,0 @@
 # 场景模式完整实现总结 (Scenario Mode Complete Implementation Summary)
 ## 🎉 实现完成 (Implementation Complete)
 场景模式功能已完全实现，包含可视化工作流编辑器和完整的图执行引擎！
 ## 📦 实现的三个阶段 (Three Implementation Phases)
 ### Phase 1: 基础架构 (Foundation) ✅
 **Commits**: fffc1e4, 2e0775e
 - 数据模型扩展（添加 `workflowGraph` 字段）
 - 数据库迁移
 - API 层更新
 - 依赖包安装（Flowgram + React Flow）
 - 基础文档
 ### Phase 2: 可视化编辑器 (Visual Editor) ✅
 **Commit**: 5ed2e5b
 - 完整的节点类型系统（5大类，20+模板）
 - 基于 React Flow 的可视化编辑器
 - 拖拽式节点创建和连接
 - 动态配置表单
 - 节点渲染器
 ### Phase 3: 图执行引擎 (Graph Execution Engine) ✅
 **Commit**: 2c5357e
 - 图遍历和执行引擎
 - 节点执行实现（触发器、条件、动作、控制流）
 - 工作流验证
 - 双模式支持（图模式 + 遗留模式）
 ## 🎯 功能清单 (Feature Checklist)
 ### 原始需求完全实现 ✅
 #### 多样化触发器 (Diverse Triggers)
 - [x] **变量监听**: 环境变量/配置文件变更监听 ✅
 - [x] **Webhook触发器**: API端点接收外部触发 ✅
 - [x] **任务状态触发器**: 基于其他任务的成功/失败状态触发 ✅
 - [x] **时间触发器**: Cron表达式支持 ✅
 - [x] **系统事件**: 磁盘空间/内存占用等硬件指标触发 ✅
 #### 动态响应机制 (Dynamic Response)
 - [x] **多条件嵌套**: 支持AND/OR逻辑的条件组合 ✅
 - [x] **延时执行**: 设置触发后的延迟执行时间 ✅
 - [x] **失败熔断**: 连续失败N次后自动禁用任务 ✅
 - [x] **自适应重试**: 根据错误类型配置重试策略 ✅
 #### 可视化工作流 (Visual Workflow) ✅
 - [x] **节点式编辑器**: 拖拽创建工作流 ✅
 - [x] **节点配置**: 双击配置节点参数 ✅
 - [x] **连线绘制**: 可视化连接节点 ✅
 - [x] **实时保存**: 工作流图持久化 ✅
 ## 💻 技术架构 (Technical Architecture)
 ### 后端 (Backend)
 ```
 ├── back/data/scenario.ts           # 数据模型（支持 workflowGraph）
 ├── back/data/scenarioLog.ts        # 日志模型
 ├── back/services/scenario.ts       # 场景服务（双模式支持）
 ├── back/services/graphExecutor.ts  # 图执行引擎
 └── back/api/scenario.ts            # REST API
 ```
 **关键技术**:
 - TypeScript
 - Sequelize (SQLite)
 - TypeDI (依赖注入)
 - Chokidar (文件监控)
 - Node-Schedule (定时任务)
 ### 前端 (Frontend)
 ```
 ├── src/pages/scenario/
 │   ├── index.tsx                   # 场景列表页
 │   ├── visualWorkflowModal.tsx     # 可视化编辑器
 │   ├── nodeTypes.tsx               # 节点类型定义
 │   ├── logModal.tsx                # 日志查看器
 │   └── modal.tsx                   # (遗留)表单编辑器
 └── src/locales/                    # 国际化文件
 ```
 **关键技术**:
 - React 18
 - TypeScript
 - React Flow (可视化工作流)
 - Ant Design 4
 - React Intl Universal
 ## 📊 代码统计 (Code Statistics)
 ### 新增代码
 - **后端**: ~1,200 行
  - 数据模型: ~200 行
  - 服务层: ~850 行
  - API 层: ~150 行
 - **前端**: ~1,600 行
  - 节点系统: ~300 行
  - 可视化编辑器: ~500 行
  - 列表页面: ~300 行
  - 日志查看: ~130 行
  - 国际化: ~144 条翻译
 - **文档**: ~700 行
  - SCENARIO_MODE.md: 用户指南
  - IMPLEMENTATION_SUMMARY.md: 技术总结
  - FLOWGRAM_INTEGRATION_STATUS.md: 集成状态
  - COMPLETE_SUMMARY.md: 完整总结
 ### 修改文件
 - 数据库加载器: +4 行
 - 主菜单: +6 行
 - Package.json: +2 个依赖
 **总计**: ~2,800 行新增代码 + 详细文档
 ## 🎨 用户界面 (User Interface)
 ### 场景列表页
 - 表格展示所有场景
 - 实时统计（执行次数、成功/失败率）
 - 快速操作（启用/禁用、手动触发、查看日志）
 - Webhook URL 获取
 ### 可视化编辑器
 - 工具栏：快速添加节点
  - 触发器按钮
  - 条件按钮
  - 动作按钮
  - 控制流按钮
  - 逻辑门按钮
 - 画布：拖拽节点和连线
 - 配置抽屉：双击节点配置参数
 - 网格背景：辅助对齐
 - 缩放控制：放大缩小画布
 ### 日志查看器
 - 时间线展示
 - 执行状态（成功/失败）
 - 条件匹配结果
 - 执行时间
 - 重试次数
 - 错误信息
 ## 🔧 使用示例 (Usage Examples)
 ### 示例 1: 定时备份工作流
 ```
 [时间触发: 每天凌晨3点]
    ↓
 [检查磁盘空间 > 20%]
    ↓
 [执行备份命令]
    ↓
 [发送通知: 备份完成]
 ```
 ### 示例 2: CI/CD 集成工作流
 ```
 [Webhook触发]
    ↓
 [条件: branch == "main" AND status == "success"]
    ↓
 [运行部署任务]
    ↓
 [设置变量: LAST_DEPLOY = timestamp]
    ↓
 [发送通知: 部署成功]
 ```
 ### 示例 3: 任务链工作流
 ```
 [任务状态触发: 任务A完成]
    ↓
 [条件: 任务A成功]
    ↓
 [延迟执行: 60秒]
    ↓
 [运行任务B]
    ↓ (失败)
 [重试策略: 3次，间隔5秒，指数退避]
    ↓ (仍然失败)
 [熔断器: 禁用场景]
 ```
 ## 🚀 部署和使用 (Deployment & Usage)
 ### 安装依赖
 ```bash
 pnpm install
 ```
 ### 构建
 ```bash
 npm run build:back    # 构建后端
 npm run build:front   # 构建前端
 ```
 ### 启动
 ```bash
 npm run panel         # 生产模式
 # 或
 npm start            # 开发模式
 ```
 ### 访问
 1. 登录青龙面板
 2. 点击侧边栏"场景模式"菜单
 3. 点击"新建场景"按钮
 4. 在可视化编辑器中创建工作流
 5. 保存并启用场景
 ## 📖 API 文档 (API Documentation)
 ### 场景管理
 ```bash
 # 获取场景列表
 GET /api/scenarios
 # 创建场景
 POST /api/scenarios
 {
  "name": "场景名称",
  "description": "描述",
  "workflowGraph": {
    "nodes": [...],
    "edges": [...]
  }
 }
 # 更新场景
 PUT /api/scenarios
 {
  "id": 1,
  "name": "新名称",
  "workflowGraph": {...}
 }
 # 删除场景
 DELETE /api/scenarios
 { "ids": [1, 2, 3] }
 # 手动触发
 POST /api/scenarios/:id/trigger
 {}
 # 获取 Webhook URL
 GET /api/scenarios/:id/webhook
 ```
 ### Webhook 触发
 ```bash
 POST /api/scenarios/webhook/:token
 Content-Type: application/json
 {
  "event": "deployment",
  "status": "success",
  "branch": "main",
  "data": {...}
 }
 ```
 ### 日志查询
 ```bash
 GET /api/scenarios/logs?scenarioId=1&limit=100
 ```
 ## 🔒 安全性 (Security)
 - ✅ Webhook Token 认证
 - ✅ 命令执行权限控制
 - ✅ 输入验证（Joi）
 - ✅ SQL 注入防护（Sequelize）
 - ✅ 循环检测
 - ✅ 失败熔断
 ## 🧪 测试建议 (Testing Recommendations)
 ### 手动测试清单
 - [ ] 创建场景
 - [ ] 添加各类节点
 - [ ] 配置节点参数
 - [ ] 连接节点
 - [ ] 保存场景
 - [ ] 启用场景
 - [ ] 触发执行（手动/Webhook/定时）
 - [ ] 查看日志
 - [ ] 验证结果
 ### 自动化测试（未来）
 - 单元测试：节点执行逻辑
 - 集成测试：完整工作流执行
 - E2E 测试：前端交互
 ## 📝 已知限制 (Known Limitations)
 1. **并行执行**: 当前是串行执行节点（可扩展）
 2. **子工作流**: 不支持嵌套工作流（可扩展）
 3. **循环**: 不支持 for-each 循环（可扩展）
 4. **条件分支**: 简单的条件判断（可扩展为 if-else）
 ## 🔮 未来增强 (Future Enhancements)
 ### 短期 (Short-term)
 - [ ] 并行节点执行
 - [ ] 可视化执行轨迹
 - [ ] 节点模板库
 - [ ] 工作流导入/导出
 ### 中期 (Mid-term)
 - [ ] 子工作流支持
 - [ ] 条件分支节点（if-else）
 - [ ] 循环节点（for-each）
 - [ ] 变量传递优化
 ### 长期 (Long-term)
 - [ ] 工作流市场
 - [ ] AI 辅助工作流生成
 - [ ] 实时执行监控
 - [ ] 性能分析工具
 ## 🎓 学习资源 (Learning Resources)
 ### 文档
 - `SCENARIO_MODE.md` - 用户指南
 - `IMPLEMENTATION_SUMMARY.md` - 技术实现
 - `FLOWGRAM_INTEGRATION_STATUS.md` - 集成进度
 ### 代码示例
 见源代码中的注释和 JSDoc
 ### 社区
 - GitHub Issues: 问题反馈
 - Pull Requests: 功能贡献
 ## 🙏 致谢 (Acknowledgments)
 - **Flowgram.ai** - 工作流编辑器灵感
 - **React Flow** - 可视化图编辑库
 - **Qinglong** - 基础平台
 - **贡献者** - 所有参与者
 ## 📄 许可证 (License)
 遵循青龙面板的开源许可证
 ---
 **实现完成日期**: 2025-11-09
 **版本**: 1.0.0
 **状态**: ✅ 生产就绪 (Production Ready)
 🎉 场景模式功能已完全实现并可投入使用！
@@ -1,329 +0,0 @@
 # Flowgram 实现完成总结 (Flowgram Implementation Summary)
 ## 🎉 实现状态：完成 (Status: Complete)
 本文档总结了 Flowgram 可视化工作流编辑器的完整实现。
 ---
 ## 📦 实现的组件 (Implemented Components)
 ### 1. 类型定义系统 (Type System)
 **文件**: `src/pages/scenario/flowgram/types.ts`
 - FlowgramGraph, FlowgramNode, FlowgramEdge 接口
 - 7 种节点数据类型接口
 - 完整的 TypeScript 类型安全
 ### 2. 节点注册系统 (Node Registry)
 **文件**: `src/pages/scenario/flowgram/nodes/index.ts`
 - 节点创建工厂函数 (createStartNode, createTriggerNode, etc.)
 - 20+ 预配置节点模板
 - 使用 nanoid 生成唯一节点 ID
 ### 3. 数据转换工具 (Data Converter)
 **文件**: `src/pages/scenario/flowgram/utils/dataConverter.ts`
 - `flowgramToBackend()` - 前端到后端格式转换
 - `backendToFlowgram()` - 后端到前端格式转换
 - `validateWorkflow()` - 工作流验证（循环检测、断点检测）
 - `createEdge()` - 边创建辅助函数
 ### 4. Flowgram 编辑器 (Flowgram Editor)
 **文件**: `src/pages/scenario/flowgram/Editor.tsx` (480+ 行)
 **功能**:
 - 工具栏 - 快速添加各类节点
 - 节点列表 - 显示所有节点卡片
 - 配置抽屉 - 点击节点打开配置表单
 - 动态表单 - 根据节点类型显示不同配置项
 - 工作流验证 - 检查工作流结构合法性
 **支持的节点类型**:
 - ✅ Start (开始) / End (结束)
 - ✅ Trigger (触发器): 时间、Webhook、变量监听、任务状态、系统事件
 - ✅ Condition (条件): 6种操作符
 - ✅ Action (动作): 运行任务、设置变量、执行命令、发送通知
 - ✅ Control (控制流): 延迟、重试、熔断器
 - ✅ Logic Gate (逻辑门): AND、OR
 ### 5. 样式文件 (Styles)
 **文件**: `src/pages/scenario/flowgram/editor.css`
 - 编辑器容器样式
 - 工具栏样式
 - 画布样式
 - 节点卡片样式和悬停效果
 ### 6. 工作流模态框 (Workflow Modal)
 **文件**: `src/pages/scenario/flowgramWorkflowModal.tsx`
 - 场景创建/编辑模态框
 - 集成 Flowgram 编辑器
 - 表单验证和提交处理
 - 启用/禁用开关
 ### 7. 主页面集成 (Main Page Integration)
 **文件**: `src/pages/scenario/index.tsx` (已更新)
 - 从 `visualWorkflowModal` 切换到 `flowgramWorkflowModal`
 - 保持所有现有功能
 ---
 ## 🎨 用户界面 (User Interface)
 ### 工具栏 (Toolbar)
 ```
 [开始] [添加触发器▾] [条件] [添加动作▾] [添加控制流▾] [添加逻辑门▾] [结束] [验证]
 ```
 ### 节点配置示例 (Node Configuration Examples)
 #### Trigger 节点 - 时间触发
 - 标签: "每日任务触发"
 - 触发类型: time
 - Cron表达式: "0 0 * * *"
 #### Condition 节点
 - 标签: "检查状态"
 - 字段: "data.status"
 - 操作符: equals
 - 值: "success"
 #### Action 节点 - 运行任务
 - 标签: "执行备份任务"
 - 动作类型: run_task
 - 任务ID: 123
 #### Control 节点 - 延迟
 - 标签: "等待30秒"
 - 控制类型: delay
 - 延迟时间: 30秒
 ---
 ## 📊 技术架构 (Technical Architecture)
 ```
 ┌─────────────────────────────────────────────────────────┐
 │  用户界面 (User Interface)                                 │
 │  - 工具栏 (Toolbar)                                       │
 │  - 节点列表 (Node List)                                   │
 │  - 配置抽屉 (Config Drawer)                               │
 └──────────────────┬──────────────────────────────────────┘
                   │
 ┌──────────────────▼──────────────────────────────────────┐
 │  FlowgramEditor 组件                                       │
 │  - 状态管理 (State Management)                            │
 │  - 事件处理 (Event Handlers)                              │
 │  - 表单渲染 (Form Rendering)                              │
 └──────────────────┬──────────────────────────────────────┘
                   │
 ┌──────────────────▼──────────────────────────────────────┐
 │  节点系统 (Node System)                                    │
 │  - 节点模板 (Node Templates)                              │
 │  - 节点创建 (Node Creation)                               │
 │  - 类型定义 (Type Definitions)                            │
 └──────────────────┬──────────────────────────────────────┘
                   │
 ┌──────────────────▼──────────────────────────────────────┐
 │  数据转换 (Data Conversion)                                │
 │  - Flowgram ↔ Backend                                    │
 │  - 工作流验证 (Workflow Validation)                        │
 └──────────────────┬──────────────────────────────────────┘
                   │
 ┌──────────────────▼──────────────────────────────────────┐
 │  后端 API (Backend API)                                   │
 │  - 场景 CRUD (Scenario CRUD)                             │
 │  - 图执行引擎 (Graph Executor)                            │
 └─────────────────────────────────────────────────────────┘
 ```
 ---
 ## 🔧 数据流 (Data Flow)
 ### 创建工作流
 ```
 1. 用户点击工具栏按钮
   ↓
 2. 调用 nodeTemplates 创建节点
   ↓
 3. 更新 FlowgramGraph 状态
   ↓
 4. 通过 onChange 传递给 Modal
   ↓
 5. 用户保存，调用 flowgramToBackend()
   ↓
 6. 提交到 API: POST /api/scenarios
   ↓
 7. 保存到数据库 (workflowGraph 字段)
 ```
 ### 执行工作流
 ```
 1. 触发器激活 (时间/Webhook/事件)
   ↓
 2. 后端加载 workflowGraph
   ↓
 3. 图执行引擎遍历节点
   ↓
 4. 执行各节点逻辑
   ↓
 5. 记录执行日志
 ```
 ---
 ## 📝 使用说明 (Usage Guide)
 ### 创建场景
 1. 点击 "新建场景" 按钮
 2. 输入场景名称
 3. 使用工具栏添加节点
 4. 点击节点配置参数
 5. 点击验证按钮检查工作流
 6. 保存场景
 ### 配置节点
 1. 点击节点卡片
 2. 在配置抽屉中填写参数
 3. 点击 "保存" 按钮
 4. 节点配置已更新
 ### 验证工作流
 1. 点击工具栏 "验证" 按钮
 2. 系统检查:
   - 是否有触发器节点
   - 是否存在循环依赖
   - 是否有断开的节点
 3. 显示验证结果
 ---
 ## 🎯 功能完整性 (Feature Completeness)
 ### 原始需求对照
 | 需求 | 状态 | 实现方式 |
 |------|------|----------|
 | 变量监听 | ✅ | Trigger 节点 - variable_monitor |
 | Webhook触发器 | ✅ | Trigger 节点 - webhook |
 | 任务状态触发器 | ✅ | Trigger 节点 - task_status |
 | 时间触发器 | ✅ | Trigger 节点 - time |
 | 系统事件 | ✅ | Trigger 节点 - system_event |
 | 多条件嵌套 (AND/OR) | ✅ | Logic Gate 节点 + Condition 节点 |
 | 延时执行 | ✅ | Control 节点 - delay |
 | 失败熔断 | ✅ | Control 节点 - circuit_breaker |
 | 自适应重试 | ✅ | Control 节点 - retry |
 | 可视化编排 | ✅ | Flowgram 编辑器 |
 ---
 ## 📦 依赖列表 (Dependencies)
 已安装的 Flowgram 相关包:
 - `@flowgram.ai/free-layout-editor` - 核心编辑器
 - `@flowgram.ai/core` - 核心库
 - `@flowgram.ai/reactive` - 响应式系统
 - `@flowgram.ai/free-snap-plugin` - 吸附插件
 - `@flowgram.ai/free-lines-plugin` - 连线插件
 - `@flowgram.ai/free-node-panel-plugin` - 节点面板
 - `@flowgram.ai/minimap-plugin` - 小地图
 - `@flowgram.ai/free-container-plugin` - 容器插件
 - `@flowgram.ai/free-group-plugin` - 分组插件
 - `@flowgram.ai/form-materials` - 表单素材
 - `@flowgram.ai/panel-manager-plugin` - 面板管理
 - `@flowgram.ai/free-stack-plugin` - 堆栈插件
 - `@flowgram.ai/runtime-interface` - 运行时接口
 - `@flowgram.ai/runtime-js` - 运行时 JS
 - `nanoid` - ID 生成器
 ---
 ## 🔄 与 React Flow 实现的区别
 ### React Flow 版本 (已替换)
 - 使用 reactflow 库
 - 完整的可视化画布
 - 拖拽节点定位
 - 可视化连线
 ### Flowgram 版本 (当前)
 - 基于 Flowgram 架构
 - 节点列表视图（简化版）
 - 点击配置
 - 数据结构兼容
 ### 为什么当前是简化版?
 Flowgram 的完整可视化画布需要更多配置和集成工作。当前实现：
 - ✅ 完整的数据模型
 - ✅ 完整的节点系统
 - ✅ 完整的配置功能
 - ✅ 与后端完全兼容
 - ⏳ 可视化画布（可后续增强）
 ---
 ## 🚀 后续增强 (Future Enhancements)
 ### Phase 1 (当前) - 完成 ✅
 - [x] 节点系统
 - [x] 配置表单
 - [x] 数据转换
 - [x] 后端集成
 ### Phase 2 (未来) - 可选
 - [ ] 完整的 Flowgram 可视化画布
 - [ ] 拖拽节点定位
 - [ ] 可视化连线绘制
 - [ ] 小地图导航
 - [ ] 节点缩放和平移
 ### Phase 3 (未来) - 高级
 - [ ] 节点复制/粘贴
 - [ ] 工作流模板
 - [ ] 导入/导出
 - [ ] 执行轨迹可视化
 ---
 ## 📚 文档资源 (Documentation)
 - **FLOWGRAM_MIGRATION_GUIDE.md** - 完整的迁移指南
 - **SCENARIO_MODE.md** - 功能使用指南
 - **IMPLEMENTATION_SUMMARY.md** - 技术实现详解
 - **COMPLETE_SUMMARY.md** - 功能完整性总结
 - **本文档** - Flowgram 实现总结
 ---
 ## ✅ 验收检查 (Acceptance Checklist)
 - [x] 节点系统完整实现
 - [x] 支持所有需求的节点类型
 - [x] 配置表单动态适配
 - [x] 数据转换正确无误
 - [x] 与后端 API 集成
 - [x] 与图执行引擎兼容
 - [x] TypeScript 类型安全
 - [x] 代码风格一致
 - [x] 文档完整
 ---
 ## 🎊 总结 (Summary)
 Flowgram 可视化工作流编辑器已完整实现，包含:
 - **7 个新文件** (~900 行代码)
 - **20+ 节点模板**
 - **完整的配置系统**
 - **工作流验证**
 - **后端完全兼容**
 基于官方 Demo 实现，数据结构与后端图执行引擎无缝对接。
 **状态**: ✅ 生产就绪
 **下一步**: 可选择增强可视化画布或直接投入使用。
 ---
 **实现完成日期**: 2025-11-10
 **参考**: https://github.com/bytedance/flowgram.ai/tree/main/apps/demo-free-layout
@@ -1,151 +0,0 @@
 # Flowgram 可视化工作流集成进度 (Flowgram Visual Workflow Integration Progress)
 ## 当前状态 (Current Status)
 ### ✅ 已完成 (Completed - Commit: fffc1e4)
 1. **依赖安装** (Dependencies Installed)
   - `@flowgram.ai/free-layout-editor@1.0.2`
   - `@flowgram.ai/core@1.0.2`
   - `@flowgram.ai/reactive@1.0.2`
 2. **数据模型更新** (Data Model Updates)
   - 添加 `workflowGraph` 字段到 Scenario 模型
   - 保留旧字段以保持向后兼容
   - 数据库迁移脚本已更新
 3. **API 层更新** (API Layer Updates)
   - `triggerType` 从必需改为可选
   - 添加 `workflowGraph` 参数支持
   - Create 和 Update 端点已更新
 4. **前端基础** (Frontend Foundation)
   - 创建新的 `flowgramModal.tsx` 组件
   - 主页面更新使用新的模态框
   - 基础工作流结构定义
 ### 🔄 需要完成 (To Be Completed)
 #### 1. 完善 Flowgram 编辑器集成 (Complete Flowgram Editor Integration)
 **当前问题**: Flowgram.ai 的详细 API 文档不完全公开。需要：
 - 研究 Flowgram API 的正确使用方式
 - 实现自定义节点渲染器
 - 添加节点工具栏和配置面板
 **临时方案**: 
 - 可以使用 React Flow 或其他开源流程图库作为替代
 - 或等待 Flowgram 官方文档/示例
 #### 2. 自定义节点类型实现 (Custom Node Types)
 需要实现以下节点类型：
 ```typescript
 // Trigger Nodes (触发器节点)
 - TimeT riggerNode: 时间触发配置
 - WebhookTriggerNode: Webhook 触发配置
 - VariableTriggerNode: 变量监听配置
 - TaskStatusTriggerNode: 任务状态触发
 - SystemEventTriggerNode: 系统事件触发
 // Condition Nodes (条件节点)
 - ConditionNode: 条件判断配置
 - LogicGateNode: AND/OR 逻辑门
 // Action Nodes (动作节点)
 - RunTaskNode: 运行任务配置
 - SetVariableNode: 设置变量配置
 - ExecuteCommandNode: 执行命令配置
 - SendNotificationNode: 发送通知配置
 // Control Flow Nodes (控制流节点)
 - DelayNode: 延迟执行
 - RetryNode: 重试策略
 - CircuitBreakerNode: 熔断器
 ```
 #### 3. 节点配置面板 (Node Configuration Panels)
 每个节点类型需要自己的配置表单：
 - 双击节点打开配置面板
 - 表单验证
 - 实时预览
 #### 4. 后端执行引擎重写 (Backend Execution Engine Rewrite)
 当前 `ScenarioService.executeScenario()` 是线性执行。需要：
 ```typescript
 // 新的图执行引擎
 class GraphExecutor {
  async execute(workflowGraph: any, triggerData: any) {
    // 1. 查找入口节点（触发器节点）
    // 2. 遍历图结构
    // 3. 评估条件节点
    // 4. 执行动作节点
    // 5. 处理分支和合并
    // 6. 记录执行轨迹
  }
 }
 ```
 #### 5. 工作流验证 (Workflow Validation)
 - 检查是否有有效的触发器节点
 - 验证节点连接的完整性
 - 检测循环
 - 验证节点配置
 #### 6. 测试和调试 (Testing & Debugging)
 - 单元测试
 - 集成测试
 - UI 测试
 - 性能测试
 ## 实现建议 (Implementation Recommendations)
 ### 方案 A: 完整 Flowgram 集成 (推荐如有文档)
 如果能获取 Flowgram 完整文档和示例：
 1. 参考官方示例实现自定义节点
 2. 使用 Flowgram 的插件系统
 3. 利用 Flowgram 的内置功能
 ### 方案 B: 使用 React Flow (备选方案)
 如果 Flowgram 文档不足：
 1. 使用 React Flow (`reactflow` npm package)
 2. 成熟的文档和社区支持
 3. 更容易实现自定义节点
 4. 保持相同的数据结构
 ### 方案 C: 混合方案
 1. 前端继续改进表单界面
 2. 后端同时支持表单数据和图数据
 3. 渐进式迁移
 ## 预估工作量 (Estimated Effort)
 - **方案 A** (Flowgram): 20-30 小时（假设有文档）
 - **方案 B** (React Flow): 15-20 小时
 - **方案 C** (渐进式): 10-15 小时初始，后续持续
 ## 下一步建议 (Next Steps Recommendations)
 1. **立即**: 确认是否有 Flowgram 官方文档或示例代码
 2. **短期**: 实现一个简单的节点（如触发器节点）作为 POC
 3. **中期**: 完成所有节点类型和配置面板
 4. **长期**: 重写执行引擎并测试
 ## 技术债务注意 (Technical Debt Notes)
 - 旧的表单数据结构被标记为 deprecated 但仍保留
 - 需要在未来版本中清理
 - 数据库包含两套结构的字段
 ## 联系和协作 (Contact & Collaboration)
 如需加速开发，建议：
 1. 获取 Flowgram 官方支持或文档
 2. 提供 Flowgram 集成的参考示例
 3. 或考虑使用 React Flow 等替代方案
@@ -1,692 +0,0 @@
 # Flowgram Migration Guide - 从 React Flow 迁移到 Flowgram.ai
 ## 概述 (Overview)
 本文档提供从 React Flow 迁移到 Flowgram.ai 的完整指南。
 参考 Demo: https://github.com/bytedance/flowgram.ai/tree/main/apps/demo-free-layout
 ## 1. 依赖安装 (Dependencies Installation)
 ### 已添加的依赖 (Dependencies Added)
 ```json
 {
  "@flowgram.ai/core": "^1.0.2",
  "@flowgram.ai/free-layout-editor": "^1.0.2",
  "@flowgram.ai/reactive": "^1.0.2",
  "@flowgram.ai/free-snap-plugin": "^1.0.2",
  "@flowgram.ai/free-lines-plugin": "^1.0.2",
  "@flowgram.ai/free-node-panel-plugin": "^1.0.2",
  "@flowgram.ai/minimap-plugin": "^1.0.2",
  "@flowgram.ai/free-container-plugin": "^1.0.2",
  "@flowgram.ai/free-group-plugin": "^1.0.2",
  "@flowgram.ai/form-materials": "^1.0.2",
  "@flowgram.ai/panel-manager-plugin": "^1.0.2",
  "@flowgram.ai/free-stack-plugin": "^1.0.2",
  "@flowgram.ai/runtime-interface": "^1.0.2",
  "@flowgram.ai/runtime-js": "^1.0.2",
  "nanoid": "^5.0.9"
 }
 ```
 ### 安装命令 (Installation Command)
 ```bash
 cd /home/runner/work/qinglong/qinglong
 npm install --legacy-peer-deps
 # or
 pnpm install
 ```
 ## 2. 数据结构适配 (Data Structure Adaptation)
 ### 当前 React Flow 格式
 ```typescript
 {
  nodes: [
    {
      id: "trigger-1",
      type: "trigger",
      position: { x: 100, y: 100 },
      data: {
        label: "Webhook Trigger",
        triggerType: "webhook",
        config: {}
      }
    }
  ],
  edges: [
    {
      id: "e1",
      source: "trigger-1",
      target: "condition-1"
    }
  ]
 }
 ```
 ### Flowgram 格式
 ```typescript
 {
  nodes: [
    {
      id: "trigger_1",
      type: "trigger",
      meta: {
        position: { x: 100, y: 100 }
      },
      data: {
        title: "Webhook Trigger",
        triggerType: "webhook",
        config: {},
        // Flowgram 使用 inputs/outputs schema
        outputs: {
          type: "object",
          properties: {
            data: { type: "object" }
          }
        }
      }
    }
  ],
  edges: [
    {
      sourceNodeID: "trigger_1",
      targetNodeID: "condition_1"
    }
  ]
 }
 ```
 ## 3. 节点注册系统 (Node Registry System)
 ### 节点注册接口 (Node Registry Interface)
 ```typescript
 // src/pages/scenario/flowgram/types.ts
 import { FlowNodeRegistry as FlowgramRegistry } from '@flowgram.ai/free-layout-editor';
 export type FlowNodeRegistry = FlowgramRegistry;
 export interface NodeData {
  title: string;
  inputs?: any;
  outputs?: any;
  inputsValues?: any;
  [key: string]: any;
 }
 ```
 ### 创建节点注册 (Create Node Registries)
 #### Start 节点 (src/pages/scenario/flowgram/nodes/start.tsx)
 ```typescript
 import { FlowNodeRegistry } from '../types';
 export const StartNodeRegistry: FlowNodeRegistry = {
  type: 'start',
  meta: {
    category: 'basic',
    label: '开始',
    description: '工作流开始节点',
  },
  data: {
    title: '开始',
    outputs: {
      type: 'object',
      properties: {
        triggerData: {
          type: 'object',
          description: '触发数据',
        },
      },
    },
  },
  formMeta: {
    properties: {
      title: {
        type: 'string',
        title: '标题',
      },
    },
  },
 };
 ```
 #### Trigger 节点 (src/pages/scenario/flowgram/nodes/trigger.tsx)
 ```typescript
 export const TriggerNodeRegistry: FlowNodeRegistry = {
  type: 'trigger',
  meta: {
    category: 'triggers',
    label: '触发器',
    description: '各种触发器类型',
  },
  data: {
    title: '触发器',
    triggerType: 'webhook',
    outputs: {
      type: 'object',
      properties: {
        data: { type: 'object' },
      },
    },
  },
  formMeta: {
    properties: {
      title: {
        type: 'string',
        title: '标题',
      },
      triggerType: {
        type: 'string',
        title: '触发类型',
        enum: ['time', 'webhook', 'variable', 'task_status', 'system_event'],
        enumNames: ['时间触发', 'Webhook', '变量监听', '任务状态', '系统事件'],
      },
      config: {
        type: 'object',
        title: '配置',
        properties: {
          schedule: {
            type: 'string',
            title: 'Cron 表达式',
          },
          filePath: {
            type: 'string',
            title: '文件路径',
          },
        },
      },
    },
  },
 };
 ```
 #### Condition 节点
 ```typescript
 export const ConditionNodeRegistry: FlowNodeRegistry = {
  type: 'condition',
  meta: {
    category: 'logic',
    label: '条件',
    description: '条件判断节点',
  },
  data: {
    title: '条件',
    conditions: [],
    outputs: {
      type: 'object',
      properties: {
        result: { type: 'boolean' },
      },
    },
  },
  formMeta: {
    properties: {
      title: { type: 'string', title: '标题' },
      operator: {
        type: 'string',
        title: '操作符',
        enum: ['equals', 'not_equals', 'greater_than', 'less_than', 'contains', 'not_contains'],
        enumNames: ['等于', '不等于', '大于', '小于', '包含', '不包含'],
      },
      field: { type: 'string', title: '字段名' },
      value: { type: 'string', title: '比较值' },
    },
  },
 };
 ```
 #### Action 节点
 ```typescript
 export const ActionNodeRegistry: FlowNodeRegistry = {
  type: 'action',
  meta: {
    category: 'actions',
    label: '动作',
    description: '执行动作',
  },
  data: {
    title: '动作',
    actionType: 'run_task',
  },
  formMeta: {
    properties: {
      title: { type: 'string', title: '标题' },
      actionType: {
        type: 'string',
        title: '动作类型',
        enum: ['run_task', 'set_variable', 'execute_command', 'send_notification'],
        enumNames: ['运行任务', '设置变量', '执行命令', '发送通知'],
      },
      cronId: { type: 'number', title: '任务 ID' },
      name: { type: 'string', title: '变量名' },
      value: { type: 'string', title: '变量值' },
      command: { type: 'string', title: '命令' },
      message: { type: 'string', title: '消息' },
    },
  },
 };
 ```
 #### Control 节点
 ```typescript
 export const ControlNodeRegistry: FlowNodeRegistry = {
  type: 'control',
  meta: {
    category: 'control',
    label: '控制流',
    description: '控制流节点',
  },
  data: {
    title: '控制流',
    controlType: 'delay',
  },
  formMeta: {
    properties: {
      title: { type: 'string', title: '标题' },
      controlType: {
        type: 'string',
        title: '控制类型',
        enum: ['delay', 'retry', 'circuit_breaker'],
        enumNames: ['延迟', '重试', '熔断器'],
      },
      delaySeconds: { type: 'number', title: '延迟秒数' },
      maxRetries: { type: 'number', title: '最大重试次数' },
      retryDelay: { type: 'number', title: '重试延迟' },
      backoffMultiplier: { type: 'number', title: '退避倍数' },
      failureThreshold: { type: 'number', title: '失败阈值' },
    },
  },
 };
 ```
 #### Logic Gate 节点
 ```typescript
 export const LogicGateNodeRegistry: FlowNodeRegistry = {
  type: 'logic_gate',
  meta: {
    category: 'logic',
    label: '逻辑门',
    description: 'AND/OR 逻辑',
  },
  data: {
    title: '逻辑门',
    gateType: 'AND',
  },
  formMeta: {
    properties: {
      title: { type: 'string', title: '标题' },
      gateType: {
        type: 'string',
        title: '逻辑类型',
        enum: ['AND', 'OR'],
        enumNames: ['AND', 'OR'],
      },
    },
  },
 };
 ```
 #### End 节点
 ```typescript
 export const EndNodeRegistry: FlowNodeRegistry = {
  type: 'end',
  meta: {
    category: 'basic',
    label: '结束',
    description: '工作流结束节点',
  },
  data: {
    title: '结束',
    inputs: {
      type: 'object',
      properties: {
        result: { type: 'any' },
      },
    },
  },
  formMeta: {
    properties: {
      title: { type: 'string', title: '标题' },
    },
  },
 };
 ```
 ## 4. 编辑器组件 (Editor Component)
 ### 主编辑器 (src/pages/scenario/flowgram/Editor.tsx)
 ```typescript
 import React from 'react';
 import { EditorRenderer, FreeLayoutEditorProvider } from '@flowgram.ai/free-layout-editor';
 import '@flowgram.ai/free-layout-editor/index.css';
 import { useEditorProps } from './hooks/useEditorProps';
 import { nodeRegistries } from './nodes';
 interface EditorProps {
  initialData: any;
  onSave: (data: any) => void;
 }
 export const FlowgramEditor: React.FC<EditorProps> = ({ initialData, onSave }) => {
  const editorProps = useEditorProps(initialData, nodeRegistries, onSave);
  return (
    <div style={{ width: '100%', height: '600px' }}>
      <FreeLayoutEditorProvider {...editorProps}>
        <EditorRenderer />
      </FreeLayoutEditorProvider>
    </div>
  );
 };
 ```
 ### 编辑器配置 (src/pages/scenario/flowgram/hooks/useEditorProps.tsx)
 ```typescript
 import { useMemo } from 'react';
 import { FreeLayoutProps } from '@flowgram.ai/free-layout-editor';
 import { createMinimapPlugin } from '@flowgram.ai/minimap-plugin';
 import { createFreeSnapPlugin } from '@flowgram.ai/free-snap-plugin';
 import { createFreeNodePanelPlugin } from '@flowgram.ai/free-node-panel-plugin';
 import { createFreeLinesPlugin } from '@flowgram.ai/free-lines-plugin';
 import { FlowNodeRegistry } from '../types';
 export function useEditorProps(
  initialData: any,
  nodeRegistries: FlowNodeRegistry[],
  onSave: (data: any) => void
 ): FreeLayoutProps {
  return useMemo<FreeLayoutProps>(
    () => ({
      background: true,
      readonly: false,
      twoWayConnection: true,
      initialData,
      nodeRegistries,
      // 节点数据转换
      fromNodeJSON(node, json) {
        return json;
      },
      toNodeJSON(node, json) {
        return json;
      },
      // 连线颜色
      lineColor: {
        default: '#4d53e8',
        drawing: '#5DD6E3',
        hovered: '#37d0ff',
        selected: '#37d0ff',
        error: 'red',
      },
      // 连线规则
      canAddLine(ctx, fromPort, toPort) {
        if (fromPort.node === toPort.node) return false;
        return !fromPort.node.lines.allInputNodes.includes(toPort.node);
      },
      // 内容变化回调
      onContentChange: (ctx, event) => {
        if (ctx.document.disposed) return;
        const data = ctx.document.toJSON();
        onSave(data);
      },
      // 插件
      plugins: () => [
        createMinimapPlugin({}),
        createFreeSnapPlugin({}),
        createFreeNodePanelPlugin({}),
        createFreeLinesPlugin({}),
      ],
    }),
    [initialData, nodeRegistries, onSave]
  );
 }
 ```
 ## 5. 模态框集成 (Modal Integration)
 ### 替换 visualWorkflowModal.tsx
 ```typescript
 // src/pages/scenario/flowgramWorkflowModal.tsx
 import React, { useState, useEffect } from 'react';
 import { Modal } from 'antd';
 import { FlowgramEditor } from './flowgram/Editor';
 import intl from 'react-intl-universal';
 interface FlowgramWorkflowModalProps {
  visible: boolean;
  scenario?: any;
  onOk: (scenario: any) => void;
  onCancel: () => void;
 }
 export const FlowgramWorkflowModal: React.FC<FlowgramWorkflowModalProps> = ({
  visible,
  scenario,
  onOk,
  onCancel,
 }) => {
  const [workflowData, setWorkflowData] = useState<any>(null);
  const [name, setName] = useState('');
  useEffect(() => {
    if (scenario) {
      setName(scenario.name || '');
      setWorkflowData(scenario.workflowGraph || getInitialData());
    } else {
      setName('');
      setWorkflowData(getInitialData());
    }
  }, [scenario, visible]);
  const getInitialData = () => ({
    nodes: [
      {
        id: 'start_0',
        type: 'start',
        meta: { position: { x: 100, y: 300 } },
        data: { title: '开始' },
      },
      {
        id: 'end_0',
        type: 'end',
        meta: { position: { x: 800, y: 300 } },
        data: { title: '结束' },
      },
    ],
    edges: [],
  });
  const handleSave = (data: any) => {
    setWorkflowData(data);
  };
  const handleOk = () => {
    onOk({
      ...scenario,
      name,
      workflowGraph: workflowData,
    });
  };
  return (
    <Modal
      title={scenario ? intl.get('编辑场景') : intl.get('新建场景')}
      open={visible}
      onOk={handleOk}
      onCancel={onCancel}
      width="90%"
      style={{ top: 20 }}
    >
      <div style={{ marginBottom: 16 }}>
        <input
          placeholder="场景名称"
          value={name}
          onChange={(e) => setName(e.target.value)}
          style={{ width: '100%', padding: '8px' }}
        />
      </div>
      {workflowData && (
        <FlowgramEditor
          initialData={workflowData}
          onSave={handleSave}
        />
      )}
    </Modal>
  );
 };
 ```
 ## 6. 在主页面中使用 (Usage in Main Page)
 ### 更新 index.tsx
 ```typescript
 // src/pages/scenario/index.tsx
 import { FlowgramWorkflowModal } from './flowgramWorkflowModal';
 // 替换原来的
 // import { VisualWorkflowModal } from './visualWorkflowModal';
 // 使用
 <FlowgramWorkflowModal
  visible={modalVisible}
  scenario={editingScenario}
  onOk={handleSaveScenario}
  onCancel={() => setModalVisible(false)}
 />
 ```
 ## 7. 后端兼容性 (Backend Compatibility)
 ### 数据转换工具 (Data Conversion)
 ```typescript
 // src/pages/scenario/flowgram/utils/dataConverter.ts
 /**
 * 将 Flowgram 格式转换为后端格式
 */
 export function convertFlowgramToBackend(flowgramData: any) {
  return {
    nodes: flowgramData.nodes.map((node: any) => ({
      id: node.id,
      type: node.type,
      position: node.meta?.position || { x: 0, y: 0 },
      data: node.data,
    })),
    edges: flowgramData.edges.map((edge: any) => ({
      id: `${edge.sourceNodeID}-${edge.targetNodeID}`,
      source: edge.sourceNodeID,
      target: edge.targetNodeID,
      sourcePort: edge.sourcePortID,
    })),
  };
 }
 /**
 * 将后端格式转换为 Flowgram 格式
 */
 export function convertBackendToFlowgram(backendData: any) {
  return {
    nodes: backendData.nodes.map((node: any) => ({
      id: node.id,
      type: node.type,
      meta: {
        position: node.position,
      },
      data: node.data,
    })),
    edges: backendData.edges.map((edge: any) => ({
      sourceNodeID: edge.source,
      targetNodeID: edge.target,
      sourcePortID: edge.sourcePort,
    })),
  };
 }
 ```
 ## 8. CSS 样式 (Styles)
 ### 导入 Flowgram 样式
 ```typescript
 // src/pages/scenario/flowgram/Editor.tsx
 import '@flowgram.ai/free-layout-editor/index.css';
 // 自定义样式
 const customStyles = `
  .flowgram-editor {
    width: 100%;
    height: 600px;
    border: 1px solid #d9d9d9;
    border-radius: 4px;
  }
 `;
 ```
 ## 9. 测试清单 (Testing Checklist)
 - [ ] 依赖安装成功
 - [ ] 节点可以正常创建和拖拽
 - [ ] 节点可以连接
 - [ ] 节点配置面板正常显示
 - [ ] 保存功能正常
 - [ ] 与后端图执行引擎兼容
 - [ ] 可以编辑现有场景
 - [ ] 所有节点类型都可用
 ## 10. 故障排查 (Troubleshooting)
 ### 常见问题
 **Q: Flowgram 插件包无法安装**
 A: 使用 `npm install --legacy-peer-deps` 或 `pnpm install`
 **Q: TypeScript 类型错误**
 A: 添加类型声明文件或使用 `// @ts-ignore`
 **Q: 样式不显示**
 A: 确保导入了 `@flowgram.ai/free-layout-editor/index.css`
 **Q: 节点不显示**
 A: 检查节点注册是否正确，formMeta 是否完整
 ## 11. 参考资源 (Resources)
 - Flowgram 官方 Demo: https://github.com/bytedance/flowgram.ai/tree/main/apps/demo-free-layout
 - Flowgram 文档: https://flowgram.ai/
 - 当前实现: src/pages/scenario/visualWorkflowModal.tsx (React Flow 版本)
 ## 总结 (Summary)
 这个迁移涉及：
 1. 替换依赖包（React Flow -> Flowgram）
 2. 重写节点注册系统
 3. 重新实现编辑器组件
 4. 适配数据格式
 5. 保持后端兼容性
 预计工作量：8-12 小时
 难度：中等
 风险：中等（主要是 Flowgram 文档不完整）
@@ -1,352 +0,0 @@
 # 场景模式实现总结 (Scenario Mode Implementation Summary)
 ## 📊 实现统计 (Implementation Statistics)
 - **新增文件**: 8 个 (8 new files)
 - **修改文件**: 6 个 (6 modified files)
 - **代码行数**: ~2,100 行新增代码 (~2,100 lines of new code)
 - **功能数量**: 5 种触发器 + 4 种动作 (5 triggers + 4 actions)
 - **语言支持**: 中文 + 英文 (Chinese + English)
 ## 🎯 核心功能实现 (Core Features Implemented)
 ### 1. 数据模型 (Data Models)
 ```
 back/data/scenario.ts       - 场景数据模型 (117 lines)
 back/data/scenarioLog.ts    - 日志数据模型 (58 lines)
 ```
 **特性**:
 - 完整的场景配置存储
 - 触发器、条件、动作的灵活配置
 - 执行统计和状态跟踪
 - 详细的日志记录
 ### 2. 后端服务 (Backend Service)
 ```
 back/services/scenario.ts   - 场景服务 (501 lines)
 ```
 **核心功能**:
 - ✅ 场景生命周期管理（创建、更新、删除）
 - ✅ 5 种触发器实现
 - ✅ 条件评估引擎
 - ✅ 动作执行引擎
 - ✅ 失败熔断机制
 - ✅ 自适应重试策略
 - ✅ 完整的日志系统
 ### 3. API 接口 (API Endpoints)
 ```
 back/api/scenario.ts        - REST API (214 lines)
 ```
 **端点列表**:
 - `GET /api/scenarios` - 获取场景列表
 - `POST /api/scenarios` - 创建场景
 - `PUT /api/scenarios` - 更新场景
 - `DELETE /api/scenarios` - 删除场景
 - `POST /api/scenarios/:id/trigger` - 手动触发
 - `GET /api/scenarios/:id/webhook` - 获取 Webhook URL
 - `GET /api/scenarios/logs` - 查询日志
 - `POST /api/scenarios/webhook/:token` - Webhook 触发
 ### 4. 前端界面 (Frontend UI)
 ```
 src/pages/scenario/index.tsx    - 主页面 (318 lines)
 src/pages/scenario/modal.tsx    - 编辑器 (443 lines)
 src/pages/scenario/logModal.tsx - 日志查看 (130 lines)
 ```
 **界面功能**:
 - 📋 场景列表管理
 - ✏️ 可视化场景编辑器
 - 🔧 动态触发器配置
 - 🧩 条件构建器 (AND/OR)
 - ⚡ 动作配置器
 - 📊 执行统计展示
 - 📝 日志查看器
 - 🔗 Webhook 管理
 ### 5. 国际化支持 (i18n)
 ```
 src/locales/zh-CN.json      - 中文翻译 (+72 entries)
 src/locales/en-US.json      - 英文翻译 (+72 entries)
 ```
 ## 🔧 技术架构 (Technical Architecture)
 ```
 ┌─────────────────────────────────────────────────────────┐
 │                    前端层 (Frontend)                     │
 ├─────────────────────────────────────────────────────────┤
 │  场景列表    │   场景编辑器   │   日志查看器           │
 │  (List)     │   (Editor)    │   (Log Viewer)         │
 └─────────────────────────────────────────────────────────┘
                        ↕ HTTP API
 ┌─────────────────────────────────────────────────────────┐
 │                   API 层 (API Layer)                    │
 ├─────────────────────────────────────────────────────────┤
 │  场景管理    │   手动触发    │   Webhook     │  日志   │
 │  (CRUD)     │   (Trigger)  │   (External)  │  (Logs) │
 └─────────────────────────────────────────────────────────┘
                        ↕ Service Layer
 ┌─────────────────────────────────────────────────────────┐
 │                 服务层 (Service Layer)                  │
 ├─────────────────────────────────────────────────────────┤
 │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
 │  │ 触发器管理   │  │ 条件评估引擎 │  │ 动作执行引擎 │ │
 │  │ (Triggers)   │  │ (Conditions) │  │  (Actions)   │ │
 │  └──────────────┘  └──────────────┘  └──────────────┘ │
 │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
 │  │ 失败熔断     │  │ 重试策略     │  │ 日志记录     │ │
 │  │ (Breaker)    │  │ (Retry)      │  │ (Logging)    │ │
 │  └──────────────┘  └──────────────┘  └──────────────┘ │
 └─────────────────────────────────────────────────────────┘
                        ↕ Data Layer
 ┌─────────────────────────────────────────────────────────┐
 │                  数据层 (Data Layer)                    │
 ├─────────────────────────────────────────────────────────┤
 │  Scenario 表        │       ScenarioLog 表              │
 │  (场景配置)         │       (执行日志)                   │
 └─────────────────────────────────────────────────────────┘
 ```
 ## 🎨 触发器详解 (Trigger Details)
 ### 1. Variable Monitor (变量监听)
 ```javascript
 {
  triggerType: 'variable',
  triggerConfig: {
    watchPath: '/path/to/watch'
  }
 }
 ```
 **工作原理**: 使用 chokidar 监控文件系统变化
 ### 2. Webhook Trigger (Webhook 触发)
 ```javascript
 {
  triggerType: 'webhook',
  triggerConfig: {
    token: 'auto-generated-or-custom'
  }
 }
 ```
 **工作原理**: 生成唯一 Token，通过 HTTP POST 接收触发
 ### 3. Task Status Trigger (任务状态)
 ```javascript
 {
  triggerType: 'task_status',
  triggerConfig: {
    cronId: 123,
    status: 'success' // or 'failure'
  }
 }
 ```
 **工作原理**: 监听定时任务执行结果
 ### 4. Time Trigger (时间触发)
 ```javascript
 {
  triggerType: 'time',
  triggerConfig: {
    schedule: '0 0 * * *'  // Cron expression
  }
 }
 ```
 **工作原理**: 使用 Cron 表达式定时触发
 ### 5. System Event Trigger (系统事件)
 ```javascript
 {
  triggerType: 'system_event',
  triggerConfig: {
    eventType: 'disk_space', // or 'memory'
    threshold: 80,            // percentage
    checkInterval: 60000      // milliseconds
  }
 }
 ```
 **工作原理**: 定期检查系统资源使用率
 ## 🧩 条件逻辑示例 (Condition Logic Examples)
 ### AND 逻辑（全部满足）
 ```json
 {
  "conditionLogic": "AND",
  "conditions": [
    { "field": "status", "operator": "equals", "value": "success" },
    { "field": "branch", "operator": "equals", "value": "main" }
  ]
 }
 ```
 ### OR 逻辑（任一满足）
 ```json
 {
  "conditionLogic": "OR",
  "conditions": [
    { "field": "branch", "operator": "equals", "value": "main" },
    { "field": "branch", "operator": "equals", "value": "develop" }
  ]
 }
 ```
 ### 支持的操作符
 - `equals` - 等于
 - `not_equals` - 不等于
 - `greater_than` - 大于
 - `less_than` - 小于
 - `contains` - 包含
 - `not_contains` - 不包含
 ## ⚡ 动作类型详解 (Action Types)
 ### 1. Run Task (运行任务)
 ```json
 {
  "type": "run_task",
  "cronId": 123
 }
 ```
 ### 2. Set Variable (设置变量)
 ```json
 {
  "type": "set_variable",
  "name": "DEPLOY_STATUS",
  "value": "completed"
 }
 ```
 ### 3. Execute Command (执行命令)
 ```json
 {
  "type": "execute_command",
  "command": "rm -rf /tmp/cache/*"
 }
 ```
 ### 4. Send Notification (发送通知)
 ```json
 {
  "type": "send_notification",
  "message": "Deployment completed successfully"
 }
 ```
 ## 🛡️ 可靠性机制 (Reliability Mechanisms)
 ### 失败熔断 (Circuit Breaker)
 ```javascript
 {
  failureThreshold: 3,  // 连续失败 3 次后自动禁用
  consecutiveFailures: 0 // 当前连续失败次数
 }
 ```
 ### 自适应重试 (Adaptive Retry)
 ```javascript
 {
  retryStrategy: {
    maxRetries: 3,          // 最多重试 3 次
    retryDelay: 5,          // 基础延迟 5 秒
    backoffMultiplier: 2    // 每次延迟翻倍
  }
 }
 // 重试延迟: 5s, 10s, 20s
 ```
 ### 延迟执行 (Delayed Execution)
 ```javascript
 {
  delayExecution: 30  // 触发后延迟 30 秒执行
 }
 ```
 ## 📈 统计信息 (Statistics)
 每个场景实时跟踪：
 - `executionCount` - 总执行次数
 - `successCount` - 成功次数
 - `failureCount` - 失败次数
 - `consecutiveFailures` - 连续失败次数
 - `lastTriggeredAt` - 最后触发时间
 - `lastExecutedAt` - 最后执行时间
 ## 🔍 日志系统 (Logging System)
 每次执行记录：
 - 触发数据 (`triggerData`)
 - 条件匹配结果 (`conditionsMatched`)
 - 执行状态 (`executionStatus`: success/failure/partial)
 - 执行详情 (`executionDetails`)
 - 错误信息 (`errorMessage`)
 - 执行耗时 (`executionTime`)
 - 重试次数 (`retriesAttempted`)
 - 创建时间 (`createdAt`)
 ## 🎯 使用场景示例 (Use Case Examples)
 ### 场景 1: 配置文件自动重载
 ```
 触发器: Variable Monitor
  - 监听: /config/app.json
 条件: 无
 动作: 
  1. Execute Command - "pm2 reload app"
  2. Send Notification - "配置已更新并重载"
 ```
 ### 场景 2: CI/CD 集成
 ```
 触发器: Webhook
 条件: 
  - event = "deployment" AND
  - status = "success" AND
  - branch = "main"
 动作:
  1. Run Task - 执行部署后清理任务
  2. Set Variable - LAST_DEPLOY_TIME = ${timestamp}
 ```
 ### 场景 3: 磁盘空间告警
 ```
 触发器: System Event
  - 事件类型: disk_space
  - 阈值: 85%
 条件: 无
 动作:
  1. Execute Command - "清理临时文件"
  2. Send Notification - "磁盘空间不足，已自动清理"
 ```
 ### 场景 4: 任务失败自动重试
 ```
 触发器: Task Status
  - 任务 ID: 123
  - 状态: failure
 条件: 无
 动作:
  1. Run Task - 重新执行任务 123
 高级设置:
  - 延迟执行: 300 秒
  - 失败熔断: 3 次
 ```
 ## 📝 总结 (Summary)
 场景模式功能为青龙面板提供了强大的自动化能力：
 ✅ **完整实现** - 从数据模型到前端界面全栈实现
 ✅ **灵活配置** - 5 种触发器和 4 种动作满足各种需求
 ✅ **可靠稳定** - 失败熔断、重试机制确保系统稳定
 ✅ **易于使用** - 可视化配置，无需编写代码
 ✅ **完善文档** - 详细的使用指南和 API 文档
 ✅ **国际化** - 完整的中英文支持
 这个功能将青龙面板从简单的定时任务管理工具升级为智能的自动化运维中枢！
@@ -0,0 +1,92 @@
 # 安装说明
 ## 前置要求
 ```bash
 1.已安装docker-ce
 2.选装docker-compose
 ```
 ## 安装方式1
 ```bash
 1. 新建一个文件夹，用于存放相关数据
 2. 下载本仓库中的`docker-compose.yml`至本地，或是复制文件内容后在本地自行建立并粘贴内容
 3. 使用docker-compose启动
 4. 浏览器输入ip:5700即可进入面板
 # 新建数据文件夹
 mkdir qinglong
 cd qinglong
 # 下载docker-compose.yml文件
 wget https://raw.githubusercontent.com/whyour/qinglong/develop/docker-compose.yml
 # 启动
 docker-compose up -d
 ```
 ## 安装方式2
 ```bash
 # 复制下列命令在ssh执行(先安装docker)
 # 注:$PWD请修改为实际你想安装的路径
 docker run -dit \
   -v $PWD/ql/config:/ql/config \
   -v $PWD/ql/log:/ql/log \
   -v $PWD/ql/db:/ql/db \
   -v $PWD/ql/repo:/ql/repo \
   -v $PWD/ql/raw:/ql/raw \
   -v $PWD/ql/scripts:/ql/scripts \
   -v $PWD/ql/jbot:/ql/jbot \
   -p 5700:5700 \
   --name qinglong \
   --hostname qinglong \
   --restart unless-stopped \
   whyour/qinglong:latest
 ```
 ## 登录
 ```bash
 打开浏览器访问宿主机ip的5700端口即可
 例如http://192.168.100.123:5700即ip:5700
 首次登录
 账号:admin 密码:admin
 会生成`auth.json`
 在ssh输入 
 1.docker exec -it qinglong bash
 2.cat /ql/config/auth.json
 cat查看之后返回的结果类似如下字段
 {"username":"admin","password":"Xb-ZYP526wmg4_h6q1WqIO"}
 # admin即为登录名;Xb-ZYP526wmg4_h6q1WqIO为登录密码
 ```
 输入此处记录的`username`及`password`，即可成功登录qinglong面板，登录后即可正常使用
 ## 拉取脚本
 ```bash
 示例
 ql repo https://github.com/xxx.git #拉取仓库
 ql raw https://raw.githubusercontent.com/xxx #拉取单个脚本
 ```
 ## 备份
 所有数据都将保存在`docker-compose.yml`所在的同级目录的`data`文件夹中，如需要备份，请直接备份`docker-compose.yml`及`data`文件夹即可
 ```bash
 root@debian:/opt/qinglong# ls -lah
 总用量 8.0K
 drwxr-xr-x 3 root root 4.0K  8月 30 01:29 .
 drwxr-xr-x 4 root root 4.0K  8月 30 00:51 ..
 drwxr-xr-x 8 root root 4.0K  8月 30 01:30 data
 -rw-r--r-- 1 root root  386  8月 30 01:29 docker-compose.yml
 ```
 ## 更新
 在面板执行"更新面板"任务即可
 或者
 ```bash
 cd qinglong
 docker-compose down
 docker pull whyour/qinglong:latest
 docker-compose up -d
 ```
@@ -1,201 +1,22 @@
-                              Apache License
+MIT LICENSE
                        Version 2.0, January 2004
                    http://www.apache.org/licenses/
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+Copyright (c) 2021-present whyour
-1. Definitions.
+Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
 "Software"), to deal in the Software without restriction, including
 without limitation the rights to use, copy, modify, merge, publish,
 distribute, sublicense, and/or sell copies of the Software, and to
 permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
-  "License" shall mean the terms and conditions for use, reproduction,
+The above copyright notice and this permission notice shall be
-  and distribution as defined by Sections 1 through 9 of this document.
+included in all copies or substantial portions of the Software.
-  "Licensor" shall mean the copyright owner or entity authorized by
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  the copyright owner that is granting the License.
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  "Legal Entity" shall mean the union of the acting entity and all
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-  other entities that control, are controlled by, or are under common
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-  control with that entity. For the purposes of this definition,
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-  "control" means (i) the power, direct or indirect, to cause the
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  direction or management of such entity, whether by contract or
  otherwise, or (ii) ownership of fifty percent (50%) or more of the
  outstanding shares, or (iii) beneficial ownership of such entity.
  "You" (or "Your") shall mean an individual or Legal Entity
  exercising permissions granted by this License.
  "Source" form shall mean the preferred form for making modifications,
  including but not limited to software source code, documentation
  source, and configuration files.
  "Object" form shall mean any form resulting from mechanical
  transformation or translation of a Source form, including but
  not limited to compiled object code, generated documentation,
  and conversions to other media types.
  "Work" shall mean the work of authorship, whether in Source or
  Object form, made available under the License, as indicated by a
  copyright notice that is included in or attached to the work
  (an example is provided in the Appendix below).
  "Derivative Works" shall mean any work, whether in Source or Object
  form, that is based on (or derived from) the Work and for which the
  editorial revisions, annotations, elaborations, or other modifications
  represent, as a whole, an original work of authorship. For the purposes
  of this License, Derivative Works shall not include works that remain
  separable from, or merely link (or bind by name) to the interfaces of,
  the Work and Derivative Works thereof.
  "Contribution" shall mean any work of authorship, including
  the original version of the Work and any modifications or additions
  to that Work or Derivative Works thereof, that is intentionally
  submitted to Licensor for inclusion in the Work by the copyright owner
  or by an individual or Legal Entity authorized to submit on behalf of
  the copyright owner. For the purposes of this definition, "submitted"
  means any form of electronic, verbal, or written communication sent
  to the Licensor or its representatives, including but not limited to
  communication on electronic mailing lists, source code control systems,
  and issue tracking systems that are managed by, or on behalf of, the
  Licensor for the purpose of discussing and improving the Work, but
  excluding communication that is conspicuously marked or otherwise
  designated in writing by the copyright owner as "Not a Contribution."
  "Contributor" shall mean Licensor and any individual or Legal Entity
  on behalf of whom a Contribution has been received by Licensor and
  subsequently incorporated within the Work.
 2. Grant of Copyright License. Subject to the terms and conditions of
  this License, each Contributor hereby grants to You a perpetual,
  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
  copyright license to reproduce, prepare Derivative Works of,
  publicly display, publicly perform, sublicense, and distribute the
  Work and such Derivative Works in Source or Object form.
 3. Grant of Patent License. Subject to the terms and conditions of
  this License, each Contributor hereby grants to You a perpetual,
  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
  (except as stated in this section) patent license to make, have made,
  use, offer to sell, sell, import, and otherwise transfer the Work,
  where such license applies only to those patent claims licensable
  by such Contributor that are necessarily infringed by their
  Contribution(s) alone or by combination of their Contribution(s)
  with the Work to which such Contribution(s) was submitted. If You
  institute patent litigation against any entity (including a
  cross-claim or counterclaim in a lawsuit) alleging that the Work
  or a Contribution incorporated within the Work constitutes direct
  or contributory patent infringement, then any patent licenses
  granted to You under this License for that Work shall terminate
  as of the date such litigation is filed.
 4. Redistribution. You may reproduce and distribute copies of the
  Work or Derivative Works thereof in any medium, with or without
  modifications, and in Source or Object form, provided that You
  meet the following conditions:
  (a) You must give any other recipients of the Work or
      Derivative Works a copy of this License; and
  (b) You must cause any modified files to carry prominent notices
      stating that You changed the files; and
  (c) You must retain, in the Source form of any Derivative Works
      that You distribute, all copyright, patent, trademark, and
      attribution notices from the Source form of the Work,
      excluding those notices that do not pertain to any part of
      the Derivative Works; and
  (d) If the Work includes a "NOTICE" text file as part of its
      distribution, then any Derivative Works that You distribute must
      include a readable copy of the attribution notices contained
      within such NOTICE file, excluding those notices that do not
      pertain to any part of the Derivative Works, in at least one
      of the following places: within a NOTICE text file distributed
      as part of the Derivative Works; within the Source form or
      documentation, if provided along with the Derivative Works; or,
      within a display generated by the Derivative Works, if and
      wherever such third-party notices normally appear. The contents
      of the NOTICE file are for informational purposes only and
      do not modify the License. You may add Your own attribution
      notices within Derivative Works that You distribute, alongside
      or as an addendum to the NOTICE text from the Work, provided
      that such additional attribution notices cannot be construed
      as modifying the License.
  You may add Your own copyright statement to Your modifications and
  may provide additional or different license terms and conditions
  for use, reproduction, or distribution of Your modifications, or
  for any such Derivative Works as a whole, provided Your use,
  reproduction, and distribution of the Work otherwise complies with
  the conditions stated in this License.
 5. Submission of Contributions. Unless You explicitly state otherwise,
  any Contribution intentionally submitted for inclusion in the Work
  by You to the Licensor shall be under the terms and conditions of
  this License, without any additional terms or conditions.
  Notwithstanding the above, nothing herein shall supersede or modify
  the terms of any separate license agreement you may have executed
  with Licensor regarding such Contributions.
 6. Trademarks. This License does not grant permission to use the trade
  names, trademarks, service marks, or product names of the Licensor,
  except as required for reasonable and customary use in describing the
  origin of the Work and reproducing the content of the NOTICE file.
 7. Disclaimer of Warranty. Unless required by applicable law or
  agreed to in writing, Licensor provides the Work (and each
  Contributor provides its Contributions) on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  implied, including, without limitation, any warranties or conditions
  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
  PARTICULAR PURPOSE. You are solely responsible for determining the
  appropriateness of using or redistributing the Work and assume any
  risks associated with Your exercise of permissions under this License.
 8. Limitation of Liability. In no event and under no legal theory,
  whether in tort (including negligence), contract, or otherwise,
  unless required by applicable law (such as deliberate and grossly
  negligent acts) or agreed to in writing, shall any Contributor be
  liable to You for damages, including any direct, indirect, special,
  incidental, or consequential damages of any character arising as a
  result of this License or out of the use or inability to use the
  Work (including but not limited to damages for loss of goodwill,
  work stoppage, computer failure or malfunction, or any and all
  other commercial damages or losses), even if such Contributor
  has been advised of the possibility of such damages.
 9. Accepting Warranty or Additional Liability. While redistributing
  the Work or Derivative Works thereof, You may choose to offer,
  and charge a fee for, acceptance of support, warranty, indemnity,
  or other liability obligations and/or rights consistent with this
  License. However, in accepting such obligations, You may act only
  on Your own behalf and on Your sole responsibility, not on behalf
  of any other Contributor, and only if You agree to indemnify,
  defend, and hold each Contributor harmless for any liability
  incurred by, or claims asserted against, such Contributor by reason
  of your accepting any such warranty or additional liability.
 END OF TERMS AND CONDITIONS
 APPENDIX: How to apply the Apache License to your work.
  To apply the Apache License to your work, attach the following
  boilerplate notice, with the fields enclosed by brackets "{}"
  replaced with your own identifying information. (Don't include
  the brackets!)  The text should be enclosed in the appropriate
  comment syntax for the file format. We also recommend that a
  file or class name and description of purpose be included on the
  same "printed page" as the copyright notice for easier
  identification within third-party archives.
 Copyright 2021 WHYOUR <https://github.com/whyour>.
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
    http://www.apache.org/licenses/LICENSE-2.0
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
@@ -1,99 +0,0 @@
 <div align="center">
 <img width="100" src="https://user-images.githubusercontent.com/22700758/191449379-f9f56204-0e31-4a16-be5a-331f52696a73.png">
 <h1 align="center">Qinglong</h1>
 [简体中文](./README.md) | English
 Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 [![npm version][npm-version-image]][npm-version-url] [![docker pulls][docker-pulls-image]][docker-pulls-url] [![docker stars][docker-stars-image]][docker-stars-url] [![docker image size][docker-image-size-image]][docker-image-size-url]
 [npm-version-image]: https://img.shields.io/npm/v/@whyour/qinglong?style=flat
 [npm-version-url]: https://www.npmjs.com/package/@whyour/qinglong?activeTab=readme
 [docker-pulls-image]: https://img.shields.io/docker/pulls/whyour/qinglong?style=flat
 [docker-pulls-url]: https://hub.docker.com/r/whyour/qinglong
 [docker-stars-image]: https://img.shields.io/docker/stars/whyour/qinglong?style=flat
 [docker-stars-url]: https://hub.docker.com/r/whyour/qinglong
 [docker-image-size-image]: https://img.shields.io/docker/image-size/whyour/qinglong?style=flat
 [docker-image-size-url]: https://hub.docker.com/r/whyour/qinglong
 [Demo](http://demo.qinglong.online:4433/) / [Issues](https://github.com/whyour/qinglong/issues) / [Telegram Channel](https://t.me/jiao_long) / [Buy Me a Coffee](https://www.buymeacoffee.com/qinglong)
 [演示](http://demo.qinglong.online:4433/) / [反馈](https://github.com/whyour/qinglong/issues) / [Telegram 频道](https://t.me/jiao_long) / [打赏开发者](https://user-images.githubusercontent.com/22700758/244744295-29cd0cd1-c8bb-4ea1-adf6-29bd390ad4dd.jpg)
 </div>
 ![cover](https://user-images.githubusercontent.com/22700758/244847235-8dc1ca21-e03f-4606-9458-0541fab60413.png)
 ## Features
 - Support for multiple scripting languages (python3, javaScript, shell, typescript)
 - Support online management of scripts, environment variables, configuration files
 - Support online view task log
 - Support second-level task setting
 - Support system level notification
 - Support dark mode
 - Support cell phone operation
 ## Version
 ### docker
 The `latest` image is built on `alpine` and the `debian` image is built on `debian-slim`. If you need to use a dependency that is not supported by `alpine`, it is recommended that you use the `debian` image.
 ```bash
 docker pull whyour/qinglong:latest
 docker pull whyour/qinglong:debian
 ```
 ### npm
 The npm version supports `debian/ubuntu/alpine` systems and requires `node/npm/python3/pip3/pnpm` to be installed.
 ```bash
 npm i @whyour/qinglong
 ```
 ## Deployment
 [View Documentation](https://qinglong.online/guide/getting-started/installation-guide)
 ## Built-in API
 [View Documentation](https://qinglong.online/guide/user-guide/built-in-api)
 ## Built-in commands
 [View Documentation](https://qinglong.online/guide/user-guide/basic-explanation)
 ## Development
 ```bash
 git clone https://github.com/whyour/qinglong.git
 cd qinglong
 cp .env.example .env
 # Recommended use pnpm https://pnpm.io/zh/installation
 npm install -g pnpm@8.3.1
 pnpm install
 pnpm start
 ```
 Open your browser and visit <http://127.0.0.1:5700>
 ## Links
 - [nevinee](https://gitee.com/evine)
 - [crontab-ui](https://github.com/alseambusher/crontab-ui)
 - [Ant Design](https://ant.design)
 - [Ant Design Pro](https://pro.ant.design/)
 - [Umijs](https://umijs.org)
 - [darkreader](https://github.com/darkreader/darkreader)
 - [admin-server](https://github.com/sunpu007/admin-server)
 ## Name Origin
 The Green Dragon, also known as the Canglong, is one of the four elephants and one of the [four spirits of the heavens](https://zh.wikipedia.org/wiki/%E5%A4%A9%E4%B9%8B%E5%9B%9B%E7%81%B5) in traditional Chinese culture. According to the Five Elements, it is a spirit animal representing the East as a green dragon, the five elements are wood, and the season represented is spring, with the eight trigrams dominating vibration. Like the Ying Long, the Cang Long has feathered wings. According to the Zhang Guo Xing Zong (Zhang Guo Xing Zong), "a true dragon is one that has complementary wings".
 In the Book of the Later Han Dynasty (後漢書-律曆志下), it is written: "The sun is in the sky, a cold and a summer, the four seasons are ready, all things are changed, the regency moves, and the green dragon moves to the star, which is called the year. (The Year of the Star)
 Among the [twenty-eight Chinese constellations](https://zh.wikipedia.org/wiki/%E4%BA%8C%E5%8D%81%E5%85%AB%E5%AE%BF), the Green Dragon is the generic name for the seven eastern constellations (Horn, Hyper, Diao, Fang, Heart, Tail and Minchi). It is known in Taoism as "Mengzhang" and in different Taoist scriptures as "Dijun", "Shengjian", "Shenjian" and He is also known in different Daoist scriptures as "Dijun", "Shengjun", "Shenjun" and "Ghost Catcher"[1], and is the guardian deity of Daoism, together with the White Tiger Supervisor of Soldiers.
@@ -1,101 +1,54 @@
-<div align="center">
+<p align="center">
-<img width="100" src="https://user-images.githubusercontent.com/22700758/191449379-f9f56204-0e31-4a16-be5a-331f52696a73.png">
+  <a href="https://github.com/whyour/qinglong">
    <img width="150" src="/public/images/qinglong.png">
  </a>
 </p>
 <h1 align="center">青龙</h1>
-简体中文 | [English](./README-en.md)
+<div align="center">
-支持 Python3、JavaScript、Shell、Typescript 的定时任务管理平台
+A timed task management panel that supports typescript, javaScript, python3, and shell.（支持python3、javaScript、shell、typescript 的定时任务管理面板）
-Timed task management platform supporting Python3, JavaScript, Shell, Typescript
+[![docker version][docker-version-image]][docker-version-url] [![docker pulls][docker-pulls-image]][docker-pulls-url] [![docker stars][docker-stars-image]][docker-stars-url] [![docker image size][docker-image-size-image]][docker-image-size-url] [![donate][donate-image]][donate-url]
-[![npm version][npm-version-image]][npm-version-url] [![docker pulls][docker-pulls-image]][docker-pulls-url] [![docker stars][docker-stars-image]][docker-stars-url] [![docker image size][docker-image-size-image]][docker-image-size-url]
+[donate-image]: https://img.shields.io/badge/donate-wechat-green?style=flat
-
+[donate-url]: https://qinglong.whyour.cn/nice.png
 [npm-version-image]: https://img.shields.io/npm/v/@whyour/qinglong?style=flat
 [npm-version-url]: https://www.npmjs.com/package/@whyour/qinglong?activeTab=readme
 [docker-pulls-image]: https://img.shields.io/docker/pulls/whyour/qinglong?style=flat
 [docker-pulls-url]: https://hub.docker.com/r/whyour/qinglong
 [docker-version-image]: https://img.shields.io/docker/v/whyour/qinglong?style=flat
 [docker-version-url]: https://hub.docker.com/r/whyour/qinglong/tags?page=1&ordering=last_updated
 [docker-stars-image]: https://img.shields.io/docker/stars/whyour/qinglong?style=flat
 [docker-stars-url]: https://hub.docker.com/r/whyour/qinglong
 [docker-image-size-image]: https://img.shields.io/docker/image-size/whyour/qinglong?style=flat
 [docker-image-size-url]: https://hub.docker.com/r/whyour/qinglong
 [Demo](http://demo.qinglong.online:4433/) / [Issues](https://github.com/whyour/qinglong/issues) / [Telegram Channel](https://t.me/jiao_long) / [Buy Me a Coffee](https://www.buymeacoffee.com/qinglong)
 [演示](http://demo.qinglong.online:4433/) / [反馈](https://github.com/whyour/qinglong/issues) / [Telegram 频道](https://t.me/jiao_long) / [打赏开发者](https://user-images.githubusercontent.com/22700758/244744295-29cd0cd1-c8bb-4ea1-adf6-29bd390ad4dd.jpg)
 </div>
-![cover](https://user-images.githubusercontent.com/22700758/244847235-8dc1ca21-e03f-4606-9458-0541fab60413.png)
+<p align="center">
-
+  <img width="49%" src="/public/images/login.png">
-## 功能
+  <img width="49%" src="/public/images/home.png">
-
+</p>
 - 支持多种脚本语言（python3、javaScript、shell、typescript）
 - 支持在线管理脚本、环境变量、配置文件
 - 支持在线查看任务日志
 - 支持秒级任务设置
 - 支持系统级通知
 - 支持暗黑模式
 - 支持手机端操作
 ## 版本
 ### docker
 `latest` 镜像是基于 `alpine` 构建，`debian` 镜像是基于 `debian-slim` 构建。如果需要使用 `alpine` 不支持的依赖，建议使用 `debian` 镜像
 ```bash
 docker pull whyour/qinglong:latest
 docker pull whyour/qinglong:debian
 ```
 ### npm
 npm 版本支持 `debian/ubuntu/alpine` 系统，需要自行安装 `node/npm/python3/pip3/pnpm`
 ```bash
 npm i @whyour/qinglong
 ```
 ## 部署
 [查看文档](https://qinglong.online/guide/getting-started/installation-guide)
 ## 内置 API
 [查看文档](https://qinglong.online/guide/user-guide/built-in-api)
 ## 内置命令
 [查看文档](https://qinglong.online/guide/user-guide/basic-explanation)
 ## 开发
 ```bash
 git clone https://github.com/whyour/qinglong.git
 cd qinglong
 cp .env.example .env
 # 推荐使用 pnpm https://pnpm.io/zh/installation
 npm install -g pnpm@8.3.1
 pnpm install
 pnpm start
 ```
 打开你的浏览器，访问 <http://127.0.0.1:5700>
 ## 链接
 - [nevinee](https://gitee.com/evine)
 - [crontab-ui](https://github.com/alseambusher/crontab-ui)
 - [Ant Design](https://ant.design)
 - [Ant Design Pro](https://pro.ant.design/)
 - [Umijs](https://umijs.org)
 - [darkreader](https://github.com/darkreader/darkreader)
 - [admin-server](https://github.com/sunpu007/admin-server)
 ## 名称来源
 青龙，又名苍龙，在中国传统文化中是四象之一、[天之四灵](https://zh.wikipedia.org/wiki/%E5%A4%A9%E4%B9%8B%E5%9B%9B%E7%81%B5)之一，根据五行学说，它是代表东方的灵兽，为青色的龙，五行属木，代表的季节是春季，八卦主震。苍龙与应龙一样，都是身具羽翼。《张果星宗》称“又有辅翼，方为真龙”。
 《后汉书·律历志下》记载：日周于天，一寒一暑，四时备成，万物毕改，摄提迁次，青龙移辰，谓之岁。
 在中国[二十八宿](https://zh.wikipedia.org/wiki/%E4%BA%8C%E5%8D%81%E5%85%AB%E5%AE%BF)中，青龙是东方七宿（角、亢、氐、房、心、尾、箕）的总称。 在早期星宿信仰中，祂是最尊贵的天神。 但被道教信仰吸纳入其神系后，神格大跌，道教将其称为“孟章”，在不同的道经中有“帝君”、“圣将”、“神将”和“捕鬼将”等称呼，与白虎监兵神君一起，是道教的护卫天神。
 ## 如何安装
 请查看[INSTALL.md](INSTALL.md)
 ## 多谢
 * [nevinee](https://gitee.com/evine)
 * [crontab-ui](https://github.com/alseambusher/crontab-ui)
 * [Ant Design](https://ant.design)
 * [Ant Design Pro](https://pro.ant.design/)
 * [Umijs3.0](https://umijs.org)
 * [darkreader](https://github.com/darkreader/darkreader)
@@ -1,295 +0,0 @@
 # 场景模式功能文档 (Scenario Mode Documentation)
 ## 概述 (Overview)
 场景模式是青龙面板的一个强大功能扩展，支持基于条件的自动化工作流。通过场景模式，您可以创建智能的自动化任务，响应各种触发器并执行相应的动作。
 Scenario Mode is a powerful feature extension for Qinglong panel, supporting conditional automated workflows. With Scenario Mode, you can create intelligent automation tasks that respond to various triggers and execute corresponding actions.
 ## 功能特性 (Features)
 ### 1. 多样化触发器 (Diverse Triggers)
 #### 变量监听 (Variable Monitor)
 - 监控指定路径的文件变化
 - 当配置文件或环境变量文件发生变化时自动触发
 - 适用场景：配置文件热加载、环境变量同步等
 #### Webhook 触发器 (Webhook Trigger)
 - 提供唯一的 HTTP 端点接收外部触发
 - 支持 POST 请求传递触发数据
 - 适用场景：第三方系统集成、CI/CD 流程集成等
 #### 任务状态触发器 (Task Status Trigger)
 - 基于其他定时任务的执行状态触发
 - 可在任务成功或失败时执行相应动作
 - 适用场景：任务链、失败告警、成功后续处理等
 #### 时间触发器 (Time Trigger)
 - 使用标准 Cron 表达式定时触发
 - 支持灵活的时间调度
 - 适用场景：定期检查、定时清理、周期性任务等
 #### 系统事件触发器 (System Event Trigger)
 - 监控系统资源使用情况
 - 支持磁盘使用率和内存使用率监控
 - 达到设定阈值时自动触发
 - 适用场景：资源告警、自动清理、容量管理等
 ### 2. 条件逻辑引擎 (Condition Logic Engine)
 - 支持多条件组合，使用 AND 或 OR 逻辑
 - 灵活的条件表达式：
  - 等于 (equals)
  - 不等于 (not_equals)
  - 大于 (greater_than)
  - 小于 (less_than)
  - 包含 (contains)
  - 不包含 (not_contains)
 - 支持嵌套字段访问（使用点号分隔，如 `data.user.name`）
 ### 3. 动作执行引擎 (Action Execution Engine)
 #### 运行任务 (Run Task)
 - 执行指定的定时任务
 - 通过任务 ID 引用
 #### 设置变量 (Set Variable)
 - 动态设置环境变量
 - 自动更新环境配置
 #### 执行命令 (Execute Command)
 - 执行自定义 Shell 命令
 - 获取命令输出
 #### 发送通知 (Send Notification)
 - 发送通知消息
 - 可集成现有通知系统
 ### 4. 高级特性 (Advanced Features)
 #### 延迟执行 (Delayed Execution)
 - 在触发后延迟指定秒数执行
 - 避免频繁触发
 #### 失败熔断 (Failure Circuit Breaker)
 - 设置连续失败阈值
 - 达到阈值后自动禁用场景
 - 防止资源浪费和错误累积
 #### 自适应重试 (Adaptive Retry)
 - 配置最大重试次数
 - 设置重试延迟
 - 支持退避倍数（每次重试延迟递增）
 - 根据错误类型灵活调整
 #### 执行日志 (Execution Logs)
 - 记录每次触发和执行的详细信息
 - 包括触发数据、条件匹配结果、执行状态、错误信息
 - 支持按场景查询历史日志
 ## 使用指南 (Usage Guide)
 ### 创建场景 (Creating a Scenario)
 1. 进入"场景模式"页面
 2. 点击"新建场景"按钮
 3. 填写基本信息：
   - 名称：场景的标识名称
   - 描述：场景的详细说明（可选）
 4. 配置触发器：
   - 选择触发类型
   - 根据触发类型填写相应配置
 5. 配置条件（可选）：
   - 选择条件逻辑（AND/OR）
   - 添加多个条件
   - 每个条件包含字段名、操作符和值
 6. 配置动作：
   - 至少添加一个动作
   - 根据动作类型填写相应参数
 7. 高级设置（可选）：
   - 延迟执行时间
   - 失败熔断阈值
   - 重试策略
 8. 保存场景
 ### Webhook 使用示例 (Webhook Usage Example)
 ```bash
 # 1. 创建 Webhook 类型的场景
 # 2. 获取 Webhook URL（点击"获取 Webhook"按钮）
 # 3. 使用 curl 或其他工具发送请求
 curl -X POST https://your-domain/api/scenarios/webhook/YOUR_TOKEN \
  -H "Content-Type: application/json" \
  -d '{
    "event": "deployment",
    "status": "success",
    "branch": "main"
  }'
 ```
 ### 条件配置示例 (Condition Configuration Examples)
 #### 示例 1：检查事件类型
 ```
 字段名: event
 操作符: equals
 值: deployment
 ```
 #### 示例 2：检查状态和分支（AND 逻辑）
 ```
 条件逻辑: AND
 条件 1:
  字段名: status
  操作符: equals
  值: success
 条件 2:
  字段名: branch
  操作符: equals
  值: main
 ```
 #### 示例 3：多分支支持（OR 逻辑）
 ```
 条件逻辑: OR
 条件 1:
  字段名: branch
  操作符: equals
  值: main
 条件 2:
  字段名: branch
  操作符: equals
  值: develop
 ```
 ### 动作配置示例 (Action Configuration Examples)
 #### 示例 1：执行任务
 ```
 动作类型: 运行任务
 任务 ID: 123
 ```
 #### 示例 2：设置环境变量
 ```
 动作类型: 设置变量
 变量名: DEPLOY_STATUS
 变量值: completed
 ```
 #### 示例 3：执行清理命令
 ```
 动作类型: 执行命令
 命令: rm -rf /tmp/cache/*
 ```
 ## API 接口 (API Endpoints)
 ### 场景管理 (Scenario Management)
 - `GET /api/scenarios` - 获取场景列表
 - `POST /api/scenarios` - 创建场景
 - `PUT /api/scenarios` - 更新场景
 - `DELETE /api/scenarios` - 删除场景
 - `POST /api/scenarios/:id/trigger` - 手动触发场景
 - `GET /api/scenarios/:id/webhook` - 获取 Webhook URL
 ### 日志查询 (Log Query)
 - `GET /api/scenarios/logs?scenarioId={id}&limit={limit}` - 查询场景日志
 ### Webhook 端点 (Webhook Endpoint)
 - `POST /api/scenarios/webhook/:token` - Webhook 触发端点
 ## 最佳实践 (Best Practices)
 1. **合理设置失败熔断阈值**
   - 建议设置为 3-5 次
   - 避免长时间重复执行失败的场景
 2. **使用条件过滤不必要的执行**
   - 添加精确的条件判断
   - 减少无效触发
 3. **监控执行日志**
   - 定期检查场景执行情况
   - 及时发现和处理异常
 4. **合理使用延迟执行**
   - 避免高频触发导致的系统负载
   - 给外部系统足够的处理时间
 5. **配置适当的重试策略**
   - 对临时性错误启用重试
   - 使用退避倍数避免频繁重试
 6. **保护敏感的 Webhook**
   - 使用复杂的 Token
   - 限制来源 IP（如需要）
   - 添加必要的条件验证
 ## 注意事项 (Notes)
 1. 变量监听功能需要读取文件系统权限
 2. 系统事件监控会定期执行检查，可能产生额外的系统开销
 3. Webhook Token 在场景创建后不可更改，如需更换请重建场景
 4. 执行命令动作需要谨慎使用，确保命令安全可靠
 5. 建议在生产环境使用前先在测试环境验证场景配置
 ## 故障排查 (Troubleshooting)
 ### 场景未触发
 1. 检查场景是否启用
 2. 验证触发器配置是否正确
 3. 查看场景执行日志
 ### 条件未匹配
 1. 检查字段名是否正确（区分大小写）
 2. 验证操作符和值的类型匹配
 3. 查看触发数据的实际内容
 ### 动作执行失败
 1. 检查动作配置参数
 2. 验证引用的任务 ID 是否存在
 3. 确认命令语法正确
 4. 查看详细的错误信息
 ### Webhook 无法访问
 1. 确认场景触发类型为 Webhook
 2. 检查 Token 是否正确
 3. 验证请求格式（Content-Type: application/json）
 ## 更新日志 (Changelog)
 ### Version 1.0.0 (2025-11-08)
 - ✨ 初始版本发布
 - ✨ 支持 5 种触发器类型
 - ✨ 支持 4 种动作类型
 - ✨ 完整的条件逻辑引擎
 - ✨ 失败熔断和重试机制
 - ✨ 执行日志记录
 - ✨ 中英文双语支持
 ## 贡献 (Contributing)
 欢迎提交问题和建议！
 Welcome to submit issues and suggestions!
 ## 许可证 (License)
 遵循青龙面板的开源许可证
 Follows the Qinglong panel's open source license
@@ -1,5 +0,0 @@
 ## Reporting a Vulnerability
 To report a vulnerability, please open a private vulnerability report at <https://github.com/whyour/qinglong/security>.
 While the discovery of new vulnerabilities is rare, we also recommend always using the latest versions of Qinglong to ensure your application remains as secure as possible.
@@ -1,38 +1,21 @@
 import { getFileContentByName, getLastModifyFilePath } from '../config/util';
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import config from '../config';
-import * as fs from 'fs/promises';
+import * as fs from 'fs';
 import { celebrate, Joi } from 'celebrate';
 import { join } from 'path';
 import { SAMPLE_FILES } from '../config/const';
 import ConfigService from '../services/config';
 import { writeFileWithLock } from '../shared/utils';
 const route = Router();
 export default (app: Router) => {
-  app.use('/configs', route);
+  app.use('/', route);
  route.get(
-    '/sample',
+    '/configs/files',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        res.send({
          code: 200,
          data: SAMPLE_FILES,
        });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get(
    '/files',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        const fileList = await fs.readdir(config.configPath, 'utf-8');
+        const fileList = fs.readdirSync(config.configPath, 'utf-8');
        res.send({
          code: 200,
          data: fileList
@@ -42,25 +25,40 @@ export default (app: Router) => {
            }),
        });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/detail',
+    '/configs/:file',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        const configService = Container.get(ConfigService);
+        let content = '';
-        await configService.getFile(req.query.path as string, res);
+        if (config.blackFileList.includes(req.params.file)) {
          res.send({ code: 403, message: '文件无法访问' });
        }
        if (req.params.file.includes('sample')) {
          content = getFileContentByName(
            `${config.samplePath}${req.params.file}`,
          );
        } else {
          content = getFileContentByName(
            `${config.configPath}${req.params.file}`,
          );
        }
        res.send({ code: 200, data: content });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.post(
-    '/save',
+    '/configs/save',
    celebrate({
      body: Joi.object({
        name: Joi.string().required(),
@@ -74,25 +72,11 @@ export default (app: Router) => {
        if (config.blackFileList.includes(name)) {
          res.send({ code: 403, message: '文件无法访问' });
        }
-        let path = join(config.configPath, name);
+        const path = `${config.configPath}${name}`;
-        if (name.startsWith('data/scripts/')) {
+        fs.writeFileSync(path, content);
          path = join(config.rootPath, name);
        }
        await writeFileWithLock(path, content);
        res.send({ code: 200, message: '保存成功' });
      } catch (e) {
-        return next(e);
+        logger.error('🔥 error: %o', e);
      }
    },
  );
  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);
      }
    },
@@ -2,164 +2,21 @@ import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import CronService from '../services/cron';
 import CronViewService from '../services/cronView';
 import { celebrate, Joi } from 'celebrate';
-import { commonCronSchema } from '../validation/schedule';
+import cron_parser from 'cron-parser';
 const route = Router();
 export default (app: Router) => {
-  app.use('/crons', route);
+  app.use('/', route);
  route.get(
-    '/views',
+    '/crons',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const cronViewService = Container.get(CronViewService);
        const data = await cronViewService.list();
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.post(
    '/views',
    celebrate({
      body: Joi.object({
        name: Joi.string().required(),
        sorts: Joi.array().optional().allow(null),
        filters: Joi.array().optional(),
        filterRelation: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const cronViewService = Container.get(CronViewService);
        const data = await cronViewService.create(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/views',
    celebrate({
      body: Joi.object({
        name: Joi.string().required(),
        id: Joi.number().required(),
        sorts: Joi.array().optional().allow(null),
        filters: Joi.array().optional(),
        filterRelation: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const cronViewService = Container.get(CronViewService);
        if (req.body.type === 1) {
          return res.send({ code: 400, message: '参数错误' });
        } else {
          const data = await cronViewService.update(req.body);
          return res.send({ code: 200, data });
        }
      } catch (e) {
        return next(e);
      }
    },
  );
  route.delete(
    '/views',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const cronViewService = Container.get(CronViewService);
        const data = await cronViewService.remove(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/views/move',
    celebrate({
      body: Joi.object({
        fromIndex: Joi.number().required(),
        toIndex: Joi.number().required(),
        id: Joi.number().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      try {
        const cronViewService = Container.get(CronViewService);
        const data = await cronViewService.move(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/views/disable',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronViewService = Container.get(CronViewService);
        const data = await cronViewService.disabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/views/enable',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronViewService = Container.get(CronViewService);
        const data = await cronViewService.enabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
    const logger: Logger = Container.get('logger');
    try {
      const cronService = Container.get(CronService);
      const data = await cronService.crontabs(req.query as any);
      return res.send({ code: 200, data });
    } catch (e) {
      logger.error('🔥 error: %o', e);
      return next(e);
    }
  });
  route.get(
    '/detail',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
-        const data = await cronService.find(req.query as any);
+        const data = await cronService.crontabs(
          req.query.searchValue as string,
        );
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
@@ -169,26 +26,35 @@ export default (app: Router) => {
  );
  route.post(
-    '/',
+    '/crons',
    celebrate({
-      body: Joi.object(commonCronSchema),
+      body: Joi.object({
        command: Joi.string().required(),
        schedule: Joi.string().required(),
        name: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        const cronService = Container.get(CronService);
+        if (cron_parser.parseExpression(req.body.schedule).hasNext()) {
-        const data = await cronService.create(req.body);
+          const cronService = Container.get(CronService);
-        return res.send({ code: 200, data });
+          const data = await cronService.create(req.body);
          return res.send({ code: 200, data });
        } else {
          return res.send({ code: 400, message: 'param schedule error' });
        }
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/run',
+    '/crons/run',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -197,15 +63,16 @@ export default (app: Router) => {
        const data = await cronService.run(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/stop',
+    '/crons/stop',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -214,58 +81,16 @@ export default (app: Router) => {
        const data = await cronService.stop(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
-        return next(e);
+        logger.error('🔥 error: %o', e);
      }
    },
  );
  route.delete(
    '/labels',
    celebrate({
      body: Joi.object({
        ids: Joi.array().items(Joi.number().required()),
        labels: Joi.array().items(Joi.string().required()),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
        const data = await cronService.removeLabels(
          req.body.ids,
          req.body.labels,
        );
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.post(
    '/labels',
    celebrate({
      body: Joi.object({
        ids: Joi.array().items(Joi.number().required()),
        labels: Joi.array().items(Joi.string().required()),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
        const data = await cronService.addLabels(req.body.ids, req.body.labels);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
-    '/disable',
+    '/crons/disable',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -274,15 +99,16 @@ export default (app: Router) => {
        const data = await cronService.disabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/enable',
+    '/crons/enable',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -291,54 +117,66 @@ export default (app: Router) => {
        const data = await cronService.enabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/:id/log',
+    '/crons/:id/log',
    celebrate({
      params: Joi.object({
-        id: Joi.number().required(),
+        id: Joi.string().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
        const data = await cronService.log(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/',
    celebrate({
      body: Joi.object({
        ...commonCronSchema,
        id: Joi.number().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
-        const data = await cronService.update(req.body);
+        const data = await cronService.log(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
    '/crons',
    celebrate({
      body: Joi.object({
        command: Joi.string().optional(),
        schedule: Joi.string().optional(),
        name: Joi.string().optional(),
        _id: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        if (
          !req.body.schedule ||
          cron_parser.parseExpression(req.body.schedule).hasNext()
        ) {
          const cronService = Container.get(CronService);
          const data = await cronService.update(req.body);
          return res.send({ code: 200, data });
        } else {
          return res.send({ code: 400, message: 'param schedule error' });
        }
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.delete(
-    '/',
+    '/crons',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -347,15 +185,16 @@ export default (app: Router) => {
        const data = await cronService.remove(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/pin',
+    '/crons/pin',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -364,15 +203,16 @@ export default (app: Router) => {
        const data = await cronService.pin(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/unpin',
+    '/crons/unpin',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -381,85 +221,71 @@ export default (app: Router) => {
        const data = await cronService.unPin(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/import',
+    '/crons/import',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
-        const data = await cronService.importCrontab();
+        const data = await cronService.import_crontab();
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/:id',
+    '/crons/:id',
    celebrate({
      params: Joi.object({
-        id: Joi.number().required(),
+        id: Joi.string().required(),
      }),
    }),
-    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
+    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
-        const data = await cronService.getDb({ id: req.params.id });
+        const data = await cronService.get(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/status',
+    '/crons/status',
    celebrate({
      body: Joi.object({
-        ids: Joi.array().items(Joi.number().required()),
+        ids: Joi.array().items(Joi.string().required()),
        status: Joi.string().required(),
-        pid: Joi.string().optional().allow(null),
+        pid: Joi.string().optional(),
-        log_path: Joi.string().optional().allow(null),
+        log_path: Joi.string().optional(),
-        last_running_time: Joi.number().optional().allow(null),
+        last_running_time: Joi.number().optional(),
-        last_execution_time: Joi.number().optional().allow(null),
+        last_execution_time: Joi.number().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
        const data = await cronService.status({
          ...req.body,
-          status: req.body.status ? parseInt(req.body.status) : undefined,
+          status: parseInt(req.body.status),
-          pid: req.body.pid ? parseInt(req.body.pid) : undefined,
+          pid: parseInt(req.body.pid) || '',
        });
        return res.send({ code: 200, data });
      } catch (e) {
-        return next(e);
+        logger.error('🔥 error: %o', e);
      }
    },
  );
  route.get(
    '/:id/logs',
    celebrate({
      params: Joi.object({
        id: Joi.number().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const cronService = Container.get(CronService);
        const data = await cronService.logs(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
@@ -6,18 +6,9 @@ import { celebrate, Joi } from 'celebrate';
 const route = Router();
 export default (app: Router) => {
-  app.use('/dependencies', route);
+  app.use('/', route);
  route.get(
-    '/',
+    '/dependencies',
    celebrate({
      query: 
        Joi.object({
          searchValue: Joi.string().optional().allow(''),
          type: Joi.string().optional().allow(''),
          status: Joi.string().optional().allow(''),
        }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -32,125 +23,121 @@ export default (app: Router) => {
  );
  route.post(
-    '/',
+    '/dependencies',
    celebrate({
      body: Joi.array().items(
        Joi.object({
          name: Joi.string().required(),
          type: Joi.number().required(),
-          remark: Joi.string().optional().allow(''),
+          remark: Joi.number().optional().allow(''),
        }),
      ),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const dependenceService = Container.get(DependenceService);
        const data = await dependenceService.create(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/',
+    '/dependencies',
    celebrate({
      body: Joi.object({
        name: Joi.string().required(),
-        id: Joi.number().required(),
+        _id: Joi.string().required(),
        type: Joi.number().required(),
-        remark: Joi.string().optional().allow(''),
+        remark: Joi.number().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const dependenceService = Container.get(DependenceService);
        const data = await dependenceService.update(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.delete(
-    '/',
+    '/dependencies',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const dependenceService = Container.get(DependenceService);
        const data = await dependenceService.remove(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.delete(
-    '/force',
+    '/dependencies/force',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const dependenceService = Container.get(DependenceService);
-        const data = await dependenceService.remove(req.body, true);
+        const data = await dependenceService.removeDb(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/:id',
+    '/dependencies/:id',
    celebrate({
      params: Joi.object({
-        id: Joi.number().required(),
+        id: Joi.string().required(),
      }),
    }),
-    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
+    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const dependenceService = Container.get(DependenceService);
-        const data = await dependenceService.getDb({ id: req.params.id });
+        const data = await dependenceService.get(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/reinstall',
+    '/dependencies/reinstall',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const dependenceService = Container.get(DependenceService);
        const data = await dependenceService.reInstall(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
-        return next(e);
+        logger.error('🔥 error: %o', e);
      }
    },
  );
  route.put(
    '/cancel',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const dependenceService = Container.get(DependenceService);
        await dependenceService.cancel(req.body);
        return res.send({ code: 200 });
      } catch (e) {
        return next(e);
      }
    },
@@ -1,48 +1,34 @@
-import { Joi, celebrate } from 'celebrate';
+import { Router, Request, Response, NextFunction } from 'express';
 import { NextFunction, Request, Response, Router } from 'express';
 import fs from 'fs';
 import multer from 'multer';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import config from '../config';
 import { safeJSONParse } from '../config/util';
 import EnvService from '../services/env';
 import { Logger } from 'winston';
 import { celebrate, Joi } from 'celebrate';
 const route = Router();
 const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, config.scriptPath);
  },
  filename: function (req, file, cb) {
    cb(null, file.originalname);
  },
 });
 const upload = multer({ storage: storage });
 export default (app: Router) => {
-  app.use('/envs', route);
+  app.use('/', route);
-
+  route.get(
-  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
+    '/envs',
-    const logger: Logger = Container.get('logger');
+    async (req: Request, res: Response, next: NextFunction) => {
-    try {
+      const logger: Logger = Container.get('logger');
-      const envService = Container.get(EnvService);
+      try {
-      const data = await envService.envs(req.query.searchValue as string);
+        const envService = Container.get(EnvService);
-      return res.send({ code: 200, data });
+        const data = await envService.envs(req.query.searchValue as string);
-    } catch (e) {
+        return res.send({ code: 200, data });
-      logger.error('🔥 error: %o', e);
+      } catch (e) {
-      return next(e);
+        logger.error('🔥 error: %o', e);
-    }
+        return next(e);
-  });
+      }
    },
  );
  route.post(
-    '/',
+    '/envs',
    celebrate({
      body: Joi.array().items(
        Joi.object({
          value: Joi.string().required(),
-          name: Joi.string()
+          name: Joi.string().required(),
            .required()
            .pattern(/^[a-zA-Z_][0-9a-zA-Z_]*$/),
          remarks: Joi.string().optional().allow(''),
        }),
      ),
@@ -51,25 +37,23 @@ export default (app: Router) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
        if (!req.body?.length) {
          return res.send({ code: 400, message: '参数不正确' });
        }
        const data = await envService.create(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/',
+    '/envs',
    celebrate({
      body: Joi.object({
        value: Joi.string().required(),
        name: Joi.string().required(),
-        remarks: Joi.string().optional().allow('').allow(null),
+        remarks: Joi.string().optional().allow(''),
-        id: Joi.number().required(),
+        _id: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -79,15 +63,16 @@ export default (app: Router) => {
        const data = await envService.update(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.delete(
-    '/',
+    '/envs',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -96,37 +81,40 @@ export default (app: Router) => {
        const data = await envService.remove(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/:id/move',
+    '/envs/:id/move',
    celebrate({
      params: Joi.object({
-        id: Joi.number().required(),
+        id: Joi.string().required(),
      }),
      body: Joi.object({
        fromIndex: Joi.number().required(),
        toIndex: Joi.number().required(),
      }),
    }),
-    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
+    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
        const data = await envService.move(req.params.id, req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/disable',
+    '/envs/disable',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -135,15 +123,16 @@ export default (app: Router) => {
        const data = await envService.disabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/enable',
+    '/envs/enable',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -152,16 +141,17 @@ export default (app: Router) => {
        const data = await envService.enabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/name',
+    '/envs/name',
    celebrate({
      body: Joi.object({
-        ids: Joi.array().items(Joi.number().required()),
+        ids: Joi.array().items(Joi.string().required()),
        name: Joi.string().required(),
      }),
    }),
@@ -172,92 +162,27 @@ export default (app: Router) => {
        const data = await envService.updateNames(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/:id',
+    '/envs/:id',
    celebrate({
      params: Joi.object({
-        id: Joi.number().required(),
+        id: Joi.string().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
        const data = await envService.getDb({ id: req.params.id });
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/pin',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
-        const data = await envService.pin(req.body);
+        const data = await envService.get(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
-        return next(e);
+        logger.error('🔥 error: %o', e);
      }
    },
  );
  route.put(
    '/unpin',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
        const data = await envService.unPin(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.post(
    '/upload',
    upload.single('env'),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const envService = Container.get(EnvService);
        const fileContent = await fs.promises.readFile(req!.file!.path, 'utf8');
        const parseContent = safeJSONParse(fileContent);
        const data = Array.isArray(parseContent)
          ? parseContent
          : [parseContent];
        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,
            })),
          );
          return res.send({ code: 200, data: result });
        } else {
          return res.send({
            code: 400,
            message: '每条数据 name 或者 value 字段不能为空，参考导出文件格式',
          });
        }
      } catch (e) {
        return next(e);
      }
    },
@@ -1,27 +0,0 @@
 import { Router } from 'express';
 import Logger from '../loaders/logger';
 import { HealthService } from '../services/health';
 import Container from 'typedi';
 const route = Router();
 export default (app: Router) => {
  app.use('/', route);
  route.get('/health', async (req, res) => {
    try {
      const healthService = Container.get(HealthService);
      const health = await healthService.check();
      res.status(200).send({
        code: 200,
        data: health,
      });
    } catch (err: any) {
      Logger.error('Health check failed:', err);
      res.status(500).send({
        code: 500,
        message: 'Health check failed',
        error: err.message,
      });
    }
  });
 };
@@ -7,11 +7,6 @@ import cron from './cron';
 import script from './script';
 import open from './open';
 import dependence from './dependence';
 import system from './system';
 import subscription from './subscription';
 import update from './update';
 import health from './health';
 import scenario from './scenario';
 export default () => {
  const app = Router();
@@ -23,11 +18,6 @@ export default () => {
  script(app);
  open(app);
  dependence(app);
  system(app);
  subscription(app);
  update(app);
  health(app);
  scenario(app);
  return app;
 };
@@ -1,140 +1,75 @@
-import { celebrate, Joi } from 'celebrate';
+import { Router, Request, Response, NextFunction } from 'express';
 import { NextFunction, Request, Response, Router } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import * as fs from 'fs';
 import config from '../config';
-import {
+import { getFileContentByName } from '../config/util';
  getFileContentByName,
  readDirs,
  removeAnsi,
  rmPath,
 } from '../config/util';
 import LogService from '../services/log';
 const route = Router();
 const blacklist = ['.tmp'];
 export default (app: Router) => {
-  app.use('/logs', route);
+  app.use('/', route);
  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
    const logger: Logger = Container.get('logger');
    try {
      const result = await readDirs(config.logPath, config.logPath, blacklist);
      res.send({
        code: 200,
        data: result,
      });
    } catch (e) {
      logger.error('🔥 error: %o', e);
      return next(e);
    }
  });
  route.get(
-    '/detail',
+    '/logs',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        const logService = Container.get(LogService);
+        const fileList = fs.readdirSync(config.logPath, 'utf-8');
-        const finalPath = logService.checkFilePath(
+        const dirs = [];
-          (req.query.path as string) || '',
+        for (let i = 0; i < fileList.length; i++) {
-          (req.query.file as string) || '',
+          const stat = fs.lstatSync(config.logPath + fileList[i]);
-        );
+          if (stat.isDirectory()) {
-        if (!finalPath || blacklist.includes(req.query.path as string)) {
+            const fileListTmp = fs.readdirSync(
-          return res.send({
+              `${config.logPath}/${fileList[i]}`,
-            code: 403,
+              'utf-8',
-            message: '暂无权限',
+            );
-          });
+            dirs.push({
              name: fileList[i],
              isDir: true,
              files: fileListTmp.reverse(),
            });
          } else {
            dirs.push({
              name: fileList[i],
              isDir: false,
              files: [],
            });
          }
        }
-        const content = await getFileContentByName(finalPath);
+        res.send({ code: 200, dirs });
        res.send({ code: 200, data: removeAnsi(content) });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/:file',
+    '/logs/:dir/:file',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        const logService = Container.get(LogService);
+        const { dir, file } = req.params;
-        const finalPath = logService.checkFilePath(
+        const content = getFileContentByName(
-          (req.query.path as string) || '',
+          `${config.logPath}/${dir}/${file}`,
          (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) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
-  route.delete(
+  route.get(
-    '/',
+    '/logs/:file',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().allow(''),
        type: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        let { filename, path } = req.body as {
+        const { file } = req.params;
-          filename: string;
+        const content = getFileContentByName(`${config.logPath}/${file}`);
-          path: string;
+        res.send({ code: 200, data: content });
        };
        const logService = Container.get(LogService);
        const finalPath = logService.checkFilePath(path, filename);
        if (!finalPath || blacklist.includes(path)) {
          return res.send({
            code: 403,
            message: '暂无权限',
          });
        }
        await rmPath(finalPath);
        res.send({ code: 200 });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.post(
    '/download',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        let { filename, path } = req.body as {
          filename: string;
          path: string;
        };
        const logService = Container.get(LogService);
        const filePath = logService.checkFilePath(path, filename);
        if (!filePath) {
          return res.send({
            code: 403,
            message: '暂无权限',
          });
        }
        return res.download(filePath, filename, (err) => {
          if (err) {
            return next(err);
          }
        });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -16,6 +16,7 @@ export default (app: Router) => {
        const data = await openService.list();
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -25,7 +26,7 @@ export default (app: Router) => {
    '/apps',
    celebrate({
      body: Joi.object({
-        name: Joi.string().optional().allow('').disallow('system'),
+        name: Joi.string().optional().allow(''),
        scopes: Joi.array().items(Joi.string().required()),
      }),
    }),
@@ -36,6 +37,7 @@ export default (app: Router) => {
        const data = await openService.create(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -47,7 +49,7 @@ export default (app: Router) => {
      body: Joi.object({
        name: Joi.string().optional().allow(''),
        scopes: Joi.array().items(Joi.string()),
-        id: Joi.number().required(),
+        _id: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
@@ -57,6 +59,7 @@ export default (app: Router) => {
        const data = await openService.update(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -65,7 +68,7 @@ export default (app: Router) => {
  route.delete(
    '/apps',
    celebrate({
-      body: Joi.array().items(Joi.number().required()),
+      body: Joi.array().items(Joi.string().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
@@ -74,6 +77,7 @@ export default (app: Router) => {
        const data = await openService.remove(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -83,16 +87,17 @@ export default (app: Router) => {
    '/apps/:id/reset-secret',
    celebrate({
      params: Joi.object({
-        id: Joi.number().required(),
+        id: Joi.string().required(),
      }),
    }),
-    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
+    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const openService = Container.get(OpenService);
        const data = await openService.resetSecret(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -113,6 +118,7 @@ export default (app: Router) => {
        const result = await openService.authToken(req.query as any);
        return res.send(result);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -1,216 +0,0 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import ScenarioService from '../services/scenario';
 import { celebrate, Joi } from 'celebrate';
 const route = Router();
 export default (app: Router) => {
  app.use('/scenarios', route);
  // List all scenarios
  route.get(
    '/',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const data = await scenarioService.list(req.query.searchValue as string);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Create a new scenario
  route.post(
    '/',
    celebrate({
      body: Joi.object({
        name: Joi.string().required(),
        description: Joi.string().optional().allow(''),
        workflowGraph: Joi.object().optional(),
        triggerType: Joi.string()
          .valid('variable', 'webhook', 'task_status', 'time', 'system_event')
          .optional(),
        triggerConfig: Joi.object().optional(),
        conditionLogic: Joi.string().valid('AND', 'OR').default('AND'),
        conditions: Joi.array().optional().default([]),
        actions: Joi.array().optional(),
        retryStrategy: Joi.object({
          maxRetries: Joi.number().min(0).max(10),
          retryDelay: Joi.number().min(1),
          backoffMultiplier: Joi.number().min(1).optional(),
          errorTypes: Joi.array().items(Joi.string()).optional(),
        }).optional(),
        failureThreshold: Joi.number().min(1).default(3),
        delayExecution: Joi.number().min(0).default(0),
        isEnabled: Joi.number().valid(0, 1).default(1),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const data = await scenarioService.create(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Update a scenario
  route.put(
    '/',
    celebrate({
      body: Joi.object({
        id: Joi.number().required(),
        name: Joi.string().optional(),
        description: Joi.string().optional().allow(''),
        workflowGraph: Joi.object().optional(),
        triggerType: Joi.string()
          .valid('variable', 'webhook', 'task_status', 'time', 'system_event')
          .optional(),
        triggerConfig: Joi.object().optional(),
        conditionLogic: Joi.string().valid('AND', 'OR').optional(),
        conditions: Joi.array().optional(),
        actions: Joi.array().optional(),
        retryStrategy: Joi.object({
          maxRetries: Joi.number().min(0).max(10),
          retryDelay: Joi.number().min(1),
          backoffMultiplier: Joi.number().min(1).optional(),
          errorTypes: Joi.array().items(Joi.string()).optional(),
        }).optional(),
        failureThreshold: Joi.number().min(1).optional(),
        delayExecution: Joi.number().min(0).optional(),
        isEnabled: Joi.number().valid(0, 1).optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const data = await scenarioService.update(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Delete scenarios
  route.delete(
    '/',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const data = await scenarioService.remove(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Get scenario logs
  route.get(
    '/logs',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const scenarioId = req.query.scenarioId
          ? parseInt(req.query.scenarioId as string)
          : undefined;
        const limit = req.query.limit
          ? parseInt(req.query.limit as string)
          : 100;
        const data = await scenarioService.getLogs(scenarioId, limit);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Manually trigger a scenario
  route.post(
    '/:id/trigger',
    celebrate({
      params: Joi.object({
        id: Joi.number().required(),
      }),
      body: Joi.object().optional().default({}),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        await scenarioService.triggerScenario(
          parseInt(req.params.id),
          req.body,
        );
        return res.send({ code: 200, message: 'Scenario triggered successfully' });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Webhook endpoint for external triggers
  route.post(
    '/webhook/:token',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const scenario = await scenarioService.findByWebhookToken(
          req.params.token,
        );
        if (!scenario) {
          return res.status(404).send({ code: 404, message: 'Invalid webhook token' });
        }
        await scenarioService.triggerScenario(scenario.id!, {
          ...req.body,
          headers: req.headers,
          query: req.query,
          webhookTriggered: true,
        });
        return res.send({ code: 200, message: 'Webhook received and scenario triggered' });
      } catch (e) {
        return next(e);
      }
    },
  );
  // Get webhook URL for a scenario
  route.get(
    '/:id/webhook',
    celebrate({
      params: Joi.object({
        id: Joi.number().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const scenarioService = Container.get(ScenarioService);
        const token = scenarioService.getWebhookToken(parseInt(req.params.id));
        if (!token) {
          return res.status(404).send({ 
            code: 404, 
            message: 'Webhook token not found. Ensure the scenario trigger type is webhook.' 
          });
        }
        const webhookUrl = `${req.protocol}://${req.get('host')}/api/scenarios/webhook/${token}`;
        return res.send({ code: 200, data: { token, webhookUrl } });
      } catch (e) {
        return next(e);
      }
    },
  );
 };
@@ -1,68 +1,72 @@
-import { fileExist, readDirs, readDir, rmPath, IFile } from '../config/util';
+import {
  fileExist,
  getFileContentByName,
  getLastModifyFilePath,
 } from '../config/util';
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import config from '../config';
-import * as fs from 'fs/promises';
+import * as fs from 'fs';
 import { celebrate, Joi } from 'celebrate';
-import path, { join, parse } from 'path';
+import path from 'path';
 import ScriptService from '../services/script';
 import multer from 'multer';
 import { writeFileWithLock } from '../shared/utils';
 const route = Router();
 const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, config.scriptPath);
  },
  filename: function (req, file, cb) {
    cb(null, file.originalname);
  },
 });
 const upload = multer({ storage: storage });
 export default (app: Router) => {
-  app.use('/scripts', route);
+  app.use('/', route);
  route.get(
-    '/',
+    '/scripts/files',
    celebrate({
      query: Joi.object({
        path: Joi.string().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        let result: IFile[] = [];
+        const fileList = fs.readdirSync(config.scriptPath, 'utf-8');
-        const blacklist = [
+
-          'node_modules',
+        let result = [];
-          '.git',
+        for (let i = 0; i < fileList.length; i++) {
-          '.pnpm',
+          const fileOrDir = fileList[i];
-          'pnpm-lock.yaml',
+          const fPath = path.join(config.scriptPath, fileOrDir);
-          'yarn.lock',
+          const dirStat = fs.statSync(fPath);
-          'package-lock.json',
+          if (['node_modules'].includes(fileOrDir)) {
-        ];
+            continue;
-        if (req.query.path) {
+          }
-          result = await readDir(
+
-            req.query.path as string,
+          if (dirStat.isDirectory()) {
-            config.scriptPath,
+            const childFileList = fs.readdirSync(fPath, 'utf-8');
-            blacklist,
+            let children = [];
-          );
+            for (let j = 0; j < childFileList.length; j++) {
-        } else {
+              const childFile = childFileList[j];
-          result = await readDirs(
+              const sPath = path.join(config.scriptPath, fileOrDir, childFile);
-            config.scriptPath,
+              const _fileExist = await fileExist(sPath);
-            config.scriptPath,
+              if (_fileExist && fs.statSync(sPath).isFile()) {
-            blacklist,
+                const statObj = fs.statSync(sPath);
-            (a, b) => {
+                children.push({
-              if (a.type === b.type) {
+                  title: childFile,
-                return a.title.localeCompare(b.title);
+                  value: childFile,
-              } else {
+                  key: `${fileOrDir}-${childFile}`,
-                return a.type === 'directory' ? -1 : 1;
+                  mtime: statObj.mtimeMs,
                  parent: fileOrDir,
                });
              }
-            },
+            }
-          );
+            result.push({
              title: fileOrDir,
              value: fileOrDir,
              key: fileOrDir,
              mtime: dirStat.mtimeMs,
              disabled: true,
              children: children.sort((a, b) => b.mtime - a.mtime),
            });
          } else {
            result.push({
              title: fileOrDir,
              value: fileOrDir,
              key: fileOrDir,
              mtime: dirStat.mtimeMs,
            });
          }
        }
        res.send({
          code: 200,
          data: result,
@@ -71,315 +75,159 @@ export default (app: Router) => {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    });
  route.get(
    '/detail',
    celebrate({
      query: Joi.object({
        path: Joi.string().optional().allow(''),
        file: Joi.string().required(),
      }),
    }),
    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.file as string,
        );
        res.send({ code: 200, data: content });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get(
-    '/:file',
+    '/scripts/:file',
    celebrate({
      params: Joi.object({
        file: Joi.string().required(),
      }),
      query: Joi.object({
        path: Joi.string().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        const scriptService = Container.get(ScriptService);
+        const path = req.query.path ? `${req.query.path}/` : '';
-        const content = await scriptService.getFile(
+        const content = getFileContentByName(
-          req.query?.path as string || '',
+          `${config.scriptPath}${path}${req.params.file}`,
          req.params.file,
        );
        res.send({ code: 200, data: content });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.post(
-    '/',
+    '/scripts',
    upload.single('file'),
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
-        path: Joi.string().optional().allow(''),
+        path: Joi.string().allow(''),
-        content: Joi.string().optional().allow(''),
+        content: Joi.string().allow(''),
-        originFilename: Joi.string().optional().allow(''),
+        originFilename: Joi.string().allow(''),
        directory: Joi.string().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        let { filename, path, content, originFilename, directory } =
+        let { filename, path, content, originFilename } = req.body as {
-          req.body as {
+          filename: string;
-            filename: string;
+          path: string;
-            path: string;
+          content: string;
-            content: string;
+          originFilename: string;
-            originFilename: string;
+        };
            directory: string;
          };
        if (!path) {
          path = config.scriptPath;
        }
        if (!path.endsWith('/')) {
          path += '/';
        }
        if (!path.startsWith('/')) {
          path = join(config.scriptPath, path);
        }
        if (config.writePathList.every((x) => !path.startsWith(x))) {
          return res.send({
-            code: 403,
+            code: 430,
-            message: '暂无权限',
+            data: '文件路径禁止访问',
          });
        }
        if (req.file) {
          await fs.rename(req.file.path, join(path, filename));
          return res.send({ code: 200 });
        }
        if (directory) {
          await fs.mkdir(join(path, directory), { recursive: true });
          return res.send({ code: 200 });
        }
        if (!originFilename) {
          originFilename = filename;
        }
-        const originFilePath = join(
+        const originFilePath = `${path}${originFilename.replace(/\//g, '')}`;
-          path,
+        const filePath = `${path}${filename.replace(/\//g, '')}`;
-          `${originFilename.replace(/\//g, '')}`,
+        if (fs.existsSync(originFilePath)) {
-        );
+          if (!fs.existsSync(config.bakPath)) {
-        const filePath = join(path, `${filename.replace(/\//g, '')}`);
+            fs.mkdirSync(config.bakPath);
-        const fileExists = await fileExist(filePath);
+          }
-        if (fileExists) {
+          fs.copyFileSync(
          await fs.copyFile(
            originFilePath,
-            join(config.bakPath, originFilename.replace(/\//g, '')),
+            `${config.bakPath}${originFilename.replace(/\//g, '')}`,
          );
          if (filename !== originFilename) {
-            await rmPath(originFilePath);
+            fs.unlinkSync(originFilePath);
          }
        }
-        await writeFileWithLock(filePath, content);
+        fs.writeFileSync(filePath, content);
        return res.send({ code: 200 });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/',
+    '/scripts',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
-        path: Joi.string().optional().allow(''),
+        path: Joi.string().allow(''),
-        content: Joi.string().required().allow(''),
+        content: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        let { filename, content, path } = req.body as {
          filename: string;
          content: string;
          path: string;
        };
-        const scriptService = Container.get(ScriptService);
+        const filePath = `${config.scriptPath}${path}/${filename}`;
-        const filePath = scriptService.checkFilePath(path, filename);
+        fs.writeFileSync(filePath, content);
        if (!filePath) {
          return res.send({
            code: 403,
            message: '暂无权限',
          });
        }
        await writeFileWithLock(filePath, content);
        return res.send({ code: 200 });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.delete(
-    '/',
+    '/scripts',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().optional().allow(''),
        type: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        let { filename, path } = req.body as {
+        let { filename } = req.body as {
          filename: string;
          path: string;
        };
-        if (!path) {
+        const filePath = `${config.scriptPath}${filename}`;
-          path = '';
+        fs.unlinkSync(filePath);
        }
        const scriptService = Container.get(ScriptService);
        const filePath = scriptService.checkFilePath(path, filename);
        if (!filePath) {
          return res.send({
            code: 403,
            message: '暂无权限',
          });
        }
        await rmPath(filePath);
        res.send({ code: 200 });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.post(
-    '/download',
+    '/scripts/download',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        let { filename, path } = req.body as {
          filename: string;
          path: string;
        };
        if (!path) {
          path = '';
        }
        const scriptService = Container.get(ScriptService);
        const filePath = scriptService.checkFilePath(path, filename);
        if (!filePath) {
          return res.send({
            code: 403,
            message: '暂无权限',
          });
        }
        return res.download(filePath, filename, (err) => {
          if (err) {
            return next(err);
          }
        });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/run',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        content: Joi.string().optional().allow(''),
        path: Joi.string().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
-        let { filename, content, path } = req.body;
+        let { filename } = req.body as {
        if (!path) {
          path = '';
        }
        const { name, ext } = parse(filename);
        const filePath = join(config.scriptPath, path, `${name}.swap${ext}`);
        await writeFileWithLock(filePath, content || '');
        const scriptService = Container.get(ScriptService);
        const result = await scriptService.runScript(filePath);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/stop',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().optional().allow(''),
        pid: Joi.number().optional().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        let { filename, path, pid } = req.body;
        if (!path) {
          path = '';
        }
        const { name, ext } = parse(filename);
        const filePath = join(config.scriptPath, path, `${name}.swap${ext}`);
        const logPath = join(config.logPath, path, `${name}.swap`);
        const scriptService = Container.get(ScriptService);
        const result = await scriptService.stopScript(filePath, pid);
        setTimeout(() => {
          rmPath(logPath);
        }, 3000);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/rename',
    celebrate({
      body: Joi.object({
        filename: Joi.string().required(),
        path: Joi.string().allow(''),
        newFilename: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        let { filename, path, newFilename } = req.body as {
          filename: string;
          path: string;
          newFilename: string;
        };
-        if (!path) {
+        const filePath = `${config.scriptPath}${filename}`;
-          path = '';
+        // const stats = fs.statSync(filePath);
-        }
+        // res.set({
-        const filePath = join(config.scriptPath, path, filename);
+        //   'Content-Type': 'application/octet-stream', //告诉浏览器这是一个二进制文件
-        const newPath = join(config.scriptPath, path, newFilename);
+        //   'Content-Disposition': 'attachment; filename=' + filename, //告诉浏览器这是一个需要下载的文件
-        await fs.rename(filePath, newPath);
+        //   'Content-Length': stats.size  //文件大小
-        res.send({ code: 200 });
+        // });
        // fs.createReadStream(filePath).pipe(res);
        return res.download(filePath, filename, (err) => {
          return next(err);
        });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -1,294 +0,0 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import SubscriptionService from '../services/subscription';
 import { celebrate, Joi } from 'celebrate';
 import { CronExpressionParser } from 'cron-parser';
 const route = Router();
 export default (app: Router) => {
  app.use('/subscriptions', route);
  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
    const logger: Logger = Container.get('logger');
    try {
      const subscriptionService = Container.get(SubscriptionService);
      const data = await subscriptionService.list(
        req.query.searchValue as string,
        req.query.ids as string,
      );
      return res.send({ code: 200, data });
    } catch (e) {
      logger.error('🔥 error: %o', e);
      return next(e);
    }
  });
  route.post(
    '/',
    celebrate({
      body: Joi.object({
        type: Joi.string().required(),
        schedule: Joi.string().optional().allow('').allow(null),
        interval_schedule: Joi.object({
          type: Joi.string().required(),
          value: Joi.number().min(1).required(),
        })
          .optional()
          .allow('')
          .allow(null),
        name: Joi.string().optional().allow('').allow(null),
        url: Joi.string().required(),
        whitelist: Joi.string().optional().allow('').allow(null),
        blacklist: Joi.string().optional().allow('').allow(null),
        branch: Joi.string().optional().allow('').allow(null),
        dependences: Joi.string().optional().allow('').allow(null),
        pull_type: Joi.string().optional().allow('').allow(null),
        pull_option: Joi.object().optional().allow('').allow(null),
        extensions: Joi.string().optional().allow('').allow(null),
        sub_before: Joi.string().optional().allow('').allow(null),
        sub_after: Joi.string().optional().allow('').allow(null),
        schedule_type: Joi.string().required(),
        alias: Joi.string().required(),
        proxy: Joi.string().optional().allow('').allow(null),
        autoAddCron: Joi.boolean().optional().allow('').allow(null),
        autoDelCron: Joi.boolean().optional().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        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 });
        } else {
          return res.send({ code: 400, message: 'param schedule error' });
        }
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/run',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.run(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/stop',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.stop(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/disable',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.disabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/enable',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.enabled(req.body);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get(
    '/:id/log',
    celebrate({
      params: Joi.object({
        id: Joi.number().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.log(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/',
    celebrate({
      body: Joi.object({
        type: Joi.string().required(),
        schedule: Joi.string().optional().allow('').allow(null),
        interval_schedule: Joi.object().optional().allow('').allow(null),
        name: Joi.string().optional().allow('').allow(null),
        url: Joi.string().required(),
        whitelist: Joi.string().optional().allow('').allow(null),
        blacklist: Joi.string().optional().allow('').allow(null),
        branch: Joi.string().optional().allow('').allow(null),
        dependences: Joi.string().optional().allow('').allow(null),
        pull_type: Joi.string().optional().allow('').allow(null),
        pull_option: Joi.object().optional().allow('').allow(null),
        schedule_type: Joi.string().optional().allow('').allow(null),
        extensions: Joi.string().optional().allow('').allow(null),
        sub_before: Joi.string().optional().allow('').allow(null),
        sub_after: Joi.string().optional().allow('').allow(null),
        alias: Joi.string().required(),
        proxy: Joi.string().optional().allow('').allow(null),
        autoAddCron: Joi.boolean().optional().allow('').allow(null),
        autoDelCron: Joi.boolean().optional().allow('').allow(null),
        id: Joi.number().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        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 });
        } else {
          return res.send({ code: 400, message: 'param schedule error' });
        }
      } catch (e) {
        return next(e);
      }
    },
  );
  route.delete(
    '/',
    celebrate({
      body: Joi.array().items(Joi.number().required()),
      query: Joi.object({
        force: Joi.boolean().optional(),
        t: Joi.number(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.remove(req.body, req.query);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get(
    '/:id',
    celebrate({
      params: Joi.object({
        id: Joi.number().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.getDb({ id: req.params.id });
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/status',
    celebrate({
      body: Joi.object({
        ids: Joi.array().items(Joi.number().required()),
        status: Joi.string().required(),
        pid: Joi.string().optional(),
        log_path: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.status({
          ...req.body,
          status: parseInt(req.body.status),
          pid: parseInt(req.body.pid) || '',
        });
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get(
    '/:id/logs',
    celebrate({
      params: Joi.object({
        id: Joi.number().required(),
      }),
    }),
    async (req: Request<{ id: number }>, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const subscriptionService = Container.get(SubscriptionService);
        const data = await subscriptionService.logs(req.params.id);
        return res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
 };
@@ -1,443 +0,0 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import * as fs from 'fs/promises';
 import config from '../config';
 import SystemService from '../services/system';
 import { celebrate, Joi } from 'celebrate';
 import UserService from '../services/user';
 import {
  getUniqPath,
  handleLogPath,
  parseVersion,
  promiseExec,
 } from '../config/util';
 import dayjs from 'dayjs';
 import multer from 'multer';
 const route = Router();
 const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, config.tmpPath);
  },
  filename: function (req, file, cb) {
    cb(null, 'data.tgz');
  },
 });
 const upload = multer({ storage: storage });
 export default (app: Router) => {
  app.use('/system', route);
  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
    const logger: Logger = Container.get('logger');
    try {
      const userService = Container.get(UserService);
      const authInfo = await userService.getAuthInfo();
      const { version, changeLog, changeLogLink, publishTime } =
        await parseVersion(config.versionFile);
      let isInitialized = true;
      if (
        Object.keys(authInfo).length === 2 &&
        authInfo.username === 'admin' &&
        authInfo.password === 'admin'
      ) {
        isInitialized = false;
      }
      res.send({
        code: 200,
        data: {
          isInitialized,
          version,
          publishTime: dayjs(publishTime).unix(),
          branch: process.env.QL_BRANCH || 'master',
          changeLog,
          changeLogLink,
        },
      });
    } catch (e) {
      logger.error('🔥 error: %o', e);
      return next(e);
    }
  });
  route.get(
    '/config',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const systemService = Container.get(SystemService);
        const data = await systemService.getSystemConfig();
        res.send({ code: 200, data });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/log-remove-frequency',
    celebrate({
      body: Joi.object({
        logRemoveFrequency: Joi.number().allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.updateLogRemoveFrequency(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/cron-concurrency',
    celebrate({
      body: Joi.object({
        cronConcurrency: Joi.number().allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.updateCronConcurrency(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/dependence-proxy',
    celebrate({
      body: Joi.object({
        dependenceProxy: Joi.string().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.updateDependenceProxy(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/node-mirror',
    celebrate({
      body: Joi.object({
        nodeMirror: Joi.string().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        res.setHeader('Content-type', 'application/octet-stream');
        await systemService.updateNodeMirror(req.body, res);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/python-mirror',
    celebrate({
      body: Joi.object({
        pythonMirror: Joi.string().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.updatePythonMirror(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/linux-mirror',
    celebrate({
      body: Joi.object({
        linuxMirror: Joi.string().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        res.setHeader('Content-type', 'application/octet-stream');
        await systemService.updateLinuxMirror(req.body, res);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/update-check',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.checkUpdate();
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/update',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.updateSystem();
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/reload',
    celebrate({
      body: Joi.object({
        type: Joi.string().optional().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.reloadSystem(req.body.type);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/notify',
    celebrate({
      body: Joi.object({
        title: Joi.string().required(),
        content: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.notify(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/command-run',
    celebrate({
      body: Joi.object({
        command: Joi.string().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const command = req.body.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`;
        res.setHeader('Content-type', 'application/octet-stream');
        await systemService.run(
          { ...req.body, logPath },
          {
            onStart: async (cp, startTime) => {
              res.setHeader('QL-Task-Pid', `${cp.pid}`);
              res.setHeader('QL-Task-Log', `${logPath}`);
            },
            onEnd: async (cp, endTime, diff) => {
              res.end();
            },
            onError: async (message: string) => {
              res.write(message);
              const absolutePath = await handleLogPath(logPath);
              await fs.appendFile(absolutePath, message);
            },
            onLog: async (message: string) => {
              res.write(message);
              const absolutePath = await handleLogPath(logPath);
              await fs.appendFile(absolutePath, message);
            },
          },
        );
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/command-stop',
    celebrate({
      body: Joi.object({
        command: Joi.string().optional(),
        pid: Joi.number().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.stop(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/data/export',
    celebrate({
      body: Joi.object({
        type: Joi.array().items(Joi.string()).optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        await systemService.exportData(res, req.body.type);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/data/import',
    upload.single('data'),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.importData();
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.get(
    '/log',
    celebrate({
      query: {
        startTime: Joi.string().allow('').optional(),
        endTime: Joi.string().allow('').optional(),
        t: Joi.string().optional(),
      },
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        await systemService.getSystemLog(
          res,
          req.query as {
            startTime?: string;
            endTime?: string;
          },
        );
      } catch (e) {
        return next(e);
      }
    },
  );
  route.delete(
    '/log',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        await systemService.deleteSystemLog();
        res.send({ code: 200 });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/auth/reset',
    celebrate({
      body: Joi.object({
        retries: Joi.number().optional(),
        twoFactorActivated: Joi.boolean().optional(),
        password: Joi.string().optional(),
        username: Joi.string().optional(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const userService = Container.get(UserService);
        await userService.resetAuthInfo(req.body);
        res.send({ code: 200, message: '更新成功' });
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/timezone',
    celebrate({
      body: Joi.object({
        timezone: Joi.string().allow('').allow(null),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.updateTimezone(req.body);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
  route.put(
    '/config/dependence-clean',
    celebrate({
      body: Joi.object({
        type: Joi.string().allow(''),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.cleanDependence(req.body.type);
        res.send(result);
      } catch (e) {
        return next(e);
      }
    },
  );
 };
@@ -1,51 +0,0 @@
 import { NextFunction, Request, Response, Router } from 'express';
 import Container from 'typedi';
 import Logger from '../loaders/logger';
 import SystemService from '../services/system';
 const route = Router();
 export default (app: Router) => {
  app.use('/update', route);
  route.put(
    '/reload',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.reloadSystem();
        res.send(result);
      } catch (e) {
        Logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
    '/system',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.reloadSystem('system');
        res.send(result);
      } catch (e) {
        Logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
    '/data',
    async (req: Request, res: Response, next: NextFunction) => {
      try {
        const systemService = Container.get(SystemService);
        const result = await systemService.reloadSystem('data');
        res.send(result);
      } catch (e) {
        Logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
 };
@@ -1,37 +1,17 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
 import * as fs from 'fs';
 import config from '../config';
 import UserService from '../services/user';
 import { celebrate, Joi } from 'celebrate';
-import multer from 'multer';
+import { getFileContentByName } from '../config/util';
 import path from 'path';
 import { v4 as uuidV4 } from 'uuid';
 import rateLimit from 'express-rate-limit';
 import config from '../config';
 import { isDemoEnv } from '../config/util';
 const route = Router();
 const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, config.uploadPath);
  },
  filename: function (req, file, cb) {
    const ext = path.parse(file.originalname).ext;
    const key = uuidV4();
    cb(null, key + ext);
  },
 });
 const upload = multer({ storage: storage });
 export default (app: Router) => {
-  app.use('/user', route);
+  app.use('/', route);
  route.post(
    '/login',
    rateLimit({
      windowMs: 15 * 60 * 1000,
      max: 100,
    }),
    celebrate({
      body: Joi.object({
        username: Joi.string().required(),
@@ -45,6 +25,7 @@ export default (app: Router) => {
        const data = await userService.login({ ...req.body }, req);
        return res.send(data);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -59,13 +40,14 @@ export default (app: Router) => {
        await userService.logout(req.platform);
        res.send({ code: 200 });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/',
+    '/user',
    celebrate({
      body: Joi.object({
        username: Joi.string().required(),
@@ -73,40 +55,41 @@ export default (app: Router) => {
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        if (isDemoEnv()) {
          return res.send({ code: 450, message: '未知错误' });
        }
        const userService = Container.get(UserService);
        await userService.updateUsernameAndPassword(req.body);
        res.send({ code: 200, message: '更新成功' });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
-  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
+  route.get(
-    const logger: Logger = Container.get('logger');
+    '/user',
-    try {
+    async (req: Request, res: Response, next: NextFunction) => {
-      const userService = Container.get(UserService);
+      const logger: Logger = Container.get('logger');
-      const authInfo = await userService.getAuthInfo();
+      try {
-      res.send({
+        const userService = Container.get(UserService);
-        code: 200,
+        const authInfo = await userService.getUserInfo();
-        data: {
+        res.send({
-          username: authInfo.username,
+          code: 200,
-          avatar: authInfo.avatar,
+          data: {
-          twoFactorActivated: authInfo.twoFactorActivated,
+            username: authInfo.username,
-        },
+            twoFactorActivated: authInfo.twoFactorActivated,
-      });
+          },
-    } catch (e) {
+        });
-      logger.error('🔥 error: %o', e);
+      } catch (e) {
-      return next(e);
+        logger.error('🔥 error: %o', e);
-    }
+        return next(e);
-  });
+      }
    },
  );
  route.get(
-    '/two-factor/init',
+    '/user/two-factor/init',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -114,13 +97,14 @@ export default (app: Router) => {
        const data = await userService.initTwoFactor();
        res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/two-factor/active',
+    '/user/two-factor/active',
    celebrate({
      body: Joi.object({
        code: Joi.string().required(),
@@ -133,13 +117,14 @@ export default (app: Router) => {
        const data = await userService.activeTwoFactor(req.body.code);
        res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/two-factor/deactive',
+    '/user/two-factor/deactive',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -147,13 +132,14 @@ export default (app: Router) => {
        const data = await userService.deactiveTwoFactor();
        res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/two-factor/login',
+    '/user/two-factor/login',
    celebrate({
      body: Joi.object({
        code: Joi.string().required(),
@@ -168,13 +154,14 @@ export default (app: Router) => {
        const data = await userService.twoFactorLogin(req.body, req);
        res.send(data);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/login-log',
+    '/user/login-log',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -182,13 +169,14 @@ export default (app: Router) => {
        const data = await userService.getLoginLog();
        res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
-    '/notification',
+    '/user/notification',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -196,13 +184,14 @@ export default (app: Router) => {
        const data = await userService.getNotificationMode();
        res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/notification',
+    '/user/notification',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -210,13 +199,46 @@ export default (app: Router) => {
        const result = await userService.updateNotificationMode(req.body);
        res.send(result);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
    '/system',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
        const authInfo = await userService.getUserInfo();
        const envDbContent = getFileContentByName(config.envDbFile);
        let isInitialized = true;
        if (
          Object.keys(authInfo).length === 2 &&
          authInfo.username === 'admin' &&
          authInfo.password === 'admin' &&
          envDbContent.length === 0
        ) {
          isInitialized = false;
        }
        res.send({
          code: 200,
          data: {
            isInitialized,
          },
        });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  // 初始化api
  route.put(
-    '/init',
+    '/init/user',
    celebrate({
      body: Joi.object({
        username: Joi.string().required(),
@@ -230,13 +252,14 @@ export default (app: Router) => {
        await userService.updateUsernameAndPassword(req.body);
        res.send({ code: 200, message: '更新成功' });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/notification/init',
+    '/init/notification',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
@@ -244,21 +267,74 @@ export default (app: Router) => {
        const result = await userService.updateNotificationMode(req.body);
        res.send(result);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.get(
    '/system/log/remove',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
        const data = await userService.getLogRemoveFrequency();
        res.send({ code: 200, data });
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
-    '/avatar',
+    '/system/log/remove',
-    upload.single('avatar'),
+    celebrate({
      body: Joi.object({
        frequency: Joi.number().required(),
      }),
    }),
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
-        const result = await userService.updateAvatar(req.file!.filename);
+        const result = await userService.updateLogRemoveFrequency(
          req.body.frequency,
        );
        res.send(result);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
    '/system/update-check',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
        const result = await userService.checkUpdate();
        res.send(result);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
  );
  route.put(
    '/system/update',
    async (req: Request, res: Response, next: NextFunction) => {
      const logger: Logger = Container.get('logger');
      try {
        const userService = Container.get(UserService);
        const result = await userService.updateSystem();
        res.send(result);
      } catch (e) {
        logger.error('🔥 error: %o', e);
        return next(e);
      }
    },
@@ -1,242 +1,34 @@
-import 'reflect-metadata';
+import 'reflect-metadata'; // We need this in order to use @Decorators
-import cluster, { type Worker } from 'cluster';
+
 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 express from 'express';
 import Logger from './loaders/logger';
 import { monitoringMiddleware } from './middlewares/monitoring';
 import { type GrpcServerService } from './services/grpc';
 import { type HttpServerService } from './services/http';
-interface WorkerMetadata {
+async function startServer() {
-  id: number;
+  const app = express();
-  pid: number;
+
-  serviceType: string;
+  await require('./loaders/sentry').default({ expressApp: app });
-  startTime: Date;
+
  await require('./loaders/db').default();
  await require('./loaders/app').default({ expressApp: app });
  const server = app
    .listen(config.port, () => {
      Logger.info(`
      ################################################
      🛡️  Server listening on port: ${config.port} 🛡️
      ################################################
    `);
    })
    .on('error', (err) => {
      Logger.error(err);
      process.exit(1);
    });
  await require('./loaders/server').default({ server });
 }
-class Application {
+startServer();
  private app: express.Application;
  private httpServerService?: HttpServerService;
  private grpcServerService?: GrpcServerService;
  private isShuttingDown = false;
  private workerMetadataMap = new Map<number, WorkerMetadata>();
  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();
      }
      if (cluster.isPrimary) {
        this.startMasterProcess();
      } else {
        await this.startWorkerProcess();
      }
    } catch (error) {
      Logger.error('Failed to start application:', error);
      process.exit(1);
    }
  }
  private startMasterProcess() {
    this.forkWorker('http');
    this.forkWorker('grpc');
    cluster.on('exit', (worker, code, signal) => {
      const metadata = this.workerMetadataMap.get(worker.id);
      if (metadata) {
        if (!this.isShuttingDown) {
          Logger.error(
            `${metadata.serviceType} worker ${worker.process.pid} died (${signal || code
            }). Restarting...`,
          );
          const newWorker = this.forkWorker(metadata.serviceType);
          Logger.info(
            `Restarted ${metadata.serviceType} worker (New PID: ${newWorker.process.pid})`,
          );
        }
        this.workerMetadataMap.delete(worker.id);
      }
    });
    this.setupMasterShutdown();
  }
  private forkWorker(serviceType: string): Worker {
    const worker = cluster.fork({ SERVICE_TYPE: serviceType });
    this.workerMetadataMap.set(worker.id, {
      id: worker.id,
      pid: worker.process.pid!,
      serviceType,
      startTime: new Date(),
    });
    return worker;
  }
  private async initializeDatabase() {
    const dbLoader = await import('./loaders/db');
    await dbLoader.default();
  }
  private setupMiddlewares() {
    this.app.use(helmet({
      contentSecurityPolicy: false,
    }));
    this.app.use(cors(config.cors));
    this.app.use(compression());
    this.app.use(monitoringMiddleware);
  }
  private setupMasterShutdown() {
    const shutdown = async () => {
      if (this.isShuttingDown) return;
      this.isShuttingDown = true;
      const workers = Object.values(cluster.workers || {});
      const workerPromises: Promise<void>[] = [];
      workers.forEach((worker) => {
        if (worker) {
          const exitPromise = new Promise<void>((resolve) => {
            worker.once('exit', () => {
              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}:`,
                error,
              );
            }
          });
          workerPromises.push(exitPromise);
        }
      });
      try {
        await Promise.race([
          Promise.all(workerPromises),
          new Promise<void>((resolve) => {
            setTimeout(() => {
              Logger.warn('Worker shutdown timeout reached');
              resolve();
            }, 10000);
          }),
        ]);
        process.exit(0);
      } catch (error) {
        Logger.error('Error during worker shutdown:', error);
        process.exit(1);
      }
    };
    process.on('SIGTERM', shutdown);
    process.on('SIGINT', shutdown);
  }
  private async startWorkerProcess() {
    const serviceType = process.env.SERVICE_TYPE;
    if (!serviceType || !['http', 'grpc'].includes(serviceType)) {
      Logger.error('Invalid SERVICE_TYPE:', serviceType);
      process.exit(1);
    }
    Logger.info(`✌️ ${serviceType} worker started (PID: ${process.pid})`);
    try {
      if (serviceType === 'http') {
        await this.startHttpService();
      } else {
        await this.startGrpcService();
      }
      process.send?.('ready');
    } catch (error) {
      Logger.error(`${serviceType} worker failed:`, error);
      process.exit(1);
    }
  }
  private async startHttpService() {
    this.setupMiddlewares();
    const { HttpServerService } = await import('./services/http');
    this.httpServerService = Container.get(HttpServerService);
    const appLoader = await import('./loaders/app');
    await appLoader.default({ app: this.app });
    const server = await this.httpServerService.initialize(
      this.app,
      config.port,
    );
    const serverLoader = await import('./loaders/server');
    await (serverLoader.default as any)({ server });
    this.setupWorkerShutdown('http');
  }
  private async startGrpcService() {
    const { GrpcServerService } = await import('./services/grpc');
    this.grpcServerService = Container.get(GrpcServerService);
    await this.grpcServerService.initialize();
    this.setupWorkerShutdown('grpc');
  }
  private setupWorkerShutdown(serviceType: string) {
    process.on('message', (msg) => {
      if (msg === 'shutdown') {
        this.gracefulShutdown(serviceType);
      }
    });
    const shutdown = () => this.gracefulShutdown(serviceType);
    process.on('SIGTERM', shutdown);
    process.on('SIGINT', shutdown);
  }
  private async gracefulShutdown(serviceType: string) {
    if (this.isShuttingDown) return;
    this.isShuttingDown = true;
    try {
      if (serviceType === 'http') {
        await this.httpServerService?.shutdown();
      } else {
        await this.grpcServerService?.shutdown();
      }
      process.exit(0);
    } catch (error) {
      Logger.error(`[${serviceType}] Error during shutdown:`, error);
      process.exit(1);
    }
  }
 }
 const app = new Application();
 app.start().catch((error) => {
  Logger.error('Application failed to start:', error);
  process.exit(1);
 });
@@ -1,51 +0,0 @@
 export const LOG_END_SYMBOL = '　　　　　';
 export const TASK_COMMAND = 'task';
 export const QL_COMMAND = 'ql';
 export const TASK_PREFIX = `${TASK_COMMAND} `;
 export const QL_PREFIX = `${QL_COMMAND} `;
 export const SAMPLE_FILES = [
  {
    title: 'config.sample.sh',
    value: 'sample/config.sample.sh',
    target: 'config.sh',
  },
  {
    title: 'notify.js',
    value: 'sample/notify.js',
    target: 'data/scripts/sendNotify.js',
  },
  {
    title: 'notify.py',
    value: 'sample/notify.py',
    target: 'data/scripts/notify.py',
  },
 ];
 export const PYTHON_INSTALL_DIR = process.env.PYTHON_HOME;
 export const NotificationModeStringMap = {
  0: 'gotify',
  1: 'goCqHttpBot',
  2: 'serverChan',
  3: 'pushDeer',
  4: 'bark',
  5: 'chat',
  6: 'telegramBot',
  7: 'dingtalkBot',
  8: 'weWorkBot',
  9: 'weWorkApp',
  10: 'aibotk',
  11: 'iGot',
  12: 'pushPlus',
  13: 'wePlusBot',
  14: 'email',
  15: 'pushMe',
  16: 'feishu',
  17: 'webhook',
  18: 'chronocat',
  19: 'ntfy',
  20: 'wxPusherBot',
 } as const;
@@ -1,68 +0,0 @@
 import { request as undiciRequest, Dispatcher } from 'undici';
 type RequestBaseOptions = {
  dispatcher?: Dispatcher;
  json?: Record<string, any>;
  form?: string;
  headers?: Record<string, string>;
 } & Omit<Dispatcher.RequestOptions<null>, 'origin' | 'path' | 'method'>;
 type RequestOptionsWithOptions = RequestBaseOptions &
  Partial<Pick<Dispatcher.RequestOptions, 'method'>>;
 type ResponseTypeMap = {
  json: Record<string, any>;
  text: string;
 };
 type ResponseTypeKey = keyof ResponseTypeMap;
 async function request(
  url: string,
  options?: RequestOptionsWithOptions,
 ): Promise<Dispatcher.ResponseData<null>> {
  const { json, form, body, headers = {}, ...rest } = options || {};
  const finalHeaders = { ...headers } as Record<string, string>;
  let finalBody = body;
  if (json) {
    finalHeaders['content-type'] = 'application/json';
    finalBody = JSON.stringify(json);
  } else if (form) {
    finalBody = form;
    delete finalHeaders['content-type'];
  }
  const res = await undiciRequest(url, {
    method: 'POST',
    headers: finalHeaders,
    body: finalBody,
    ...rest,
  });
  return res;
 }
 async function post<T extends ResponseTypeKey = 'json'>(
  url: string,
  options?: RequestBaseOptions & { responseType?: T },
 ): Promise<ResponseTypeMap[T]> {
  const resp = await request(url, { ...options, method: 'POST' });
  const rawText = await resp.body.text();
  if (options?.responseType === 'text') {
    return rawText as ResponseTypeMap[T];
  }
  try {
    return JSON.parse(rawText) as ResponseTypeMap[T];
  } catch {
    return rawText as ResponseTypeMap[T];
  }
 }
 export const httpClient = {
  post,
  request,
 };
@@ -1,127 +1,58 @@
 import dotenv from 'dotenv';
 import path from 'path';
-import { createRandomString } from './share';
+import { createRandomString } from './util';
-dotenv.config({
+process.env.NODE_ENV = process.env.NODE_ENV || 'development';
  path: path.join(__dirname, '../../.env'),
 });
-interface Config {
+const lastVersionFile =
-  port: number;
+  'https://ghproxy.com/https://raw.githubusercontent.com/whyour/qinglong/master/src/version.ts';
-  grpcPort: number;
+
-  nodeEnv: string;
+const envFound = dotenv.config();
-  isDevelopment: boolean;
+const rootPath = process.cwd();
-  isProduction: boolean;
+const envFile = path.join(rootPath, 'config/env.sh');
-  jwt: {
+const confFile = path.join(rootPath, 'config/config.sh');
-    secret: string;
+const sampleFile = path.join(rootPath, 'sample/config.sample.sh');
-    expiresIn?: string;
+const crontabFile = path.join(rootPath, 'config/crontab.list');
-  };
+const confBakDir = path.join(rootPath, 'config/bak/');
-  cors: {
+const authConfigFile = path.join(rootPath, 'config/auth.json');
-    origin: string[];
+const extraFile = path.join(rootPath, 'config/extra.sh');
-    methods: string[];
+const configPath = path.join(rootPath, 'config/');
-  };
+const scriptPath = path.join(rootPath, 'scripts/');
-  logs: {
+const bakPath = path.join(rootPath, 'bak/');
-    level: string;
+const samplePath = path.join(rootPath, 'sample/');
-  };
+const logPath = path.join(rootPath, 'log/');
-  api: {
+const authError = '错误的用户名密码，请重试';
-    prefix: string;
+const loginFaild = '请先登录!';
-  };
+const configString = 'config sample crontab shareCode diy';
 const dbPath = path.join(rootPath, 'db/');
 const cronDbFile = path.join(rootPath, 'db/crontab.db');
 const envDbFile = path.join(rootPath, 'db/env.db');
 const appDbFile = path.join(rootPath, 'db/app.db');
 const authDbFile = path.join(rootPath, 'db/auth.db');
 const dependenceDbFile = path.join(rootPath, 'db/dependence.db');
 const versionFile = path.join(rootPath, 'src/version.ts');
 const configFound = dotenv.config({ path: confFile });
 if (envFound.error) {
  throw new Error("⚠️  Couldn't find .env file  ⚠️");
 }
-const config: Config = {
+if (configFound.error) {
-  port: parseInt(process.env.BACK_PORT || '5700', 10),
+  throw new Error("⚠️  Couldn't find config.sh file  ⚠️");
-  grpcPort: parseInt(process.env.GRPC_PORT || '5500', 10),
+}
-  nodeEnv: process.env.NODE_ENV || 'development',
+
-  isDevelopment: process.env.NODE_ENV === 'development',
+export default {
-  isProduction: process.env.NODE_ENV === 'production',
+  port: parseInt(process.env.PORT as string, 10),
  cronPort: parseInt(process.env.CRON_PORT as string, 10),
  secret: process.env.SECRET || createRandomString(16, 32),
  logs: {
    level: process.env.LOG_LEVEL || 'silly',
  },
  api: {
    prefix: '/api',
  },
  jwt: {
    secret: process.env.JWT_SECRET || 'whyour-secret',
    expiresIn: process.env.JWT_EXPIRES_IN,
  },
  cors: {
    origin: process.env.CORS_ORIGIN
      ? process.env.CORS_ORIGIN.split(',')
      : ['*'],
    methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  },
 };
 process.env.NODE_ENV = process.env.NODE_ENV || 'development';
 if (!process.env.QL_DIR) {
  let qlHomePath = path.join(__dirname, '../../');
  if (qlHomePath.endsWith('/static/')) {
    qlHomePath = path.join(qlHomePath, '../');
  }
  process.env.QL_DIR = qlHomePath.replace(/\/$/g, '');
 }
 const lastVersionFile = `https://qn.whyour.cn/version.yaml`;
 const rootPath = process.env.QL_DIR as string;
 const envFound = dotenv.config({ path: path.join(rootPath, '.env') });
 let dataPath = path.join(rootPath, 'data/');
 if (process.env.QL_DATA_DIR) {
  dataPath = process.env.QL_DATA_DIR.replace(/\/$/g, '');
 }
 const shellPath = path.join(rootPath, 'shell/');
 const preloadPath = path.join(shellPath, 'preload/');
 const tmpPath = path.join(rootPath, '.tmp/');
 const samplePath = path.join(rootPath, 'sample/');
 const configPath = path.join(dataPath, 'config/');
 const scriptPath = path.join(dataPath, 'scripts/');
 const repoPath = path.join(dataPath, 'repo/');
 const bakPath = path.join(dataPath, 'bak/');
 const logPath = path.join(dataPath, 'log/');
 const dbPath = path.join(dataPath, 'db/');
 const uploadPath = path.join(dataPath, 'upload/');
 const sshdPath = path.join(dataPath, 'ssh.d/');
 const systemLogPath = path.join(dataPath, 'syslog/');
 const dependenceCachePath = path.join(dataPath, 'dep_cache/');
 const envFile = path.join(preloadPath, 'env.sh');
 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 confFile = path.join(configPath, 'config.sh');
 const crontabFile = path.join(configPath, 'crontab.list');
 const authConfigFile = path.join(configPath, 'auth.json');
 const extraFile = path.join(configPath, 'extra.sh');
 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');
 const shareShellFile = path.join(shellPath, 'share.sh');
 const dependenceProxyFile = path.join(configPath, 'dependence-proxy.sh');
 if (envFound.error) {
  throw new Error("⚠️  Couldn't find .env file  ⚠️");
 }
 export default {
  ...config,
  jwt: config.jwt,
  rootPath,
  tmpPath,
  dataPath,
  dataTgzFile,
  shareShellFile,
  dependenceProxyFile,
  configString,
  loginFaild,
  authError,
@@ -133,47 +64,32 @@ export default {
  sampleFile,
  confFile,
  envFile,
  jsEnvFile,
  pyEnvFile,
  jsNotifyFile,
  pyNotifyFile,
  dbPath,
-  uploadPath,
+  cronDbFile,
  envDbFile,
  appDbFile,
  authDbFile,
  dependenceDbFile,
  configPath,
  scriptPath,
  repoPath,
  samplePath,
  blackFileList: [
    'auth.json',
    'config.sh.sample',
    'cookie.sh',
    'crontab.list',
    'dependence-proxy.sh',
    'env.sh',
    'env.js',
    'env.py',
    'token.json',
  ],
  writePathList: [configPath, scriptPath],
  bakPath,
  apiWhiteList: [
-    '/api/user/login',
+    '/api/login',
    '/api/health',
    '/open/auth/token',
    '/api/user/two-factor/login',
    '/api/system',
-    '/api/user/init',
+    '/api/init/user',
-    '/api/user/notification/init',
+    '/api/init/notification',
    '/open/user/login',
    '/open/user/two-factor/login',
    '/open/system',
    '/open/user/init',
    '/open/user/notification/init',
  ],
  versionFile,
  lastVersionFile,
  sqliteFile,
  sshdPath,
  systemLogPath,
  dependenceCachePath,
 };
@@ -1,28 +0,0 @@
 import { Request, Response } from 'express';
 import pick from 'lodash/pick';
 let pickedEnv: Record<string, string>;
 function getPickedEnv() {
  if (pickedEnv) return pickedEnv;
  const picked = pick(process.env, ['QlBaseUrl', 'DeployEnv', 'QL_DIR']);
  if (picked.QlBaseUrl) {
    if (!picked.QlBaseUrl.startsWith('/')) {
      picked.QlBaseUrl = `/${picked.QlBaseUrl}`;
    }
    if (!picked.QlBaseUrl.endsWith('/')) {
      picked.QlBaseUrl = `${picked.QlBaseUrl}/`;
    }
  }
  pickedEnv = picked as Record<string, string>;
  return picked;
 }
 export function serveEnv(_req: Request, res: Response) {
  res.type('.js');
  res.send(
    Object.entries(getPickedEnv())
      .map(([k, v]) => `window.__ENV__${k}=${JSON.stringify(v)};`)
      .join('\n'),
  );
 }
@@ -1,84 +0,0 @@
 export function createRandomString(min: number, max: number): string {
  const num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
  const english = [
    'a',
    'b',
    'c',
    'd',
    'e',
    'f',
    'g',
    'h',
    'i',
    'j',
    'k',
    'l',
    'm',
    'n',
    'o',
    'p',
    'q',
    'r',
    's',
    't',
    'u',
    'v',
    'w',
    'x',
    'y',
    'z',
  ];
  const ENGLISH = [
    'A',
    'B',
    'C',
    'D',
    'E',
    'F',
    'G',
    'H',
    'I',
    'J',
    'K',
    'L',
    'M',
    'N',
    'O',
    'P',
    'Q',
    'R',
    'S',
    'T',
    'U',
    'V',
    'W',
    'X',
    'Y',
    'Z',
  ];
  const special = ['-', '_'];
  const config = num.concat(english).concat(ENGLISH).concat(special);
  const arr = [];
  arr.push(getOne(num));
  arr.push(getOne(english));
  arr.push(getOne(ENGLISH));
  arr.push(getOne(special));
  const len = min + Math.floor(Math.random() * (max - min + 1));
  for (let i = 4; i < len; i++) {
    arr.push(config[Math.floor(Math.random() * config.length)]);
  }
  const newArr = [];
  for (let j = 0; j < len; j++) {
    newArr.push(arr.splice(Math.random() * arr.length, 1)[0]);
  }
  function getOne(arr: any[]) {
    return arr[Math.floor(Math.random() * arr.length)];
  }
  return newArr.join('');
 }
@@ -1,46 +0,0 @@
 import { Subscription } from '../data/subscription';
 import isNil from 'lodash/isNil';
 export function formatUrl(doc: Subscription) {
  let url = doc.url;
  let host = '';
  if (doc.type === 'private-repo') {
    if (doc.pull_type === 'ssh-key') {
      host = doc.url!.replace(/.*\@([^\:]+)\:.*/, '$1');
      url = doc.url!.replace(host, doc.alias);
    } else {
      host = doc.url!.replace(/.*\:\/\/([^\/]+)\/.*/, '$1');
      const { username, password } = doc.pull_option as any;
      url = doc.url!.replace(host, `${username}:${password}@${host}`);
    }
  }
  return { url, host };
 }
 export function formatCommand(doc: Subscription, url?: string) {
  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,40 +1,24 @@
-import * as fs from 'fs/promises';
+import * as fs from 'fs';
 import * as path from 'path';
-import { exec } from 'child_process';
+import got from 'got';
-import psTreeFun from 'ps-tree';
+import iconv from 'iconv-lite';
 import { promisify } from 'util';
 import { load } from 'js-yaml';
 import config from './index';
 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';
-export * from './share';
+export function getFileContentByName(fileName: string) {
-
+  if (fs.existsSync(fileName)) {
-export async function getFileContentByName(fileName: string) {
+    return fs.readFileSync(fileName, 'utf8');
  const _exsit = await fileExist(fileName);
  if (_exsit) {
    return await fs.readFile(fileName, 'utf8');
  }
  return '';
 }
-export function removeAnsi(text: string) {
+export function getLastModifyFilePath(dir: string) {
  return text.replace(/\x1b\[\d+m/g, '');
 }
 export async function getLastModifyFilePath(dir: string) {
  let filePath = '';
-  const _exsit = await fileExist(dir);
+  if (fs.existsSync(dir)) {
-  if (_exsit) {
+    const arr = fs.readdirSync(dir);
    const arr = await fs.readdir(dir);
-    arr.forEach(async (item) => {
+    arr.forEach((item) => {
      const fullpath = path.join(dir, item);
-      const stats = await fs.lstat(fullpath);
+      const stats = fs.statSync(fullpath);
      if (stats.isFile()) {
        if (stats.mtimeMs >= 0) {
          filePath = fullpath;
@@ -45,6 +29,91 @@ export async function getLastModifyFilePath(dir: string) {
  return filePath;
 }
 export function createRandomString(min: number, max: number): string {
  const num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
  const english = [
    'a',
    'b',
    'c',
    'd',
    'e',
    'f',
    'g',
    'h',
    'i',
    'j',
    'k',
    'l',
    'm',
    'n',
    'o',
    'p',
    'q',
    'r',
    's',
    't',
    'u',
    'v',
    'w',
    'x',
    'y',
    'z',
  ];
  const ENGLISH = [
    'A',
    'B',
    'C',
    'D',
    'E',
    'F',
    'G',
    'H',
    'I',
    'J',
    'K',
    'L',
    'M',
    'N',
    'O',
    'P',
    'Q',
    'R',
    'S',
    'T',
    'U',
    'V',
    'W',
    'X',
    'Y',
    'Z',
  ];
  const special = ['-', '_'];
  const config = num.concat(english).concat(ENGLISH).concat(special);
  const arr = [];
  arr.push(getOne(num));
  arr.push(getOne(english));
  arr.push(getOne(ENGLISH));
  arr.push(getOne(special));
  const len = min + Math.floor(Math.random() * (max - min + 1));
  for (let i = 4; i < len; i++) {
    arr.push(config[Math.floor(Math.random() * config.length)]);
  }
  const newArr = [];
  for (let j = 0; j < len; j++) {
    newArr.push(arr.splice(Math.random() * arr.length, 1)[0]);
  }
  function getOne(arr) {
    return arr[Math.floor(Math.random() * arr.length)];
  }
  return newArr.join('');
 }
 export function getToken(req: any) {
  const { authorization = '' } = req.headers;
  if (authorization && authorization.split(' ')[0] === 'Bearer') {
@@ -56,6 +125,69 @@ export function getToken(req: any) {
  return '';
 }
 export async function getNetIp(req: any) {
  const ipArray = [
    ...new Set([
      ...(req.headers['x-real-ip'] || '').split(','),
      ...(req.headers['x-forwarded-for'] || '').split(','),
      req.ip,
      ...req.ips,
      req.socket.remoteAddress,
    ]),
  ];
  let ip = ipArray[0];
  if (ipArray.length > 1) {
    for (let i = 0; i < ipArray.length; i++) {
      const ipNumArray = ipArray[i].split('.');
      const tmp = ipNumArray[0] + '.' + ipNumArray[1];
      if (
        tmp === '192.168' ||
        (ipNumArray[0] === '172' &&
          ipNumArray[1] >= 16 &&
          ipNumArray[1] <= 32) ||
        tmp === '10.7' ||
        tmp === '127.0'
      ) {
        continue;
      }
      ip = ipArray[i];
      break;
    }
  }
  ip = ip.substr(ip.lastIndexOf(':') + 1, ip.length);
  if (ip.includes('127.0') || ip.includes('192.168') || ip.includes('10.7')) {
    ip = '';
  }
  try {
    const baiduApi = got
      .get(`https://www.cip.cc/${ip}`, { timeout: 10000, retry: 0 })
      .text();
    const ipApi = got
      .get(`https://whois.pconline.com.cn/ipJson.jsp?ip=${ip}&json=true`, {
        timeout: 10000,
        retry: 0,
      })
      .buffer();
    const [data, ipApiBody] = await await Promise.all<any>([baiduApi, ipApi]);
    const ipRegx = /.*IP	:(.*)\n/;
    const addrRegx = /.*数据二	:(.*)\n/;
    if (data && ipRegx.test(data) && addrRegx.test(data)) {
      const ip = data.match(ipRegx)[1];
      const addr = data.match(addrRegx)[1];
      return { address: addr, ip };
    } else if (ipApiBody) {
      const { addr, ip } = JSON.parse(iconv.decode(ipApiBody, 'GBK'));
      return { address: `${addr}`, ip };
    } else {
      return { address: `获取失败`, ip };
    }
  } catch (error) {
    return { address: `获取失败`, ip };
  }
 }
 export function getPlatform(userAgent: string): 'mobile' | 'desktop' {
  const ua = userAgent.toLowerCase();
  const testUa = (regexp: RegExp) => regexp.test(ua);
@@ -77,19 +209,12 @@ export function getPlatform(userAgent: string): 'mobile' | 'desktop' {
    system = 'android'; // android系统
  } else if (testUa(/ios|iphone|ipad|ipod|iwatch/g)) {
    system = 'ios'; // ios系统
  } else if (testUa(/openharmony/g)) {
    system = 'openharmony'; // openharmony系统
  }
  let platform = 'desktop';
  if (system === 'windows' || system === 'macos' || system === 'linux') {
    platform = 'desktop';
-  } else if (
+  } else if (system === 'android' || system === 'ios' || testUa(/mobile/g)) {
    system === 'android' ||
    system === 'ios' ||
    system === 'openharmony' ||
    testUa(/mobile/g)
  ) {
    platform = 'mobile';
  }
@@ -97,475 +222,12 @@ export function getPlatform(userAgent: string): 'mobile' | 'desktop' {
 }
 export async function fileExist(file: any) {
-  try {
+  return new Promise((resolve) => {
    await fs.access(file);
    return true;
  } catch (error) {
    return false;
  }
 }
 export async function createFile(file: string, data: string = '') {
  await fs.mkdir(path.dirname(file), { recursive: true });
  await writeFileWithLock(file, data);
 }
 export async function handleLogPath(
  logPath: string,
  data: string = '',
 ): Promise<string> {
  const absolutePath = path.resolve(config.logPath, logPath);
  const logFileExist = await fileExist(absolutePath);
  if (!logFileExist) {
    await createFile(absolutePath, data);
  }
  return absolutePath;
 }
 export async function concurrentRun(
  fnList: Array<() => Promise<any>> = [],
  max = 5,
 ) {
  if (!fnList.length) return;
  const replyList: any[] = []; // 收集任务执行结果
  const startTime = new Date().getTime(); // 记录任务执行开始时间
  // 任务执行程序
  const schedule = async (index: number) => {
    return new Promise(async (resolve) => {
      const fn = fnList[index];
      if (!fn) return resolve(null);
      // 执行当前异步任务
      const reply = await fn();
      replyList[index] = reply;
      // 执行完当前任务后，继续执行任务池的剩余任务
      await schedule(index + max);
      resolve(null);
    });
  };
  // 任务池执行程序
  const scheduleList = new Array(max)
    .fill(0)
    .map((_, index) => schedule(index));
  // 使用 Promise.all 批量执行
  const r = await Promise.all(scheduleList);
  const cost = (new Date().getTime() - startTime) / 1000;
  return replyList;
 }
 enum FileType {
  'directory',
  'file',
 }
 export interface IFile {
  title: string;
  key: string;
  type: 'directory' | 'file';
  parent: string;
  createTime: number;
  size?: number;
  children?: IFile[];
 }
 export function dirSort(a: IFile, b: IFile): number {
  if (a.type === 'file' && b.type === 'file') {
    return b.createTime - a.createTime;
  } else if (a.type === 'directory' && b.type === 'directory') {
    return a.title.localeCompare(b.title);
  } else {
    return a.type === 'directory' ? -1 : 1;
  }
 }
 export async function readDirs(
  dir: string,
  baseDir: string = '',
  blacklist: string[] = [],
  sort: (a: IFile, b: IFile) => number = dirSort,
 ): Promise<IFile[]> {
  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(
  dir: string,
  baseDir: string = '',
  blacklist: string[] = [],
 ): Promise<IFile[]> {
  const absoluteDir = path.join(baseDir, dir);
  const relativePath = path.relative(baseDir, absoluteDir);
  try {
    const files = await fs.readdir(absoluteDir);
    const result: IFile[] = [];
    for (const file of files) {
      const subPath = path.join(absoluteDir, file);
      const stats = await fs.lstat(subPath);
      const key = path.join(relativePath, file);
      if (blacklist.includes(file) || stats.isSymbolicLink()) {
        continue;
      }
      if (stats.isDirectory()) {
        result.push({
          title: file,
          type: 'directory',
          key,
          parent: relativePath,
          createTime: stats.birthtime.getTime(),
          children: [],
        });
      } else {
        result.push({
          title: file,
          type: 'file',
          key,
          parent: relativePath,
          size: stats.size,
          createTime: stats.birthtime.getTime(),
        });
      }
    }
    return result;
  } catch (error: any) {
    if (error.code === 'ENOENT') {
      return [];
    }
    throw error;
  }
 }
 export async function promiseExec(command: string): Promise<string> {
  try {
    const { stderr, stdout } = await promisify(exec)(command, {
      maxBuffer: 200 * 1024 * 1024,
      encoding: 'utf8',
    });
    return stdout || stderr;
  } catch (error) {
    return JSON.stringify(error);
  }
 }
 export async function promiseExecSuccess(command: string): Promise<string> {
  try {
    const { stdout } = await promisify(exec)(command, {
      maxBuffer: 200 * 1024 * 1024,
      encoding: 'utf8',
    });
    return stdout || '';
  } catch (error) {
    return '';
  }
 }
 export function parseHeaders(headers: string) {
  if (!headers) return {};
  const parsed: any = {};
  let key: string;
  let val: string;
  let i: number;
  headers &&
    headers.split('\n').forEach(function parser(line) {
      i = line.indexOf(':');
      key = line.substring(0, i).trim().toLowerCase();
      val = line.substring(i + 1).trim();
      if (!key) {
        return;
      }
      parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
    });
  return parsed;
 }
 function parseString(
  input: string,
  valueFormatFn?: (v: string) => string,
 ): Record<string, string> {
  const regex = /(\w+):\s*((?:(?!\n\w+:).)*)/g;
  const matches: Record<string, string> = {};
  let match;
  while ((match = regex.exec(input)) !== null) {
    const [, key, value] = match;
    const _key = key.trim();
    if (!_key || matches[_key]) {
      continue;
    }
    let _value = value.trim();
    try {
-      _value = valueFormatFn ? valueFormatFn(_value) : _value;
+      fs.accessSync(file);
-      const jsonValue = JSON.parse(_value);
+      resolve(true);
      matches[_key] = jsonValue;
    } catch (error) {
-      matches[_key] = _value;
+      resolve(false);
    }
  }
  return matches;
 }
 export function parseBody(
  body: string,
  contentType:
    | 'application/json'
    | 'multipart/form-data'
    | 'application/x-www-form-urlencoded'
    | 'text/plain',
  valueFormatFn?: (v: string) => string,
 ) {
  if (contentType === 'text/plain' || !body) {
    return valueFormatFn && body ? valueFormatFn(body) : body;
  }
  const parsed = parseString(body, valueFormatFn);
  switch (contentType) {
    case 'multipart/form-data':
      return Object.keys(parsed).reduce((p, c) => {
        p.append(c, parsed[c]);
        return p;
      }, new FormData());
    case 'application/x-www-form-urlencoded':
      return Object.keys(parsed).reduce((p, c) => {
        return p ? `${p}&${c}=${parsed[c]}` : `${c}=${parsed[c]}`;
      });
  }
  return parsed;
 }
 export function psTree(pid: number): Promise<number[]> {
  return new Promise((resolve, reject) => {
    psTreeFun(pid, (err: any, children) => {
      if (err) {
        reject(err);
      }
      resolve(children.map((x) => Number(x.PID)).filter((x) => !isNaN(x)));
    });
  });
 }
 export async function killTask(pid: number) {
  const pids = await psTree(pid);
  if (pids.length) {
    try {
      [pid, ...pids].reverse().forEach((x) => {
        process.kill(x, 15);
      });
    } catch (error) {}
  } else {
    process.kill(pid, 2);
  }
 }
 export async function getPid(cmd: string) {
  const taskCommand = `ps -eo pid,command | grep "${cmd}" | grep -v grep | awk '{print $1}' | head -1 | xargs echo -n`;
  const pid = await promiseExec(taskCommand);
  return pid ? Number(pid) : undefined;
 }
 interface IVersion {
  version: string;
  changeLogLink: string;
  changeLog: string;
  publishTime: string;
 }
 export async function parseVersion(path: string): Promise<IVersion> {
  return load(await fs.readFile(path, 'utf8')) as IVersion;
 }
 export function parseContentVersion(content: string): IVersion {
  return load(content) as IVersion;
 }
 export async function getUniqPath(
  command: string,
  id: string,
 ): Promise<string> {
  let suffix = '';
  if (/^\d+$/.test(id)) {
    suffix = `_${id}`;
  }
  let items = command.split(/ +/);
  const maxTimeCommandIndex = items.findIndex((x) => x === '-m');
  if (maxTimeCommandIndex !== -1) {
    items = items.slice(maxTimeCommandIndex + 2);
  }
  let str = items[0];
  if (items[0] === TASK_COMMAND) {
    str = items[1];
  }
  const dotIndex = str.lastIndexOf('.');
  if (dotIndex !== -1) {
    str = str.slice(0, dotIndex);
  }
  const slashIndex = str.lastIndexOf('/');
  let tempStr = '';
  if (slashIndex !== -1) {
    tempStr = str.slice(0, slashIndex);
    const _slashIndex = tempStr.lastIndexOf('/');
    if (_slashIndex !== -1) {
      tempStr = tempStr.slice(_slashIndex + 1);
    }
    str = `${tempStr}_${str.slice(slashIndex + 1)}`;
  }
  return `${str}${suffix}`;
 }
 export function safeJSONParse(value?: string) {
  if (!value) {
    return {};
  }
  try {
    return JSON.parse(value);
  } catch (error) {
    Logger.error('[safeJSONParse失败]', error);
    return {};
  }
 }
 export async function rmPath(path: string) {
  try {
    const _exsit = await fileExist(path);
    if (_exsit) {
      await fs.rm(path, { force: true, recursive: true, maxRetries: 5 });
    }
  } catch (error) {
    Logger.error('[rmPath失败]', error);
  }
 }
 export async function setSystemTimezone(timezone: string): Promise<boolean> {
  try {
    if (!(await fileExist(`/usr/share/zoneinfo/${timezone}`))) {
      throw new Error('Invalid 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);
    return false;
  }
 }
 export function getGetCommand(type: DependenceTypes, name: string): string {
  const baseCommands = {
    [DependenceTypes.nodejs]: `pnpm ls -g  | grep "${name}" | head -1`,
    [DependenceTypes.python3]: `
    python3 -c "exec('''
 name='${name}'
 try:
    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]: `apk info -es ${name}`,
  };
  return baseCommands[type];
 }
 export function getInstallCommand(type: DependenceTypes, name: string): string {
  const baseCommands = {
    [DependenceTypes.nodejs]: 'pnpm add -g',
    [DependenceTypes.python3]:
      'pip3 install --disable-pip-version-check --root-user-action=ignore',
    [DependenceTypes.linux]: 'apk add --no-check-certificate',
  };
  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 {
  const baseCommands = {
    [DependenceTypes.nodejs]: 'pnpm remove -g',
    [DependenceTypes.python3]:
      'pip3 uninstall --disable-pip-version-check --root-user-action=ignore -y',
    [DependenceTypes.linux]: 'apk del',
  };
  return `${baseCommands[type]} ${name.trim()}`;
 }
 export function isDemoEnv() {
  return process.env.DeployEnv === 'demo';
 }
@@ -0,0 +1,25 @@
 export class AuthInfo {
  ip?: string;
  type: AuthDataType;
  info?: any;
  _id?: string;
  constructor(options: AuthInfo) {
    this.ip = options.ip;
    this.info = options.info;
    this.type = options.type;
    this._id = options._id;
  }
 }
 export enum LoginStatus {
  'success',
  'fail',
 }
 export enum AuthDataType {
  'loginLog' = 'loginLog',
  'authToken' = 'authToken',
  'notification' = 'notification',
  'removeLogFrequency' = 'removeLogFrequency',
 }
@@ -1,90 +1,40 @@
 import { sequelize } from '.';
 import { DataTypes, Model, ModelDefined } from 'sequelize';
 export class Crontab {
  name?: string;
  command: string;
-  schedule?: string;
+  schedule: string;
  timestamp?: string;
  created?: number;
  saved?: boolean;
-  id?: number;
+  _id?: string;
  status?: CrontabStatus;
  isSystem?: 1 | 0;
  pid?: number;
  isDisabled?: 1 | 0;
  log_path?: string;
  isPinned?: 1 | 0;
  labels?: string[];
  last_running_time?: number;
  last_execution_time?: number;
  sub_id?: number;
  extra_schedules?: Array<{ schedule: string }>;
  task_before?: string;
  task_after?: string;
  log_name?: string;
  constructor(options: Crontab) {
    this.name = options.name;
-    this.command = options.command.trim();
+    this.command = options.command;
    this.schedule = options.schedule;
    this.saved = options.saved;
-    this.id = options.id;
+    this._id = options._id;
-    this.status =
+    this.created = options.created;
-      typeof options.status === 'number' && CrontabStatus[options.status]
+    this.status = CrontabStatus[options.status]
-        ? options.status
+      ? options.status
-        : CrontabStatus.idle;
+      : CrontabStatus.idle;
    this.timestamp = new Date().toString();
    this.isSystem = options.isSystem || 0;
    this.pid = options.pid;
    this.isDisabled = options.isDisabled || 0;
    this.log_path = options.log_path || '';
    this.isPinned = options.isPinned || 0;
    this.labels = options.labels || [];
    this.last_running_time = options.last_running_time || 0;
    this.last_execution_time = options.last_execution_time || 0;
    this.sub_id = options.sub_id;
    this.extra_schedules = options.extra_schedules;
    this.task_before = options.task_before;
    this.task_after = options.task_after;
    this.log_name = options.log_name;
  }
 }
 export enum CrontabStatus {
-  'running' = 0,
+  'running',
-  'queued' = 0.5,
+  'idle',
  'idle' = 1,
  'disabled',
  'queued',
 }
 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,
 });
@@ -1,62 +0,0 @@
 import { sequelize } from '.';
 import { DataTypes, Model } from 'sequelize';
 export enum CronViewType {
  '系统' = 1,
  '个人',
 }
 interface SortType {
  type: 'ASC' | 'DESC';
  value: string;
 }
 interface FilterType {
  property: string;
  operation: string;
  value: string;
 }
 export class CrontabView {
  name?: string;
  id?: number;
  position?: number;
  isDisabled?: 1 | 0;
  filters?: FilterType[];
  sorts?: SortType[];
  filterRelation?: 'and' | 'or';
  type?: CronViewType;
  constructor(options: CrontabView) {
    this.name = options.name;
    this.id = options.id;
    this.position = options.position;
    this.isDisabled = options.isDisabled || 0;
    this.filters = options.filters;
    this.sorts = options.sorts;
    this.filterRelation = options.filterRelation;
    this.type = options.type || CronViewType.个人;
  }
 }
 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,24 +1,20 @@
 import { sequelize } from '.';
 import { DataTypes, Model, ModelDefined } from 'sequelize';
 export class Dependence {
  timestamp?: string;
-  id?: number;
+  created?: number;
-  status: DependenceStatus;
+  _id?: string;
-  type: DependenceTypes;
+  status?: DependenceStatus;
-  name: string;
+  type?: DependenceTypes;
  name?: number;
  log?: string[];
  remark?: string;
  constructor(options: Dependence) {
-    this.id = options.id;
+    this._id = options._id;
-    this.status =
+    this.created = options.created || new Date().valueOf();
-      typeof options.status === 'number' && DependenceStatus[options.status]
+    this.status = options.status || DependenceStatus.installing;
        ? options.status
        : DependenceStatus.queued;
    this.type = options.type || DependenceTypes.nodejs;
    this.timestamp = new Date().toString();
-    this.name = options.name.trim();
+    this.name = options.name;
    this.log = options.log || [];
    this.remark = options.remark || '';
  }
@@ -31,8 +27,6 @@ export enum DependenceStatus {
  'removing',
  'removed',
  'removeFailed',
  'queued',
  'cancelled',
 }
 export enum DependenceTypes {
@@ -41,23 +35,14 @@ export enum DependenceTypes {
  'linux',
 }
-export enum versionDependenceCommandTypes {
+export enum InstallDependenceCommandTypes {
-  '@',
+  'npm i -g --force',
-  '==',
+  'pip3 install',
-  '=',
+  'apk add --no-cache -f',
 }
-export interface DependenceInstance
+export enum unInstallDependenceCommandTypes {
-  extends Model<Dependence, Dependence>,
+  'npm uninstall -g --force',
-    Dependence {}
+  'pip3 uninstall -y',
-export const DependenceModel = sequelize.define<DependenceInstance>(
+  'apk del -f',
-  'Dependence',
+}
  {
    name: DataTypes.STRING,
    type: DataTypes.NUMBER,
    timestamp: DataTypes.STRING,
    status: DataTypes.NUMBER,
    log: DataTypes.JSON,
    remark: DataTypes.STRING,
  },
 );
@@ -1,28 +1,22 @@
 import { DataTypes, Model } from 'sequelize';
 import { sequelize } from '.';
 export class Env {
  value?: string;
  timestamp?: string;
-  id?: number;
+  created?: number;
  _id?: string;
  status?: EnvStatus;
  position?: number;
-  name?: string;
+  name?: number;
-  remarks?: string;
+  remarks?: number;
  isPinned?: 1 | 0;
  constructor(options: Env) {
    this.value = options.value;
-    this.id = options.id;
+    this._id = options._id;
-    this.status =
+    this.created = options.created || new Date().valueOf();
-      typeof options.status === 'number' && EnvStatus[options.status]
+    this.status = options.status || EnvStatus.normal;
        ? options.status
        : EnvStatus.normal;
    this.timestamp = new Date().toString();
    this.position = options.position;
    this.name = options.name;
-    this.remarks = options.remarks || '';
+    this.remarks = options.remarks;
    this.isPinned = options.isPinned || 0;
  }
 }
@@ -31,18 +25,4 @@ export enum EnvStatus {
  'disabled',
 }
-export const maxPosition = 9000000000000000;
+export const initEnvPosition = 9999999999;
 export const initPosition = 4500000000000000;
 export const stepPosition = 10000000000;
 export const minPosition = 100;
 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,23 +0,0 @@
 import { Sequelize, Transaction } from 'sequelize';
 import config from '../config/index';
 import { join } from 'path';
 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 };
@@ -1,37 +1,20 @@
 export enum NotificationMode {
  'gotify' = 'gotify',
  'goCqHttpBot' = 'goCqHttpBot',
  'serverChan' = 'serverChan',
  'pushDeer' = 'pushDeer',
  'bark' = 'bark',
  'chat' = 'chat',
  'telegramBot' = 'telegramBot',
  'dingtalkBot' = 'dingtalkBot',
  'weWorkBot' = 'weWorkBot',
  'weWorkApp' = 'weWorkApp',
  'aibotk' = 'aibotk',
  'iGot' = 'iGot',
  'pushPlus' = 'pushPlus',
  'wePlusBot' = 'wePlusBot',
  'email' = 'email',
  'pushMe' = 'pushMe',
  'feishu' = 'feishu',
  'webhook' = 'webhook',
  'chronocat' = 'Chronocat',
  'ntfy' = 'ntfy',
  'wxPusherBot' = 'wxPusherBot',
 }
 abstract class NotificationBaseInfo {
  public type!: NotificationMode;
 }
 export class GotifyNotification extends NotificationBaseInfo {
  public gotifyUrl = '';
  public gotifyToken = '';
  public gotifyPriority = 0;
 }
 export class GoCqHttpBotNotification extends NotificationBaseInfo {
  public goCqHttpBotUrl = '';
  public goCqHttpBotToken = '';
@@ -42,23 +25,10 @@ export class ServerChanNotification extends NotificationBaseInfo {
  public serverChanKey = '';
 }
 export class PushDeerNotification extends NotificationBaseInfo {
  public pushDeerKey = '';
  public pushDeerUrl = '';
 }
 export class synologyChatNotification extends NotificationBaseInfo {
  public synologyChatUrl = '';
 }
 export class BarkNotification extends NotificationBaseInfo {
  public barkPush = '';
  public barkIcon = 'https://qn.whyour.cn/logo.png';
  public barkSound = '';
  public barkGroup = 'qinglong';
  public barkLevel = 'active';
  public barkUrl = '';
  public barkArchive = '';
 }
 export class TelegramBotNotification extends NotificationBaseInfo {
@@ -67,7 +37,7 @@ export class TelegramBotNotification extends NotificationBaseInfo {
  public telegramBotProxyHost = '';
  public telegramBotProxyPort = '';
  public telegramBotProxyAuth = '';
-  public telegramBotApiHost = 'https://api.telegram.org';
+  public telegramBotApiHost = 'api.telegram.org';
 }
 export class DingtalkBotNotification extends NotificationBaseInfo {
@@ -77,18 +47,10 @@ export class DingtalkBotNotification extends NotificationBaseInfo {
 export class WeWorkBotNotification extends NotificationBaseInfo {
  public weWorkBotKey = '';
  public weWorkOrigin = '';
 }
 export class WeWorkAppNotification extends NotificationBaseInfo {
  public weWorkAppKey = '';
  public weWorkOrigin = '';
 }
 export class AibotkNotification extends NotificationBaseInfo {
  public aibotkKey: string = '';
  public aibotkType: 'room' | 'contact' = 'room';
  public aibotkName: string = '';
 }
 export class IGotNotification extends NotificationBaseInfo {
@@ -98,87 +60,22 @@ export class IGotNotification extends NotificationBaseInfo {
 export class PushPlusNotification extends NotificationBaseInfo {
  public pushPlusToken = '';
  public pushPlusUser = '';
  public pushPlusTemplate = '';
  public pushplusChannel = '';
  public pushplusWebhook = '';
  public pushplusCallbackUrl = '';
  public pushplusTo = '';
 }
 export class WePlusBotNotification extends NotificationBaseInfo {
  public wePlusBotToken = '';
  public wePlusBotReceiver = '';
  public wePlusBotVersion = '';
 }
 export class EmailNotification extends NotificationBaseInfo {
  public emailService: string = '';
  public emailUser: string = '';
  public emailPass: string = '';
  public emailTo: string = '';
 }
 export class PushMeNotification extends NotificationBaseInfo {
  public pushMeKey: string = '';
  public pushMeUrl: string = '';
 }
 export class ChronocatNotification extends NotificationBaseInfo {
  public chronocatURL: string = '';
  public chronocatQQ: string = '';
  public chronocatToken: string = '';
 }
 export class WebhookNotification extends NotificationBaseInfo {
  public webhookHeaders: string = '';
  public webhookBody: string = '';
  public webhookUrl: string = '';
  public webhookMethod: 'GET' | 'POST' | 'PUT' = 'GET';
  public webhookContentType:
    | 'application/json'
    | 'multipart/form-data'
    | 'application/x-www-form-urlencoded' = 'application/json';
 }
 export class LarkNotification extends NotificationBaseInfo {
  public larkKey = '';
 }
 export class NtfyNotification extends NotificationBaseInfo {
  public ntfyUrl = '';
  public ntfyTopic = '';
  public ntfyPriority = '';
  public ntfyToken = '';
  public ntfyUsername = '';
  public ntfyPassword = '';
  public ntfyActions = '';
 }
 export class WxPusherBotNotification extends NotificationBaseInfo {
  public wxPusherBotAppToken = '';
  public wxPusherBotTopicIds = '';
  public wxPusherBotUids = '';
 }
 export interface NotificationInfo
  extends GoCqHttpBotNotification,
    GotifyNotification,
    ServerChanNotification,
    PushDeerNotification,
    synologyChatNotification,
    BarkNotification,
    TelegramBotNotification,
    DingtalkBotNotification,
    WeWorkBotNotification,
    WeWorkAppNotification,
    AibotkNotification,
    IGotNotification,
    PushPlusNotification,
-    WePlusBotNotification,
+    EmailNotification {}
    EmailNotification,
    PushMeNotification,
    WebhookNotification,
    ChronocatNotification,
    LarkNotification,
    NtfyNotification,
    WxPusherBotNotification {}
@@ -1,36 +1,31 @@
 import { sequelize } from '.';
 import { DataTypes, Model, ModelDefined } from 'sequelize';
 export class App {
  name: string;
  scopes: AppScope[];
  client_id: string;
  client_secret: string;
  tokens?: AppToken[];
-  id?: number;
+  _id?: string;
  constructor(options: App) {
    this.name = options.name;
    this.scopes = options.scopes;
    this.client_id = options.client_id;
    this.client_secret = options.client_secret;
-    this.id = options.id;
+    this._id = options._id;
  }
 }
 export interface AppToken {
  value: string;
-  type?: 'Bearer';
+  type: 'Bearer';
  expiration: number;
 }
-export type AppScope = 'envs' | 'crons' | 'configs' | 'scripts' | 'logs' | 'system';
+export type AppScope = 'envs' | 'crons' | 'configs' | 'scripts' | 'logs';
-export interface AppInstance extends Model<App, App>, App {}
+export enum CrontabStatus {
-export const AppModel = sequelize.define<AppInstance>('App', {
+  'running',
-  name: { type: DataTypes.STRING, unique: 'name' },
+  'idle',
-  scopes: DataTypes.JSON,
+  'disabled',
-  client_id: DataTypes.STRING,
+  'queued',
-  client_secret: DataTypes.STRING,
+}
  tokens: DataTypes.JSON,
 });
@@ -1,123 +0,0 @@
 import { sequelize } from '.';
 import { DataTypes, Model } from 'sequelize';
 export class Scenario {
  id?: number;
  name: string;
  description?: string;
  isEnabled?: 1 | 0;
  workflowGraph?: any; // Flowgram workflow graph structure
  triggerType?: string; // Deprecated: kept for backward compatibility
  triggerConfig?: any; // Deprecated: kept for backward compatibility
  conditionLogic?: 'AND' | 'OR'; // Deprecated: kept for backward compatibility
  conditions?: any[]; // Deprecated: kept for backward compatibility
  actions?: any[]; // Deprecated: kept for backward compatibility
  retryStrategy?: {
    maxRetries: number;
    retryDelay: number; // in seconds
    backoffMultiplier?: number;
    errorTypes?: string[];
  };
  failureThreshold?: number; // Auto-disable after N consecutive failures
  consecutiveFailures?: number;
  delayExecution?: number; // Delay in seconds after trigger
  lastTriggeredAt?: Date;
  lastExecutedAt?: Date;
  executionCount?: number;
  failureCount?: number;
  successCount?: number;
  createdAt?: Date;
  updatedAt?: Date;
  constructor(options: Scenario) {
    this.id = options.id;
    this.name = options.name;
    this.description = options.description;
    this.isEnabled = options.isEnabled ?? 1;
    this.workflowGraph = options.workflowGraph || null;
    this.triggerType = options.triggerType;
    this.triggerConfig = options.triggerConfig;
    this.conditionLogic = options.conditionLogic || 'AND';
    this.conditions = options.conditions || [];
    this.actions = options.actions || [];
    this.retryStrategy = options.retryStrategy;
    this.failureThreshold = options.failureThreshold || 3;
    this.consecutiveFailures = options.consecutiveFailures || 0;
    this.delayExecution = options.delayExecution || 0;
    this.lastTriggeredAt = options.lastTriggeredAt;
    this.lastExecutedAt = options.lastExecutedAt;
    this.executionCount = options.executionCount || 0;
    this.failureCount = options.failureCount || 0;
    this.successCount = options.successCount || 0;
    this.createdAt = options.createdAt;
    this.updatedAt = options.updatedAt;
  }
 }
 export interface ScenarioInstance extends Model<Scenario, Scenario>, Scenario {}
 export const ScenarioModel = sequelize.define<ScenarioInstance>('Scenario', {
  name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
  description: DataTypes.TEXT,
  isEnabled: {
    type: DataTypes.NUMBER,
    defaultValue: 1,
  },
  workflowGraph: {
    type: DataTypes.JSON,
    allowNull: true,
  },
  triggerType: {
    type: DataTypes.STRING,
    allowNull: true,
  },
  triggerConfig: {
    type: DataTypes.JSON,
    allowNull: true,
  },
  conditionLogic: {
    type: DataTypes.STRING,
    defaultValue: 'AND',
  },
  conditions: {
    type: DataTypes.JSON,
    defaultValue: [],
  },
  actions: {
    type: DataTypes.JSON,
    defaultValue: [],
  },
  retryStrategy: {
    type: DataTypes.JSON,
    allowNull: true,
  },
  failureThreshold: {
    type: DataTypes.NUMBER,
    defaultValue: 3,
  },
  consecutiveFailures: {
    type: DataTypes.NUMBER,
    defaultValue: 0,
  },
  delayExecution: {
    type: DataTypes.NUMBER,
    defaultValue: 0,
  },
  lastTriggeredAt: DataTypes.DATE,
  lastExecutedAt: DataTypes.DATE,
  executionCount: {
    type: DataTypes.NUMBER,
    defaultValue: 0,
  },
  failureCount: {
    type: DataTypes.NUMBER,
    defaultValue: 0,
  },
  successCount: {
    type: DataTypes.NUMBER,
    defaultValue: 0,
  },
 });
@@ -1,58 +0,0 @@
 import { sequelize } from '.';
 import { DataTypes, Model } from 'sequelize';
 export class ScenarioLog {
  id?: number;
  scenarioId: number;
  scenarioName?: string;
  triggerData?: any; // The data that triggered the scenario
  conditionsMatched?: boolean;
  executionStatus?: 'success' | 'failure' | 'partial';
  executionDetails?: any; // Details about actions executed
  errorMessage?: string;
  executionTime?: number; // Time taken in milliseconds
  retriesAttempted?: number;
  createdAt?: Date;
  constructor(options: ScenarioLog) {
    this.id = options.id;
    this.scenarioId = options.scenarioId;
    this.scenarioName = options.scenarioName;
    this.triggerData = options.triggerData;
    this.conditionsMatched = options.conditionsMatched;
    this.executionStatus = options.executionStatus;
    this.executionDetails = options.executionDetails;
    this.errorMessage = options.errorMessage;
    this.executionTime = options.executionTime;
    this.retriesAttempted = options.retriesAttempted || 0;
    this.createdAt = options.createdAt;
  }
 }
 export interface ScenarioLogInstance
  extends Model<ScenarioLog, ScenarioLog>,
    ScenarioLog {}
 export const ScenarioLogModel = sequelize.define<ScenarioLogInstance>(
  'ScenarioLog',
  {
    scenarioId: {
      type: DataTypes.NUMBER,
      allowNull: false,
    },
    scenarioName: DataTypes.STRING,
    triggerData: DataTypes.JSON,
    conditionsMatched: DataTypes.BOOLEAN,
    executionStatus: {
      type: DataTypes.STRING,
      allowNull: false,
    },
    executionDetails: DataTypes.JSON,
    errorMessage: DataTypes.TEXT,
    executionTime: DataTypes.NUMBER,
    retriesAttempted: {
      type: DataTypes.NUMBER,
      defaultValue: 0,
    },
  },
 );
@@ -1,7 +1,7 @@
 export class SockMessage {
  message?: string;
  type?: SockMessageType;
-  references?: number[];
+  references?: string[];
  constructor(options: SockMessage) {
    this.type = options.type;
@@ -13,10 +13,4 @@ export class SockMessage {
 export type SockMessageType =
  | 'ping'
  | 'installDependence'
-  | 'uninstallDependence'
+  | 'updateSystemVersion';
  | 'updateSystemVersion'
  | 'manuallyRunScript'
  | 'runSubscriptionEnd'
  | 'reloadSystem'
  | 'updateNodeMirror'
  | 'updateLinuxMirror';
@@ -1,115 +0,0 @@
 import { sequelize } from '.';
 import { DataTypes, Model, ModelDefined } from 'sequelize';
 import { SimpleIntervalSchedule } from 'toad-scheduler';
 type SimpleIntervalScheduleUnit = keyof SimpleIntervalSchedule;
 export class Subscription {
  id?: number;
  name?: string;
  type?: 'public-repo' | 'private-repo' | 'file';
  schedule_type?: 'crontab' | 'interval';
  schedule?: string;
  interval_schedule?: { type: SimpleIntervalScheduleUnit; value: number };
  url?: string;
  whitelist?: string;
  blacklist?: string;
  dependences?: string;
  branch?: string;
  status?: SubscriptionStatus;
  pull_type?: 'ssh-key' | 'user-pwd';
  pull_option?:
    | { private_key: string }
    | { username: string; password: string };
  pid?: number;
  is_disabled?: 1 | 0;
  log_path?: string;
  alias: string;
  command?: string;
  extensions?: string;
  sub_before?: string;
  sub_after?: string;
  proxy?: string;
  autoAddCron?: 1 | 0;
  autoDelCron?: 1 | 0;
  constructor(options: Subscription) {
    this.id = options.id;
    this.name = options.name || options.alias;
    this.type = options.type;
    this.schedule = options.schedule;
    this.status = this.status =
      typeof options.status === 'number' && SubscriptionStatus[options.status]
        ? options.status
        : SubscriptionStatus.idle;
    this.url = options.url;
    this.whitelist = options.whitelist;
    this.blacklist = options.blacklist;
    this.dependences = options.dependences;
    this.branch = options.branch;
    this.pull_type = options.pull_type;
    this.pull_option = options.pull_option;
    this.pid = options.pid;
    this.is_disabled = options.is_disabled;
    this.log_path = options.log_path;
    this.schedule_type = options.schedule_type;
    this.alias = options.alias;
    this.interval_schedule = options.interval_schedule;
    this.extensions = options.extensions;
    this.sub_before = options.sub_before;
    this.sub_after = options.sub_after;
    this.proxy = options.proxy;
    this.autoAddCron = options.autoAddCron ? 1 : 0;
    this.autoDelCron = options.autoDelCron ? 1 : 0;
  }
 }
 export enum SubscriptionStatus {
  'running',
  'idle',
  'disabled',
  'queued',
 }
 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,82 +0,0 @@
 import { sequelize } from '.';
 import { DataTypes, Model, ModelDefined } from 'sequelize';
 import { NotificationInfo } from './notify';
 export class SystemInfo {
  ip?: string;
  type: AuthDataType;
  info?: SystemModelInfo;
  id?: number;
  constructor(options: SystemInfo) {
    this.ip = options.ip;
    this.info = options.info;
    this.type = options.type;
    this.id = options.id;
  }
 }
 export enum LoginStatus {
  'success',
  'fail',
 }
 export enum AuthDataType {
  'loginLog' = 'loginLog',
  'authToken' = 'authToken',
  'notification' = 'notification',
  'removeLogFrequency' = 'removeLogFrequency',
  'systemConfig' = 'systemConfig',
  'authConfig' = 'authConfig',
 }
 export interface SystemConfigInfo {
  logRemoveFrequency?: number;
  cronConcurrency?: number;
  dependenceProxy?: string;
  nodeMirror?: string;
  pythonMirror?: string;
  linuxMirror?: string;
  timezone?: string;
 }
 export interface LoginLogInfo {
  timestamp?: number;
  address?: string;
  ip?: string;
  platform?: string;
  status?: LoginStatus;
 }
 export interface AuthInfo {
  username: string;
  password: string;
  retries: number;
  lastlogon: number;
  lastip: string;
  lastaddr: string;
  platform: string;
  isTwoFactorChecking: boolean;
  token: string;
  tokens: Record<string, string>;
  twoFactorActivated: boolean;
  twoFactorSecret: string;
  avatar: string;
 }
 export type SystemModelInfo = SystemConfigInfo &
  Partial<NotificationInfo> &
  LoginLogInfo &
  Partial<AuthInfo>;
 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,
  },
 });
@@ -0,0 +1,5 @@
 declare namespace Express {
  interface Request {
    platform: 'desktop' | 'mobile';
  }
 }
@@ -1,13 +0,0 @@
 export enum ScheduleType {
  BOOT = '@boot',
  ONCE = '@once',
 }
 export type ScheduleValidator = (schedule?: string) => boolean;
 export type CronSchedulerPayload = {
  name: string;
  id: string;
  schedule: string;
  command: string;
  extra_schedules: Array<{ schedule: string }>;
 };
@@ -1,28 +1,18 @@
 import expressLoader from './express';
-import depInjectorLoader from './depInjector';
+import dependencyInjectorLoader from './dependencyInjector';
 import Logger from './logger';
 import initData from './initData';
 import { Application } from 'express';
 import linkDeps from './deps';
 import initTask from './initTask';
 import initFile from './initFile';
-export default async ({ app }: { app: Application }) => {
+export default async ({ expressApp }: { expressApp: Application }) => {
-  depInjectorLoader();
+  await dependencyInjectorLoader({
-  Logger.info('✌️ Dependency loaded');
+    models: [],
  });
  Logger.info('✌️ Dependency Injector loaded');
-  await linkDeps();
+  await expressLoader({ app: expressApp });
-  Logger.info('✌️ Link deps loaded');
+  Logger.info('✌️ Express loaded');
  initFile();
  Logger.info('✌️ Init file loaded');
  await initData();
-  Logger.info('✌️ Init data loaded');
+  Logger.info('✌️ init data loaded');
  initTask();
  Logger.info('✌️ Init task loaded');
  expressLoader({ app });
  Logger.info('✌️ Express loaded');
 };
@@ -1,8 +0,0 @@
 import Container from 'typedi';
 import CronService from '../services/cron';
 export default async () => {
  const cronService = Container.get(CronService);
  await cronService.bootTask();
 };
@@ -1,76 +1,63 @@
 import DataStore from 'nedb';
 import config from '../config';
 import Logger from './logger';
-import { EnvModel } from '../data/env';
+import fs from 'fs';
-import { CrontabModel } from '../data/cron';
+import { fileExist } from '../config/util';
 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 { ScenarioModel } from '../data/scenario';
 import { ScenarioLogModel } from '../data/scenarioLog';
 import { sequelize } from '../data';
 interface Dbs {
  cronDb: DataStore;
  dependenceDb: DataStore;
  envDb: DataStore;
  appDb: DataStore;
  authDb: DataStore;
 }
 const db: Dbs = {} as any;
 async function truncateDb() {
  return new Promise(async (resolve) => {
    const files = [
      config.cronDbFile,
      config.dependenceDbFile,
      config.envDbFile,
      config.appDbFile,
      config.authDbFile,
    ];
    for (const file of files) {
      const _fileExist = await fileExist(file);
      if (_fileExist && fs.statSync(file).size >= 1024 * 1024 * 500) {
        fs.truncateSync(file, 1024 * 1024 * 500);
      }
    }
    resolve(null);
  });
 }
 export default async () => {
  try {
-    await CrontabModel.sync();
+    await truncateDb();
    await DependenceModel.sync();
    await AppModel.sync();
    await SystemModel.sync();
    await EnvModel.sync();
    await SubscriptionModel.sync();
    await CrontabViewModel.sync();
    await ScenarioModel.sync();
    await ScenarioLogModel.sync();
-    // 初始化新增字段
+    db.cronDb = new DataStore({ filename: config.cronDbFile, autoload: true });
-    try {
+    db.dependenceDb = new DataStore({
-      await sequelize.query(
+      filename: config.dependenceDbFile,
-        'alter table CrontabViews add column filterRelation VARCHAR(255)',
+      autoload: true,
-      );
+    });
-    } catch (error) {}
+    db.envDb = new DataStore({ filename: config.envDbFile, autoload: true });
-    try {
+    db.appDb = new DataStore({ filename: config.appDbFile, autoload: true });
-      await sequelize.query(
+    db.authDb = new DataStore({ filename: config.authDbFile, autoload: true });
-        'alter table Subscriptions add column proxy VARCHAR(255)',
+
-      );
+    // compaction data file
-    } catch (error) {}
+    db.cronDb.persistence.compactDatafile();
-    try {
+    db.envDb.persistence.compactDatafile();
-      await sequelize.query('alter table CrontabViews add column type NUMBER');
+    db.dependenceDb.persistence.compactDatafile();
-    } catch (error) {}
+    db.appDb.persistence.compactDatafile();
-    try {
+    db.authDb.persistence.compactDatafile();
      await sequelize.query(
        'alter table Subscriptions add column autoAddCron NUMBER',
      );
    } catch (error) {}
    try {
      await sequelize.query(
        'alter table Subscriptions add column autoDelCron NUMBER',
      );
    } catch (error) {}
    try {
      await sequelize.query('alter table Crontabs add column sub_id NUMBER');
    } catch (error) {}
    try {
      await sequelize.query(
        'alter table Crontabs add column extra_schedules JSON',
      );
    } catch (error) {}
    try {
      await sequelize.query('alter table Crontabs add column task_before TEXT');
    } catch (error) {}
    try {
      await sequelize.query('alter table Crontabs add column task_after TEXT');
    } catch (error) {}
    try {
      await sequelize.query(
        'alter table Crontabs add column log_name VARCHAR(255)',
      );
    } catch (error) { }
    try {
      await sequelize.query('alter table Envs add column isPinned NUMBER');
    } catch (error) {}
    Logger.info('✌️ DB loaded');
  } catch (error) {
-    Logger.error('✌️ DB load failed', error);
+    Logger.info('✌️ DB load failed');
    Logger.info(error);
  }
 };
 export const dbs: Dbs = db;
@@ -1,8 +1,12 @@
 import { Container } from 'typedi';
 import LoggerInstance from './logger';
-export default () => {
+export default ({ models }: { models: { name: string; model: any }[] }) => {
  try {
    models.forEach((m) => {
      Container.set(m.name, m.model);
    });
    Container.set('logger', LoggerInstance);
  } catch (e) {
    LoggerInstance.error('🔥 Error on dependency injector loader: %o', e);
@@ -1,63 +0,0 @@
 import path from 'path';
 import fs from 'fs/promises';
 import chokidar from 'chokidar';
 import config from '../config/index';
 import { fileExist, promiseExec, rmPath } from '../config/util';
 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 commandPath = await promiseExec('which node');
  const commandDir = path.dirname(commandPath);
  const linkShell = [
    {
      src: 'update.sh',
      dest: 'ql',
      tmp: 'ql_tmp',
    },
    {
      src: 'task.sh',
      dest: 'task',
      tmp: 'task_tmp',
    },
  ];
  for (const link of linkShell) {
    const source = path.join(config.rootPath, 'shell', link.src);
    const target = path.join(commandDir, link.dest);
    const tmpTarget = path.join(commandDir, link.tmp);
    try {
      const stats = await fs.lstat(tmpTarget);
      if (stats) {
        await fs.unlink(tmpTarget);
      }
    } catch (error) { }
    await fs.symlink(source, tmpTarget);
    await fs.rename(tmpTarget, target);
  }
 }
 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));
 };
@@ -1,34 +1,41 @@
-import express, { Request, Response, NextFunction, Application } from 'express';
+import { Request, Response, NextFunction, Application } from 'express';
 import bodyParser from 'body-parser';
 import cors from 'cors';
 import routes from '../api';
 import config from '../config';
-import { UnauthorizedError, expressjwt } from 'express-jwt';
+import jwt from 'express-jwt';
-import { getPlatform, getToken } from '../config/util';
+import fs from 'fs';
 import { getFileContentByName, getPlatform, getToken } from '../config/util';
 import Container from 'typedi';
 import OpenService from '../services/open';
 import rewrite from 'express-urlrewrite';
-import { errors } from 'celebrate';
+import UserService from '../services/user';
-import { serveEnv } from '../config/serverEnv';
+import handler from 'serve-handler';
-import { IKeyvStore, shareStore } from '../shared/store';
+import * as Sentry from '@sentry/node';
 import path from 'path';
 export default ({ app }: { app: Application }) => {
-  app.set('trust proxy', 'loopback');
+  app.enable('trust proxy');
  app.use(cors());
  app.get(`${config.api.prefix}/env.js`, serveEnv);
  app.use(`${config.api.prefix}/static`, express.static(config.uploadPath));
  app.use((req, res, next) => {
    if (req.path.startsWith('/api') || req.path.startsWith('/open')) {
      next();
    } else {
      return handler(req, res, {
        public: 'dist',
        rewrites: [{ source: '**', destination: '/index.html' }],
      });
    }
  });
  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({
+    jwt({
-      secret: config.jwt.secret,
+      secret: config.secret as string,
      algorithms: ['HS384'],
    }).unless({
-      path: [...config.apiWhiteList, /^\/(?!api\/).*/],
+      path: [...config.apiWhiteList, /^\/open\//],
    }),
  );
@@ -42,17 +49,11 @@ export default ({ app }: { app: Application }) => {
    return next();
  });
-  app.use(async (req: Request, res, next) => {
+  app.use(async (req, 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 openService = Container.get(OpenService);
-      const doc = apps?.filter((x) =>
+      const doc = await openService.findTokenByValue(headerToken);
        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]+)\/*/);
@@ -67,43 +68,49 @@ export default ({ app }: { app: Application }) => {
      }
    }
    const originPath = `${req.baseUrl}${req.path === '/' ? '' : req.path}`;
    if (
      !headerToken &&
-      originPath &&
+      req.path &&
-      config.apiWhiteList.includes(originPath)
+      config.apiWhiteList.includes(req.path) &&
      req.path !== '/api/crons/status'
    ) {
      return next();
    }
    const remoteAddress = req.socket.remoteAddress;
    if (
      remoteAddress === '::ffff:127.0.0.1' &&
      req.path === '/api/crons/status'
    ) {
      return next();
    }
-    const authInfo = await shareStore.getAuthInfo();
+    const data = fs.readFileSync(config.authConfigFile, 'utf8');
-    if (authInfo && headerToken) {
+    if (data) {
-      const { token = '', tokens = {} } = authInfo;
+      const { token = '', tokens = {} } = JSON.parse(data);
      if (headerToken === token || tokens[req.platform] === headerToken) {
        return next();
      }
    }
-    const errorCode = headerToken ? 'invalid_token' : 'credentials_required';
+    const err: any = new Error('UnauthorizedError');
-    const errorMessage = headerToken
+    err.status = 401;
      ? '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)) {
+    if (!['/api/init/user', '/api/init/notification'].includes(req.path)) {
      return next();
    }
-    const authInfo =
+    const userService = Container.get(UserService);
-      (await shareStore.getAuthInfo()) || ({} as IKeyvStore['authInfo']);
+    const authInfo = await userService.getUserInfo();
    const envDbContent = getFileContentByName(config.envDbFile);
    let isInitialized = true;
    if (
      Object.keys(authInfo).length === 2 &&
      authInfo.username === 'admin' &&
-      authInfo.password === 'admin'
+      authInfo.password === 'admin' &&
      envDbContent.length === 0
    ) {
      isInitialized = false;
    }
@@ -118,18 +125,13 @@ export default ({ app }: { app: Application }) => {
  app.use(rewrite('/open/*', '/api/$1'));
  app.use(config.api.prefix, routes());
-  app.get('*', (_, res, next) => {
+  app.use((req, res, next) => {
-    const indexPath = path.join(frontendPath, 'index.html');
+    const err: any = new Error('Not Found');
-    res.sendFile(indexPath, (err) => {
+    err['status'] = 404;
-      if (err) {
+    next(err);
        const err: any = new Error('Not Found');
        err['status'] = 404;
        next(err);
      }
    });
  });
-  app.use(errors());
+  app.use(Sentry.Handlers.errorHandler());
  app.use(
    (
@@ -148,27 +150,6 @@ export default ({ app }: { app: Application }) => {
    },
  );
  app.use(
    (
      err: Error & { errors: any[] },
      req: Request,
      res: Response,
      next: NextFunction,
    ) => {
      if (err.name.includes('Sequelize')) {
        return res
          .status(500)
          .send({
            code: 400,
            message: `${err.message}`,
            errors: err.errors,
          })
          .end();
      }
      return next(err);
    },
  );
  app.use(
    (
      err: Error & { status: number },
@@ -176,6 +157,8 @@ export default ({ app }: { app: Application }) => {
      res: Response,
      next: NextFunction,
    ) => {
      Sentry.captureException(err);
      res.status(err.status || 500);
      res.json({
        code: err.status || 500,
@@ -1,223 +1,91 @@
 import DependenceService from '../services/dependence';
 import { exec } from 'child_process';
 import { Container } from 'typedi';
-import { Crontab, CrontabModel, CrontabStatus } from '../data/cron';
+import { Crontab, CrontabStatus } from '../data/cron';
 import CronService from '../services/cron';
 import EnvService from '../services/env';
-import { DependenceModel, DependenceStatus } from '../data/dependence';
+import _ from 'lodash';
-import { Op } from 'sequelize';
+import { dbs } from '../loaders/db';
 import config from '../config';
 import { CrontabViewModel, CronViewType } from '../data/cronView';
 import { initPosition } from '../data/env';
 import { AuthDataType, SystemModel } from '../data/system';
 import SystemService from '../services/system';
 import UserService from '../services/user';
 import { writeFile, readFile } from 'fs/promises';
 import { createRandomString, fileExist, safeJSONParse } from '../config/util';
 import OpenService from '../services/open';
 import { shareStore } from '../shared/store';
 import Logger from './logger';
 import { AppModel } from '../data/open';
 export default async () => {
  const cronService = Container.get(CronService);
  const envService = Container.get(EnvService);
  const dependenceService = Container.get(DependenceService);
-  const systemService = Container.get(SystemService);
+  const cronDb = dbs.cronDb;
-  const userService = Container.get(UserService);
+  const dependenceDb = dbs.dependenceDb;
  const openService = Container.get(OpenService);
  // 初始化增加系统配置
  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.findOrCreate({
    where: { type: AuthDataType.notification },
  });
  const [authConfig] = await SystemModel.findOrCreate({
    where: { type: AuthDataType.authConfig },
  });
  if (!authConfig?.info) {
    let authInfo = {
      username: 'admin',
      password: 'admin',
    };
    try {
      const authFileExist = await fileExist(config.authConfigFile);
      if (authFileExist) {
        const content = await readFile(config.authConfigFile, 'utf8');
        authInfo = safeJSONParse(content);
      }
    } catch (error) {
      Logger.warn('Failed to read auth config file, using default credentials');
    }
    await SystemModel.upsert({
      id: authConfig?.id,
      info: authInfo,
      type: AuthDataType.authConfig,
    });
  }
  const installDependencies = async () => {
    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({
      pythonMirror: systemConfig.info?.pythonMirror,
    });
  }
  if (systemConfig.info?.linuxMirror) {
    systemService.updateLinuxMirror(
      {
        linuxMirror: systemConfig.info?.linuxMirror,
      },
      undefined,
      () => installDependencies(),
    );
  } else {
    installDependencies();
  }
  if (systemConfig.info?.nodeMirror) {
    systemService.updateNodeMirror({
      nodeMirror: systemConfig.info?.nodeMirror,
    });
  }
  // 初始化新增默认全部任务视图
  CrontabViewModel.findAll({
    where: { type: CronViewType.系统, name: '全部任务' },
    raw: true,
  }).then((docs) => {
    if (docs.length === 0) {
      CrontabViewModel.create({
        name: '全部任务',
        type: CronViewType.系统,
        position: initPosition / 2,
      });
    }
  });
  // 初始化更新所有任务状态为空闲
-  await CrontabModel.update({ status: CrontabStatus.idle }, { where: {} });
+  cronDb.update(
    { status: { $in: [CrontabStatus.running, CrontabStatus.queued] } },
    { $set: { status: CrontabStatus.idle } },
    { multi: true },
  );
-  // 初始化时执行一次所有的 ql repo 任务
+  // 初始化时安装所有处于安装中，安装成功，安装失败的依赖
-  CrontabModel.findAll({
+  dependenceDb.find({ status: { $in: [0, 1, 2] } }).exec((err, docs) => {
-    where: {
+    const groups = _.groupBy(docs, 'type');
-      isDisabled: { [Op.ne]: 1 },
+    for (const key in groups) {
-      command: {
+      if (Object.prototype.hasOwnProperty.call(groups, key)) {
-        [Op.or]: [{ [Op.like]: `%ql repo%` }, { [Op.like]: `%ql raw%` }],
+        const group = groups[key];
-      },
+        const depIds = group.map((x) => x._id);
-    },
+        for (const dep of depIds) {
-  }).then((docs) => {
+          dependenceService.reInstall([dep]);
-    for (let i = 0; i < docs.length; i++) {
+        }
      const doc = docs[i];
      if (doc) {
        exec(doc.command);
      }
    }
  });
-  // 更新2.11.3以前的脚本路径
+  // 初始化时执行一次所有的ql repo 任务
-  CrontabModel.findAll({
+  cronDb
-    where: {
+    .find({
-      command: {
+      command: /ql (repo|raw)/,
-        [Op.or]: [
+      isDisabled: { $ne: 1 },
-          { [Op.like]: `%\/${config.rootPath}\/scripts\/%` },
+    })
-          { [Op.like]: `%\/${config.rootPath}\/config\/%` },
+    .exec((err, docs) => {
-          { [Op.like]: `%\/${config.rootPath}\/log\/%` },
+      for (let i = 0; i < docs.length; i++) {
-          { [Op.like]: `%\/${config.rootPath}\/db\/%` },
+        const doc = docs[i];
-        ],
+        if (doc) {
-      },
+          exec(doc.command);
    },
  }).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.update(
            { command: doc.command.replace(`${config.rootPath}/scripts/`, '') },
            { where: { id: doc.id } },
          );
        }
        if (doc.command.includes(`${config.rootPath}/log/`)) {
          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.update(
            {
              command: `${config.dataPath}/config/${doc.command.replace(
                `${config.rootPath}/config/`,
                '',
              )}`,
            },
            { where: { id: doc.id } },
          );
        }
        if (doc.command.includes(`${config.rootPath}/db/`)) {
          await CrontabModel.update(
            {
              command: `${config.dataPath}/db/${doc.command.replace(
                `${config.rootPath}/db/`,
                '',
              )}`,
            },
            { where: { id: doc.id } },
          );
        }
      }
-    }
+    });
-  });
+
  // patch 禁用状态字段改变
  cronDb
    .find({
      status: CrontabStatus.disabled,
    })
    .exec((err, docs) => {
      if (docs.length > 0) {
        const ids = docs.map((x) => x._id);
        cronDb.update(
          { _id: { $in: ids } },
          { $set: { status: CrontabStatus.idle, isDisabled: 1 } },
          { multi: true },
          (err) => {
            cronService.autosave_crontab();
          },
        );
      }
    });
  // 初始化保存一次ck和定时任务数据
  await cronService.autosave_crontab();
  await envService.set_envs();
  const authInfo = await userService.getAuthInfo();
  const apps = await openService.findApps();
  await shareStore.updateAuthInfo(authInfo);
  if (apps?.length) {
    await shareStore.updateApps(apps);
  }
 };
 function randomSchedule(from: number, to: number) {
  const result: any[] = [];
  const arr = [...Array(from).keys()];
  let count = arr.length;
  for (let i = 0; i < to; i++) {
    const index = ~~(Math.random() * count) + i;
    if (result.includes(arr[index])) {
      continue;
    }
    result[i] = arr[index];
    arr[index] = arr[i];
    count--;
  }
  return result;
 }
@@ -1,127 +0,0 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import Logger from './logger';
 import { fileExist } from '../config/util';
 import { writeFileWithLock } from '../shared/utils';
 const rootPath = process.env.QL_DIR as string;
 let dataPath = path.join(rootPath, 'data/');
 if (process.env.QL_DATA_DIR) {
  dataPath = process.env.QL_DATA_DIR.replace(/\/$/g, '');
 }
 const preloadPath = path.join(rootPath, 'shell/preload/');
 const configPath = path.join(dataPath, 'config/');
 const scriptPath = path.join(dataPath, 'scripts/');
 const logPath = path.join(dataPath, 'log/');
 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 confFile = path.join(configPath, 'config.sh');
 const sampleConfigFile = path.join(samplePath, 'config.sample.sh');
 const sampleTaskShellFile = path.join(samplePath, 'task.sample.sh');
 const sampleNotifyJsFile = path.join(samplePath, 'notify.js');
 const sampleNotifyPyFile = path.join(samplePath, 'notify.py');
 const scriptNotifyJsFile = path.join(scriptPath, 'sendNotify.js');
 const scriptNotifyPyFile = path.join(scriptPath, 'notify.py');
 const jsNotifyFile = path.join(preloadPath, '__ql_notify__.js');
 const pyNotifyFile = path.join(preloadPath, '__ql_notify__.py');
 const TaskBeforeFile = path.join(configPath, 'task_before.sh');
 const TaskBeforeJsFile = path.join(configPath, 'task_before.js');
 const TaskBeforePyFile = path.join(configPath, 'task_before.py');
 const TaskAfterFile = path.join(configPath, 'task_after.sh');
 const homedir = os.homedir();
 const sshPath = path.resolve(homedir, '.ssh');
 const sshdPath = path.join(dataPath, 'ssh.d');
 const systemLogPath = path.join(dataPath, 'syslog');
 const directories = [
  configPath,
  scriptPath,
  preloadPath,
  logPath,
  tmpPath,
  uploadPath,
  sshPath,
  bakPath,
  sshdPath,
  systemLogPath,
 ];
 const files = [
  {
    target: confFile,
    source: sampleConfigFile,
    checkExistence: true,
  },
  {
    target: jsNotifyFile,
    source: sampleNotifyJsFile,
    checkExistence: false,
  },
  {
    target: pyNotifyFile,
    source: sampleNotifyPyFile,
    checkExistence: false,
  },
  {
    target: scriptNotifyJsFile,
    source: sampleNotifyJsFile,
    checkExistence: true,
  },
  {
    target: scriptNotifyPyFile,
    source: sampleNotifyPyFile,
    checkExistence: true,
  },
  {
    target: TaskBeforeFile,
    source: sampleTaskShellFile,
    checkExistence: true,
  },
  {
    target: TaskBeforeJsFile,
    content:
      '// The JavaScript code that executes before the JavaScript task execution will execute.',
    checkExistence: true,
  },
  {
    target: TaskBeforePyFile,
    content:
      '# The Python code that executes before the Python task execution will execute.',
    checkExistence: true,
  },
  {
    target: TaskAfterFile,
    source: sampleTaskShellFile,
    checkExistence: true,
  },
 ];
 export default async () => {
  for (const dirPath of directories) {
    if (!(await fileExist(dirPath))) {
      await fs.mkdir(dirPath);
    }
  }
  for (const item of files) {
    const exists = await fileExist(item.target);
    if (!item.checkExistence || !exists) {
      if (!item.content && !item.source) {
        throw new Error(
          `Neither content nor source specified for ${item.target}`,
        );
      }
      const content =
        item.content ||
        (await fs.readFile(item.source!, { encoding: 'utf-8' }));
      await writeFileWithLock(item.target, content);
    }
  }
  Logger.info('✌️ Init file down');
 };
@@ -1,67 +0,0 @@
 import { Container } from 'typedi';
 import SystemService from '../services/system';
 import ScheduleService, { ScheduleTaskType } from '../services/schedule';
 import SubscriptionService from '../services/subscription';
 import config from '../config';
 import { fileExist } from '../config/util';
 import { join } from 'path';
 export default async () => {
  const systemService = Container.get(SystemService);
  const scheduleService = Container.get(ScheduleService);
  const subscriptionService = Container.get(SubscriptionService);
  // 生成内置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}`;
  }
  const cron = {
    id: NaN,
    name: '生成token',
    command: tokenCommand,
    runOrigin: 'system',
  } as ScheduleTaskType;
  await scheduleService.cancelIntervalTask(cron);
  scheduleService.createIntervalTask(
    cron,
    {
      days: 28,
    },
    true,
  );
  // 运行删除日志任务
  const data = await systemService.getSystemConfig();
  if (data && data.info) {
    if (data.info.logRemoveFrequency) {
      const rmlogCron = {
        id: data.id as number,
        name: '删除日志',
        command: `ql rmlog ${data.info.logRemoveFrequency}`,
        runOrigin: 'system' as const,
      };
      await scheduleService.cancelIntervalTask(rmlogCron);
      scheduleService.createIntervalTask(
        rmlogCron,
        {
          days: data.info.logRemoveFrequency,
        },
        true,
      );
    }
    systemService.updateTimezone(data.info);
  }
  await subscriptionService.setSshConfig();
  const subs = await subscriptionService.list();
  for (const sub of subs) {
    subscriptionService.handleTask(sub.get({ plain: true }), !sub.is_disabled);
  }
 };
@@ -1,63 +1,32 @@
 import winston from 'winston';
 import 'winston-daily-rotate-file';
 import config from '../config';
 import path from 'path';
-const levelMap: Record<string, string> = {
+const transports = [];
-  info: 'ℹ️', // info图标
+if (process.env.NODE_ENV !== 'development') {
-  warn: '⚠️', // 警告图标
+  transports.push(new winston.transports.Console());
-  error: '❌', // 错误图标
+} else {
-  debug: '🐛', // debug调试图标
+  transports.push(
-};
+    new winston.transports.Console({
-
+      format: winston.format.combine(
-const baseFormat = [
+        winston.format.cli(),
-  winston.format.splat(),
+        winston.format.splat(),
-  winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
+      ),
-  winston.format.align(),
+    }),
-];
+  );
-
+}
 const consoleFormat = winston.format.combine(
  winston.format.colorize({ level: true }),
  ...baseFormat,
  winston.format.printf((info) => {
    return `[${info.level} ${info.timestamp}]:${info.message}`;
  }),
 );
 const plainFormat = winston.format.combine(
  winston.format.uncolorize(),
  ...baseFormat,
  winston.format.printf((info) => {
    return `[${levelMap[info.level] || ''}${info.level} ${info.timestamp}]:${
      info.message
    }`;
  }),
 );
 const consoleTransport = new winston.transports.Console({
  format: consoleFormat,
  level: 'debug',
 });
 const fileTransport = new winston.transports.DailyRotateFile({
  filename: path.join(config.systemLogPath, '%DATE%.log'),
  datePattern: 'YYYY-MM-DD',
  maxSize: '20m',
  maxFiles: '7d',
  format: plainFormat,
  level: config.logs.level || 'info',
 });
 const LoggerInstance = winston.createLogger({
-  level: 'debug',
+  level: config.logs.level,
  levels: winston.config.npm.levels,
-  transports: [consoleTransport, fileTransport],
+  format: winston.format.combine(
-  exceptionHandlers: [consoleTransport, fileTransport],
+    winston.format.timestamp({
-  rejectionHandlers: [consoleTransport, fileTransport],
+      format: 'YYYY-MM-DD HH:mm:ss',
-});
+    }),
-
+    winston.format.errors({ stack: true }),
-LoggerInstance.on('error', (error) => {
+    winston.format.splat(),
-  console.error('Logger error:', error);
+    winston.format.json(),
  ),
  transports,
 });
 export default LoggerInstance;
@@ -0,0 +1,21 @@
 import { Application } from 'express';
 import * as Sentry from '@sentry/node';
 import * as Tracing from '@sentry/tracing';
 import Logger from './logger';
 export default ({ expressApp }: { expressApp: Application }) => {
  Sentry.init({
    dsn: 'https://e14681bce55f4849b11024a7d424b711@o1051273.ingest.sentry.io/6047906',
    integrations: [
      new Sentry.Integrations.Http({ tracing: true }),
      new Tracing.Integrations.Express({ app: expressApp }),
    ],
    tracesSampleRate: 1.0,
  });
  expressApp.use(Sentry.Handlers.requestHandler());
  expressApp.use(Sentry.Handlers.tracingHandler());
  Logger.info('✌️ Sentry loaded');
 };
@@ -6,11 +6,11 @@ export default async ({ server }: { server: Server }) => {
  await Sock({ server });
  Logger.info('✌️ Sock loaded');
-  process.on('uncaughtException', (error) => {
+  process.on('SIGINT', () => {
-    Logger.error('Uncaught exception:', error);
+    Logger.info('✌️ Server need close');
-  });
+    server.close(() => {
-
+      Logger.info('✌️ Server closed');
-  process.on('unhandledRejection', (reason, promise) => {
+      process.exit(0);
-    Logger.error('Unhandled rejection:', reason, promise);
+    });
  });
 };
@@ -1,25 +1,28 @@
 import sockJs from 'sockjs';
 import { Server } from 'http';
 import Logger from './logger';
 import { Container } from 'typedi';
 import SockService from '../services/sock';
 import config from '../config/index';
 import fs from 'fs';
 import { getPlatform } from '../config/util';
 import { shareStore } from '../shared/store';
 export default async ({ server }: { server: Server }) => {
  const echo = sockJs.createServer({ prefix: '/api/ws', log: () => {} });
  const sockService = Container.get(SockService);
-  echo.on('connection', async (conn) => {
+  echo.on('connection', (conn) => {
    if (!conn.headers || !conn.url || !conn.pathname) {
      conn.close('404');
    }
-    const authInfo = await shareStore.getAuthInfo();
+    const data = fs.readFileSync(config.authConfigFile, 'utf8');
    const platform = getPlatform(conn.headers['user-agent'] || '') || 'desktop';
    const headerToken = conn.url.replace(`${conn.pathname}?token=`, '');
-    if (authInfo) {
+    if (data) {
-      const { token = '', tokens = {} } = authInfo;
+      const { token = '', tokens = {} } = JSON.parse(data);
      if (headerToken === token || tokens[platform] === headerToken) {
        conn.write(JSON.stringify({ type: 'ping', message: 'hanhh' }));
        sockService.addClient(conn);
        conn.on('data', (message) => {
@@ -31,6 +34,8 @@ export default async ({ server }: { server: Server }) => {
        });
        return;
      } else {
        conn.write(JSON.stringify({ type: 'ping', message: 'whyour' }));
      }
    }
@@ -1,80 +0,0 @@
 import { Request, Response, NextFunction } from 'express';
 import Logger from '../loaders/logger';
 import { performance } from 'perf_hooks';
 import { metricsService } from '../services/metrics';
 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,
 ) => {
  const start = performance.now();
  const originalEnd = res.end;
  res.end = function (chunk?: any, encoding?: any, cb?: any) {
    const duration = performance.now() - start;
    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) {
      Logger.warn(
        `Slow request detected: ${req.method} ${
          req.path
        } took ${duration.toFixed(2)}ms`,
      );
    }
    return originalEnd.call(this, chunk, encoding, cb);
  };
  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,257 +0,0 @@
 syntax = "proto3";
 package com.ql.api;
 message EnvItem {
  optional int32 id = 1;
  optional string name = 2;
  optional string value = 3;
  optional string remarks = 4;
  optional int32 status = 5;
  optional int64 position = 6;
 }
 message GetEnvsRequest { string searchValue = 1; }
 message CreateEnvRequest { repeated EnvItem envs = 1; }
 message UpdateEnvRequest { EnvItem env = 1; }
 message DeleteEnvsRequest { repeated int32 ids = 1; }
 message MoveEnvRequest {
  int32 id = 1;
  int32 fromIndex = 2;
  int32 toIndex = 3;
 }
 message DisableEnvsRequest { repeated int32 ids = 1; }
 message EnableEnvsRequest { repeated int32 ids = 1; }
 message UpdateEnvNamesRequest {
  repeated int32 ids = 1;
  string name = 2;
 }
 message GetEnvByIdRequest { int32 id = 1; }
 message EnvsResponse {
  int32 code = 1;
  repeated EnvItem data = 2;
  optional string message = 3;
 }
 message EnvResponse {
  int32 code = 1;
  EnvItem data = 2;
  optional string message = 3;
 }
 message Response {
  int32 code = 1;
  optional string message = 2;
 }
 message ExtraScheduleItem { string schedule = 1; }
 message CronItem {
  optional int32 id = 1;
  optional string command = 2;
  optional string schedule = 3;
  optional string name = 4;
  repeated string labels = 5;
  optional int32 sub_id = 6;
  repeated ExtraScheduleItem extra_schedules = 7;
  optional string task_before = 8;
  optional string task_after = 9;
  optional int32 status = 10;
  optional string log_path = 11;
  optional int32 pid = 12;
  optional int64 last_running_time = 13;
  optional int64 last_execution_time = 14;
 }
 message CreateCronRequest {
  string command = 1;
  string schedule = 2;
  optional string name = 3;
  repeated string labels = 4;
  optional int32 sub_id = 5;
  repeated ExtraScheduleItem extra_schedules = 6;
  optional string task_before = 7;
  optional string task_after = 8;
 }
 message UpdateCronRequest {
  int32 id = 1;
  optional string command = 2;
  optional string schedule = 3;
  optional string name = 4;
  repeated string labels = 5;
  optional int32 sub_id = 6;
  repeated ExtraScheduleItem extra_schedules = 7;
  optional string task_before = 8;
  optional string task_after = 9;
 }
 message DeleteCronsRequest { repeated int32 ids = 1; }
 message CronsResponse {
  int32 code = 1;
  repeated CronItem data = 2;
  optional string message = 3;
 }
 message CronResponse {
  int32 code = 1;
  CronItem data = 2;
  optional string message = 3;
 }
 message CronDetailRequest { string log_path = 1; }
 message CronDetailResponse {
  int32 code = 1;
  CronItem data = 2;
  optional string message = 3;
 }
 enum NotificationMode {
  gotify = 0;
  goCqHttpBot = 1;
  serverChan = 2;
  pushDeer = 3;
  bark = 4;
  chat = 5;
  telegramBot = 6;
  dingtalkBot = 7;
  weWorkBot = 8;
  weWorkApp = 9;
  aibotk = 10;
  iGot = 11;
  pushPlus = 12;
  wePlusBot = 13;
  email = 14;
  pushMe = 15;
  feishu = 16;
  webhook = 17;
  chronocat = 18;
  ntfy = 19;
  wxPusherBot = 20;
 }
 message NotificationInfo {
  NotificationMode type = 1;
  optional string gotifyUrl = 2;
  optional string gotifyToken = 3;
  optional int32 gotifyPriority = 4;
  optional string goCqHttpBotUrl = 5;
  optional string goCqHttpBotToken = 6;
  optional string goCqHttpBotQq = 7;
  optional string serverChanKey = 8;
  optional string pushDeerKey = 9;
  optional string pushDeerUrl = 10;
  optional string synologyChatUrl = 11;
  optional string barkPush = 12;
  optional string barkIcon = 13;
  optional string barkSound = 14;
  optional string barkGroup = 15;
  optional string barkLevel = 16;
  optional string barkUrl = 17;
  optional string barkArchive = 18;
  optional string telegramBotToken = 19;
  optional string telegramBotUserId = 20;
  optional string telegramBotProxyHost = 21;
  optional string telegramBotProxyPort = 22;
  optional string telegramBotProxyAuth = 23;
  optional string telegramBotApiHost = 24;
  optional string dingtalkBotToken = 25;
  optional string dingtalkBotSecret = 26;
  optional string weWorkBotKey = 27;
  optional string weWorkOrigin = 28;
  optional string weWorkAppKey = 29;
  optional string aibotkKey = 30;
  optional string aibotkType = 31;
  optional string aibotkName = 32;
  optional string iGotPushKey = 33;
  optional string pushPlusToken = 34;
  optional string pushPlusUser = 35;
  optional string pushPlusTemplate = 36;
  optional string pushplusChannel = 37;
  optional string pushplusWebhook = 38;
  optional string pushplusCallbackUrl = 39;
  optional string pushplusTo = 40;
  optional string wePlusBotToken = 41;
  optional string wePlusBotReceiver = 42;
  optional string wePlusBotVersion = 43;
  optional string emailService = 44;
  optional string emailUser = 45;
  optional string emailPass = 46;
  optional string emailTo = 47;
  optional string pushMeKey = 48;
  optional string pushMeUrl = 49;
  optional string chronocatURL = 50;
  optional string chronocatQQ = 51;
  optional string chronocatToken = 52;
  optional string webhookHeaders = 53;
  optional string webhookBody = 54;
  optional string webhookUrl = 55;
  optional string webhookMethod = 56;
  optional string webhookContentType = 57;
  optional string larkKey = 58;
  optional string ntfyUrl = 59;
  optional string ntfyTopic = 60;
  optional string ntfyPriority = 61;
  optional string ntfyToken = 62;
  optional string ntfyUsername = 63;
  optional string ntfyPassword = 64;
  optional string ntfyActions = 65;
  optional string wxPusherBotAppToken = 66;
  optional string wxPusherBotTopicIds = 67;
  optional string wxPusherBotUids = 68;
 }
 message SystemNotifyRequest {
  string title = 1;
  string content = 2;
  optional NotificationInfo notificationInfo = 3;
 }
 service Api {
  rpc GetEnvs(GetEnvsRequest) returns (EnvsResponse) {}
  rpc CreateEnv(CreateEnvRequest) returns (EnvsResponse) {}
  rpc UpdateEnv(UpdateEnvRequest) returns (EnvResponse) {}
  rpc DeleteEnvs(DeleteEnvsRequest) returns (Response) {}
  rpc MoveEnv(MoveEnvRequest) returns (EnvResponse) {}
  rpc DisableEnvs(DisableEnvsRequest) returns (Response) {}
  rpc EnableEnvs(EnableEnvsRequest) returns (Response) {}
  rpc UpdateEnvNames(UpdateEnvNamesRequest) returns (Response) {}
  rpc GetEnvById(GetEnvByIdRequest) returns (EnvResponse) {}
  rpc SystemNotify(SystemNotifyRequest) returns (Response) {}
  rpc GetCronDetail(CronDetailRequest) returns (CronDetailResponse) {}
  rpc CreateCron(CreateCronRequest) returns (CronResponse) {}
  rpc UpdateCron(UpdateCronRequest) returns (CronResponse) {}
  rpc DeleteCrons(DeleteCronsRequest) returns (Response) {}
 }
@@ -1,26 +0,0 @@
 syntax = "proto3";
 package com.ql.cron;
 service Cron {
  rpc addCron(AddCronRequest) returns (AddCronResponse);
  rpc delCron(DeleteCronRequest) returns (DeleteCronResponse);
 }
 message ISchedule { string schedule = 1; }
 message ICron {
  string id = 1;
  string schedule = 2;
  string command = 3;
  repeated ISchedule extra_schedules = 4;
  string name = 5;
 }
 message AddCronRequest { repeated ICron crons = 1; }
 message AddCronResponse {}
 message DeleteCronRequest { repeated string ids = 1; }
 message DeleteCronResponse {}
@@ -1,525 +0,0 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
 //   protoc-gen-ts_proto  v2.6.1
 //   protoc               v3.17.3
 // source: back/protos/cron.proto
 /* eslint-disable */
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import {
  type CallOptions,
  ChannelCredentials,
  Client,
  type ClientOptions,
  type ClientUnaryCall,
  type handleUnaryCall,
  makeGenericClientConstructor,
  Metadata,
  type ServiceError,
  type UntypedServiceImplementation,
 } from "@grpc/grpc-js";
 export const protobufPackage = "com.ql.cron";
 export interface ISchedule {
  schedule: string;
 }
 export interface ICron {
  id: string;
  schedule: string;
  command: string;
  extra_schedules: ISchedule[];
  name: string;
 }
 export interface AddCronRequest {
  crons: ICron[];
 }
 export interface AddCronResponse {
 }
 export interface DeleteCronRequest {
  ids: string[];
 }
 export interface DeleteCronResponse {
 }
 function createBaseISchedule(): ISchedule {
  return { schedule: "" };
 }
 export const ISchedule: MessageFns<ISchedule> = {
  encode(message: ISchedule, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.schedule !== "") {
      writer.uint32(10).string(message.schedule);
    }
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): ISchedule {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseISchedule();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.schedule = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object: any): ISchedule {
    return { schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "" };
  },
  toJSON(message: ISchedule): unknown {
    const obj: any = {};
    if (message.schedule !== "") {
      obj.schedule = message.schedule;
    }
    return obj;
  },
  create<I extends Exact<DeepPartial<ISchedule>, I>>(base?: I): ISchedule {
    return ISchedule.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ISchedule>, I>>(object: I): ISchedule {
    const message = createBaseISchedule();
    message.schedule = object.schedule ?? "";
    return message;
  },
 };
 function createBaseICron(): ICron {
  return { id: "", schedule: "", command: "", extra_schedules: [], name: "" };
 }
 export const ICron: MessageFns<ICron> = {
  encode(message: ICron, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    if (message.schedule !== "") {
      writer.uint32(18).string(message.schedule);
    }
    if (message.command !== "") {
      writer.uint32(26).string(message.command);
    }
    for (const v of message.extra_schedules) {
      ISchedule.encode(v!, writer.uint32(34).fork()).join();
    }
    if (message.name !== "") {
      writer.uint32(42).string(message.name);
    }
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): ICron {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseICron();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
        }
        case 2: {
          if (tag !== 18) {
            break;
          }
          message.schedule = reader.string();
          continue;
        }
        case 3: {
          if (tag !== 26) {
            break;
          }
          message.command = reader.string();
          continue;
        }
        case 4: {
          if (tag !== 34) {
            break;
          }
          message.extra_schedules.push(ISchedule.decode(reader, reader.uint32()));
          continue;
        }
        case 5: {
          if (tag !== 42) {
            break;
          }
          message.name = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object: any): ICron {
    return {
      id: isSet(object.id) ? globalThis.String(object.id) : "",
      schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "",
      command: isSet(object.command) ? globalThis.String(object.command) : "",
      extra_schedules: globalThis.Array.isArray(object?.extra_schedules)
        ? object.extra_schedules.map((e: any) => ISchedule.fromJSON(e))
        : [],
      name: isSet(object.name) ? globalThis.String(object.name) : "",
    };
  },
  toJSON(message: ICron): unknown {
    const obj: any = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    if (message.schedule !== "") {
      obj.schedule = message.schedule;
    }
    if (message.command !== "") {
      obj.command = message.command;
    }
    if (message.extra_schedules?.length) {
      obj.extra_schedules = message.extra_schedules.map((e) => ISchedule.toJSON(e));
    }
    if (message.name !== "") {
      obj.name = message.name;
    }
    return obj;
  },
  create<I extends Exact<DeepPartial<ICron>, I>>(base?: I): ICron {
    return ICron.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<ICron>, I>>(object: I): ICron {
    const message = createBaseICron();
    message.id = object.id ?? "";
    message.schedule = object.schedule ?? "";
    message.command = object.command ?? "";
    message.extra_schedules = object.extra_schedules?.map((e) => ISchedule.fromPartial(e)) || [];
    message.name = object.name ?? "";
    return message;
  },
 };
 function createBaseAddCronRequest(): AddCronRequest {
  return { crons: [] };
 }
 export const AddCronRequest: MessageFns<AddCronRequest> = {
  encode(message: AddCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.crons) {
      ICron.encode(v!, writer.uint32(10).fork()).join();
    }
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): AddCronRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAddCronRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.crons.push(ICron.decode(reader, reader.uint32()));
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object: any): AddCronRequest {
    return { crons: globalThis.Array.isArray(object?.crons) ? object.crons.map((e: any) => ICron.fromJSON(e)) : [] };
  },
  toJSON(message: AddCronRequest): unknown {
    const obj: any = {};
    if (message.crons?.length) {
      obj.crons = message.crons.map((e) => ICron.toJSON(e));
    }
    return obj;
  },
  create<I extends Exact<DeepPartial<AddCronRequest>, I>>(base?: I): AddCronRequest {
    return AddCronRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AddCronRequest>, I>>(object: I): AddCronRequest {
    const message = createBaseAddCronRequest();
    message.crons = object.crons?.map((e) => ICron.fromPartial(e)) || [];
    return message;
  },
 };
 function createBaseAddCronResponse(): AddCronResponse {
  return {};
 }
 export const AddCronResponse: MessageFns<AddCronResponse> = {
  encode(_: AddCronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): AddCronResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseAddCronResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_: any): AddCronResponse {
    return {};
  },
  toJSON(_: AddCronResponse): unknown {
    const obj: any = {};
    return obj;
  },
  create<I extends Exact<DeepPartial<AddCronResponse>, I>>(base?: I): AddCronResponse {
    return AddCronResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<AddCronResponse>, I>>(_: I): AddCronResponse {
    const message = createBaseAddCronResponse();
    return message;
  },
 };
 function createBaseDeleteCronRequest(): DeleteCronRequest {
  return { ids: [] };
 }
 export const DeleteCronRequest: MessageFns<DeleteCronRequest> = {
  encode(message: DeleteCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    for (const v of message.ids) {
      writer.uint32(10).string(v!);
    }
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDeleteCronRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.ids.push(reader.string());
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object: any): DeleteCronRequest {
    return { ids: globalThis.Array.isArray(object?.ids) ? object.ids.map((e: any) => globalThis.String(e)) : [] };
  },
  toJSON(message: DeleteCronRequest): unknown {
    const obj: any = {};
    if (message.ids?.length) {
      obj.ids = message.ids;
    }
    return obj;
  },
  create<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(base?: I): DeleteCronRequest {
    return DeleteCronRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(object: I): DeleteCronRequest {
    const message = createBaseDeleteCronRequest();
    message.ids = object.ids?.map((e) => e) || [];
    return message;
  },
 };
 function createBaseDeleteCronResponse(): DeleteCronResponse {
  return {};
 }
 export const DeleteCronResponse: MessageFns<DeleteCronResponse> = {
  encode(_: DeleteCronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseDeleteCronResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(_: any): DeleteCronResponse {
    return {};
  },
  toJSON(_: DeleteCronResponse): unknown {
    const obj: any = {};
    return obj;
  },
  create<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(base?: I): DeleteCronResponse {
    return DeleteCronResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(_: I): DeleteCronResponse {
    const message = createBaseDeleteCronResponse();
    return message;
  },
 };
 export type CronService = typeof CronService;
 export const CronService = {
  addCron: {
    path: "/com.ql.cron.Cron/addCron",
    requestStream: false,
    responseStream: false,
    requestSerialize: (value: AddCronRequest) => Buffer.from(AddCronRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer) => AddCronRequest.decode(value),
    responseSerialize: (value: AddCronResponse) => Buffer.from(AddCronResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer) => AddCronResponse.decode(value),
  },
  delCron: {
    path: "/com.ql.cron.Cron/delCron",
    requestStream: false,
    responseStream: false,
    requestSerialize: (value: DeleteCronRequest) => Buffer.from(DeleteCronRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer) => DeleteCronRequest.decode(value),
    responseSerialize: (value: DeleteCronResponse) => Buffer.from(DeleteCronResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer) => DeleteCronResponse.decode(value),
  },
 } as const;
 export interface CronServer extends UntypedServiceImplementation {
  addCron: handleUnaryCall<AddCronRequest, AddCronResponse>;
  delCron: handleUnaryCall<DeleteCronRequest, DeleteCronResponse>;
 }
 export interface CronClient extends Client {
  addCron(
    request: AddCronRequest,
    callback: (error: ServiceError | null, response: AddCronResponse) => void,
  ): ClientUnaryCall;
  addCron(
    request: AddCronRequest,
    metadata: Metadata,
    callback: (error: ServiceError | null, response: AddCronResponse) => void,
  ): ClientUnaryCall;
  addCron(
    request: AddCronRequest,
    metadata: Metadata,
    options: Partial<CallOptions>,
    callback: (error: ServiceError | null, response: AddCronResponse) => void,
  ): ClientUnaryCall;
  delCron(
    request: DeleteCronRequest,
    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
  ): ClientUnaryCall;
  delCron(
    request: DeleteCronRequest,
    metadata: Metadata,
    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
  ): ClientUnaryCall;
  delCron(
    request: DeleteCronRequest,
    metadata: Metadata,
    options: Partial<CallOptions>,
    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
  ): ClientUnaryCall;
 }
 export const CronClient = makeGenericClientConstructor(CronService, "com.ql.cron.Cron") as unknown as {
  new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): CronClient;
  service: typeof CronService;
  serviceName: string;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;
 type KeysOfUnion<T> = T extends T ? keyof T : never;
 export type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 function isSet(value: any): boolean {
  return value !== null && value !== undefined;
 }
 export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
 }
@@ -1,22 +0,0 @@
 syntax = "proto3";
 package com.ql.health;
 message HealthCheckRequest {
  string service = 1;
 }
 message HealthCheckResponse {
  enum ServingStatus {
    UNKNOWN = 0;
    SERVING = 1;
    NOT_SERVING = 2;
    SERVICE_UNKNOWN = 3;
  }
  ServingStatus status = 1;
 }
 service Health {
  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
 }
@@ -1,275 +0,0 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
 //   protoc-gen-ts_proto  v2.6.1
 //   protoc               v3.17.3
 // source: back/protos/health.proto
 /* eslint-disable */
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import {
  type CallOptions,
  ChannelCredentials,
  Client,
  type ClientOptions,
  type ClientReadableStream,
  type ClientUnaryCall,
  type handleServerStreamingCall,
  type handleUnaryCall,
  makeGenericClientConstructor,
  Metadata,
  type ServiceError,
  type UntypedServiceImplementation,
 } from "@grpc/grpc-js";
 export const protobufPackage = "com.ql.health";
 export interface HealthCheckRequest {
  service: string;
 }
 export interface HealthCheckResponse {
  status: HealthCheckResponse_ServingStatus;
 }
 export enum HealthCheckResponse_ServingStatus {
  UNKNOWN = 0,
  SERVING = 1,
  NOT_SERVING = 2,
  SERVICE_UNKNOWN = 3,
  UNRECOGNIZED = -1,
 }
 export function healthCheckResponse_ServingStatusFromJSON(object: any): HealthCheckResponse_ServingStatus {
  switch (object) {
    case 0:
    case "UNKNOWN":
      return HealthCheckResponse_ServingStatus.UNKNOWN;
    case 1:
    case "SERVING":
      return HealthCheckResponse_ServingStatus.SERVING;
    case 2:
    case "NOT_SERVING":
      return HealthCheckResponse_ServingStatus.NOT_SERVING;
    case 3:
    case "SERVICE_UNKNOWN":
      return HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN;
    case -1:
    case "UNRECOGNIZED":
    default:
      return HealthCheckResponse_ServingStatus.UNRECOGNIZED;
  }
 }
 export function healthCheckResponse_ServingStatusToJSON(object: HealthCheckResponse_ServingStatus): string {
  switch (object) {
    case HealthCheckResponse_ServingStatus.UNKNOWN:
      return "UNKNOWN";
    case HealthCheckResponse_ServingStatus.SERVING:
      return "SERVING";
    case HealthCheckResponse_ServingStatus.NOT_SERVING:
      return "NOT_SERVING";
    case HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN:
      return "SERVICE_UNKNOWN";
    case HealthCheckResponse_ServingStatus.UNRECOGNIZED:
    default:
      return "UNRECOGNIZED";
  }
 }
 function createBaseHealthCheckRequest(): HealthCheckRequest {
  return { service: "" };
 }
 export const HealthCheckRequest: MessageFns<HealthCheckRequest> = {
  encode(message: HealthCheckRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.service !== "") {
      writer.uint32(10).string(message.service);
    }
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): HealthCheckRequest {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHealthCheckRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 10) {
            break;
          }
          message.service = reader.string();
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object: any): HealthCheckRequest {
    return { service: isSet(object.service) ? globalThis.String(object.service) : "" };
  },
  toJSON(message: HealthCheckRequest): unknown {
    const obj: any = {};
    if (message.service !== "") {
      obj.service = message.service;
    }
    return obj;
  },
  create<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(base?: I): HealthCheckRequest {
    return HealthCheckRequest.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(object: I): HealthCheckRequest {
    const message = createBaseHealthCheckRequest();
    message.service = object.service ?? "";
    return message;
  },
 };
 function createBaseHealthCheckResponse(): HealthCheckResponse {
  return { status: 0 };
 }
 export const HealthCheckResponse: MessageFns<HealthCheckResponse> = {
  encode(message: HealthCheckResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
    if (message.status !== 0) {
      writer.uint32(8).int32(message.status);
    }
    return writer;
  },
  decode(input: BinaryReader | Uint8Array, length?: number): HealthCheckResponse {
    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseHealthCheckResponse();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1: {
          if (tag !== 8) {
            break;
          }
          message.status = reader.int32() as any;
          continue;
        }
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skip(tag & 7);
    }
    return message;
  },
  fromJSON(object: any): HealthCheckResponse {
    return { status: isSet(object.status) ? healthCheckResponse_ServingStatusFromJSON(object.status) : 0 };
  },
  toJSON(message: HealthCheckResponse): unknown {
    const obj: any = {};
    if (message.status !== 0) {
      obj.status = healthCheckResponse_ServingStatusToJSON(message.status);
    }
    return obj;
  },
  create<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(base?: I): HealthCheckResponse {
    return HealthCheckResponse.fromPartial(base ?? ({} as any));
  },
  fromPartial<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(object: I): HealthCheckResponse {
    const message = createBaseHealthCheckResponse();
    message.status = object.status ?? 0;
    return message;
  },
 };
 export type HealthService = typeof HealthService;
 export const HealthService = {
  check: {
    path: "/com.ql.health.Health/Check",
    requestStream: false,
    responseStream: false,
    requestSerialize: (value: HealthCheckRequest) => Buffer.from(HealthCheckRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer) => HealthCheckRequest.decode(value),
    responseSerialize: (value: HealthCheckResponse) => Buffer.from(HealthCheckResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer) => HealthCheckResponse.decode(value),
  },
  watch: {
    path: "/com.ql.health.Health/Watch",
    requestStream: false,
    responseStream: true,
    requestSerialize: (value: HealthCheckRequest) => Buffer.from(HealthCheckRequest.encode(value).finish()),
    requestDeserialize: (value: Buffer) => HealthCheckRequest.decode(value),
    responseSerialize: (value: HealthCheckResponse) => Buffer.from(HealthCheckResponse.encode(value).finish()),
    responseDeserialize: (value: Buffer) => HealthCheckResponse.decode(value),
  },
 } as const;
 export interface HealthServer extends UntypedServiceImplementation {
  check: handleUnaryCall<HealthCheckRequest, HealthCheckResponse>;
  watch: handleServerStreamingCall<HealthCheckRequest, HealthCheckResponse>;
 }
 export interface HealthClient extends Client {
  check(
    request: HealthCheckRequest,
    callback: (error: ServiceError | null, response: HealthCheckResponse) => void,
  ): ClientUnaryCall;
  check(
    request: HealthCheckRequest,
    metadata: Metadata,
    callback: (error: ServiceError | null, response: HealthCheckResponse) => void,
  ): ClientUnaryCall;
  check(
    request: HealthCheckRequest,
    metadata: Metadata,
    options: Partial<CallOptions>,
    callback: (error: ServiceError | null, response: HealthCheckResponse) => void,
  ): ClientUnaryCall;
  watch(request: HealthCheckRequest, options?: Partial<CallOptions>): ClientReadableStream<HealthCheckResponse>;
  watch(
    request: HealthCheckRequest,
    metadata?: Metadata,
    options?: Partial<CallOptions>,
  ): ClientReadableStream<HealthCheckResponse>;
 }
 export const HealthClient = makeGenericClientConstructor(HealthService, "com.ql.health.Health") as unknown as {
  new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): HealthClient;
  service: typeof HealthService;
  serviceName: string;
 };
 type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export type DeepPartial<T> = T extends Builtin ? T
  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
  : Partial<T>;
 type KeysOfUnion<T> = T extends T ? keyof T : never;
 export type Exact<P, I extends P> = P extends Builtin ? P
  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 function isSet(value: any): boolean {
  return value !== null && value !== undefined;
 }
 export interface MessageFns<T> {
  encode(message: T, writer?: BinaryWriter): BinaryWriter;
  decode(input: BinaryReader | Uint8Array, length?: number): T;
  fromJSON(object: any): T;
  toJSON(message: T): unknown;
  create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
  fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
 }
@@ -0,0 +1,61 @@
 import schedule from 'node-schedule';
 import express from 'express';
 import { exec } from 'child_process';
 import Logger from './loaders/logger';
 import { CrontabStatus } from './data/cron';
 import config from './config';
 import { dbs } from './loaders/db';
 const app = express();
 const run = async () => {
  const cronDb = dbs.cronDb;
  cronDb
    .find({})
    .sort({ created: 1 })
    .exec((err, docs) => {
      if (err) {
        Logger.error(err);
        process.exit(1);
      }
      if (docs && docs.length > 0) {
        for (let i = 0; i < docs.length; i++) {
          const task = docs[i];
          const _schedule = task.schedule && task.schedule.split(/ +/);
          if (
            _schedule &&
            _schedule.length > 5 &&
            task.status !== CrontabStatus.disabled &&
            !task.isDisabled
          ) {
            schedule.scheduleJob(task.schedule, function () {
              let command = task.command as string;
              if (!command.includes('task ') && !command.includes('ql ')) {
                command = `task ${command}`;
              }
              exec(command);
            });
          }
        }
      }
    });
 };
 app
  .listen(config.cronPort, async () => {
    await require('./loaders/sentry').default({ expressApp: app });
    await require('./loaders/db').default();
    await run();
    Logger.info(`
      ################################################
      🛡️  Schedule listening on port: ${config.cronPort} 🛡️
      ################################################
    `);
  })
  .on('error', (err) => {
    Logger.error(err);
    process.exit(1);
  });
@@ -1,57 +0,0 @@
 import { ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js';
 import { AddCronRequest, AddCronResponse } from '../protos/cron';
 import nodeSchedule from 'node-schedule';
 import { scheduleStacks } from './data';
 import { runCron } from '../shared/runCron';
 import Logger from '../loaders/logger';
 const addCron = (
  call: ServerUnaryCall<AddCronRequest, AddCronResponse>,
  callback: sendUnaryData<AddCronResponse>,
 ) => {
  for (const item of call.request.crons) {
    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) => {
        Logger.info(
          '[schedule][创建定时任务] 任务ID: %s, 名称: %s, cron: %s, 执行命令: %s',
          id,
          name,
          x.schedule,
          command,
        );
      });
    }
    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);
 };
 export { addCron };
@@ -1,325 +0,0 @@
 import 'reflect-metadata';
 import { Container } from 'typedi';
 import EnvService from '../services/env';
 import { sendUnaryData, ServerUnaryCall } from '@grpc/grpc-js';
 import {
  CreateEnvRequest,
  CronItem,
  DeleteEnvsRequest,
  DisableEnvsRequest,
  EnableEnvsRequest,
  EnvItem,
  EnvResponse,
  EnvsResponse,
  GetEnvByIdRequest,
  GetEnvsRequest,
  MoveEnvRequest,
  Response,
  SystemNotifyRequest,
  UpdateEnvNamesRequest,
  UpdateEnvRequest,
 } from '../protos/api';
 import LoggerInstance from '../loaders/logger';
 import pick from 'lodash/pick';
 import SystemService from '../services/system';
 import CronService from '../services/cron';
 import {
  CronDetailRequest,
  CronDetailResponse,
  CreateCronRequest,
  UpdateCronRequest,
  DeleteCronsRequest,
  CronResponse,
 } from '../protos/api';
 import { NotificationInfo } from '../data/notify';
 Container.set('logger', LoggerInstance);
 export const getEnvs = async (
  call: ServerUnaryCall<GetEnvsRequest, EnvsResponse>,
  callback: sendUnaryData<EnvsResponse>,
 ) => {
  try {
    const envService = Container.get(EnvService);
    const data = await envService.envs(call.request.searchValue);
    callback(null, {
      code: 200,
      data: data.map((x) => ({ ...x, remarks: x.remarks || '' })),
    });
  } catch (e: any) {
    callback(null, {
      code: 500,
      data: [],
      message: e.message,
    });
  }
 };
 export const createEnv = async (
  call: ServerUnaryCall<CreateEnvRequest, EnvsResponse>,
  callback: sendUnaryData<EnvsResponse>,
 ) => {
  try {
    const envService = Container.get(EnvService);
    const data = await envService.create(call.request.envs);
    callback(null, { code: 200, data });
  } catch (e: any) {
    callback(e);
  }
 };
 export const updateEnv = async (
  call: ServerUnaryCall<UpdateEnvRequest, EnvResponse>,
  callback: sendUnaryData<EnvResponse>,
 ) => {
  try {
    if (!call.request.env?.id) {
      return callback(null, {
        code: 400,
        data: undefined,
        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,
    );
    callback(null, { code: 200, data });
  } catch (e: any) {
    callback(e);
  }
 };
 export const deleteEnvs = async (
  call: ServerUnaryCall<DeleteEnvsRequest, Response>,
  callback: sendUnaryData<Response>,
 ) => {
  try {
    if (!call.request.ids || call.request.ids.length === 0) {
      return callback(null, {
        code: 400,
        message: 'ids parameter is required',
      });
    }
    const envService = Container.get(EnvService);
    await envService.remove(call.request.ids);
    callback(null, { code: 200 });
  } catch (e: any) {
    callback(e);
  }
 };
 export const moveEnv = async (
  call: ServerUnaryCall<MoveEnvRequest, EnvResponse>,
  callback: sendUnaryData<EnvResponse>,
 ) => {
  try {
    if (!call.request.id) {
      return callback(null, {
        code: 400,
        data: undefined,
        message: 'id parameter is required',
      });
    }
    const envService = Container.get(EnvService);
    const data = await envService.move(call.request.id, {
      fromIndex: call.request.fromIndex,
      toIndex: call.request.toIndex,
    });
    callback(null, { code: 200, data });
  } catch (e: any) {
    callback(e);
  }
 };
 export const disableEnvs = async (
  call: ServerUnaryCall<DisableEnvsRequest, Response>,
  callback: sendUnaryData<Response>,
 ) => {
  try {
    if (!call.request.ids || call.request.ids.length === 0) {
      return callback(null, {
        code: 400,
        message: 'ids parameter is required',
      });
    }
    const envService = Container.get(EnvService);
    await envService.disabled(call.request.ids);
    callback(null, { code: 200 });
  } catch (e: any) {
    callback(e);
  }
 };
 export const enableEnvs = async (
  call: ServerUnaryCall<EnableEnvsRequest, Response>,
  callback: sendUnaryData<Response>,
 ) => {
  try {
    if (!call.request.ids || call.request.ids.length === 0) {
      return callback(null, {
        code: 400,
        message: 'ids parameter is required',
      });
    }
    const envService = Container.get(EnvService);
    await envService.enabled(call.request.ids);
    callback(null, { code: 200 });
  } catch (e: any) {
    callback(e);
  }
 };
 export const updateEnvNames = async (
  call: ServerUnaryCall<UpdateEnvNamesRequest, Response>,
  callback: sendUnaryData<Response>,
 ) => {
  try {
    if (!call.request.ids || call.request.ids.length === 0) {
      return callback(null, {
        code: 400,
        message: 'ids parameter is required',
      });
    }
    const envService = Container.get(EnvService);
    await envService.updateNames({
      ids: call.request.ids,
      name: call.request.name,
    });
    callback(null, { code: 200 });
  } catch (e: any) {
    callback(e);
  }
 };
 export const getEnvById = async (
  call: ServerUnaryCall<GetEnvByIdRequest, EnvResponse>,
  callback: sendUnaryData<EnvResponse>,
 ) => {
  try {
    if (!call.request.id) {
      return callback(null, {
        code: 400,
        data: undefined,
        message: 'id parameter is required',
      });
    }
    const envService = Container.get(EnvService);
    const data = await envService.getDb({ id: call.request.id });
    callback(null, {
      code: 200,
      data: { ...data, remarks: data.remarks || '' },
    });
  } catch (e: any) {
    callback(e);
  }
 };
 export const systemNotify = async (
  call: ServerUnaryCall<SystemNotifyRequest, Response>,
  callback: sendUnaryData<Response>,
 ) => {
  try {
    const systemService = Container.get(SystemService);
    const data = await systemService.notify({
      title: call.request.title,
      content: call.request.content,
      notificationInfo: call.request.notificationInfo as unknown as NotificationInfo,
    });
    callback(null, data);
  } catch (e: any) {
    callback(e);
  }
 };
 const normalizeCronData = (data: CronItem | null): CronItem | undefined => {
  if (!data) return undefined;
  return {
    ...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>,
 ) => {
  try {
    if (!call.request.log_path) {
      return callback(null, {
        code: 400,
        data: undefined,
        message: 'log_path is required',
      });
    }
    const cronService = Container.get(CronService);
    const data = (await cronService.find({
      log_path: call.request.log_path,
    })) as CronItem;
    callback(null, { code: 200, data: normalizeCronData(data) });
  } catch (e: any) {
    callback(e);
  }
 };
 export const createCron = async (
  call: ServerUnaryCall<CreateCronRequest, CronResponse>,
  callback: sendUnaryData<CronResponse>,
 ) => {
  try {
    const cronService = Container.get(CronService);
    const data = (await cronService.create(call.request)) as CronItem;
    callback(null, { code: 200, data: normalizeCronData(data) });
  } catch (e: any) {
    callback(e);
  }
 };
 export const updateCron = async (
  call: ServerUnaryCall<UpdateCronRequest, CronResponse>,
  callback: sendUnaryData<CronResponse>,
 ) => {
  try {
    const cronService = Container.get(CronService);
    const { id, ...fields } = call.request;
    const updateRequest = {
      id,
      ...Object.entries(fields).reduce((acc: any, [key, value]) => {
        if (value !== undefined) {
          acc[key] = value;
        }
        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>,
 ) => {
  try {
    const cronService = Container.get(CronService);
    await cronService.remove(call.request.ids);
    callback(null, { code: 200 });
  } catch (e: any) {
    callback(e);
  }
 };
@@ -1,41 +0,0 @@
 import { credentials } from '@grpc/grpc-js';
 import {
  AddCronRequest,
  AddCronResponse,
  CronClient,
  DeleteCronRequest,
  DeleteCronResponse,
 } from '../protos/cron';
 import config from '../config';
 class Client {
  private client = new CronClient(
    `0.0.0.0:${config.grpcPort}`,
    credentials.createInsecure(),
    { 'grpc.enable_http_proxy': 0 },
  );
  addCron(request: AddCronRequest['crons']): Promise<AddCronResponse> {
    return new Promise((resolve, reject) => {
      this.client.addCron({ crons: request }, (err, res) => {
        if (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);
      });
    });
  }
 }
 export default new Client();
@@ -1,6 +0,0 @@
 import nodeSchedule from 'node-schedule';
 import { ToadScheduler } from 'toad-scheduler';
 export const scheduleStacks = new Map<string, nodeSchedule.Job[]>();
 export const intervalSchedule = new ToadScheduler();
@@ -1,24 +0,0 @@
 import { ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js';
 import { DeleteCronRequest, DeleteCronResponse } from '../protos/cron';
 import { scheduleStacks } from './data';
 import Logger from '../loaders/logger';
 const delCron = (
  call: ServerUnaryCall<DeleteCronRequest, DeleteCronResponse>,
  callback: sendUnaryData<DeleteCronResponse>,
 ) => {
  for (const id of call.request.ids) {
    if (scheduleStacks.has(id)) {
      Logger.info(
        '[schedule][取消定时任务] 任务ID: %s',
        id,
      );
      scheduleStacks.get(id)?.forEach(x => x.cancel());
      scheduleStacks.delete(id);
    }
  }
  callback(null, null);
 };
 export { delCron };
@@ -1,35 +0,0 @@
 import { ServerUnaryCall, sendUnaryData } from '@grpc/grpc-js';
 import { HealthCheckRequest, HealthCheckResponse } from '../protos/health';
 import config from '../config';
 import { promiseExec } from '../config/util';
 const check = async (
  call: ServerUnaryCall<HealthCheckRequest, HealthCheckResponse>,
  callback: sendUnaryData<HealthCheckResponse>,
 ) => {
  switch (call.request.service) {
    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 panelErrLog = await promiseExec(
        `tail -n 300 ~/.pm2/logs/panel-error.log`,
      );
      const scheduleErrLog = await promiseExec(
        `tail -n 300 ~/.pm2/logs/schedule-error.log`,
      );
      return callback(
        new Error(`${scheduleErrLog || ''}\n${panelErrLog || ''}\n${res}`.trim()),
      );
    default:
      return callback(null, { status: 1 });
  }
 };
 export { check };
@@ -1,42 +0,0 @@
 import { Service, Inject } from 'typedi';
 import path, { join } from 'path';
 import config from '../config';
 import { getFileContentByName } from '../config/util';
 import { Response } from 'express';
 import { request } from 'undici';
@Service()
 export default class ConfigService {
  constructor() {}
  public async getFile(filePath: string, res: Response) {
    let content = '';
    const avaliablePath = [config.rootPath, config.configPath].map((x) =>
      path.resolve(x, filePath),
    );
    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/')) {
      const res = await request(
        `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(join(config.configPath, filePath));
    }
    res.send({ code: 200, data: content });
  }
 }
@@ -1,125 +0,0 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import { CrontabView, CrontabViewModel } from '../data/cronView';
 import {
  initPosition,
  maxPosition,
  minPosition,
  stepPosition,
 } from '../data/env';
 import { FindOptions } from 'sequelize';
@Service()
 export default class CronViewService {
  constructor(@Inject('logger') private logger: winston.Logger) {}
  public async create(payload: CrontabView): Promise<CrontabView> {
    let position = initPosition;
    const views = await this.list();
    if (views && views.length > 0 && views[views.length - 1].position) {
      position = views[views.length - 1].position as number;
    }
    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.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.update(payload, { where: { id: payload.id } });
    return await this.getDb({ id: payload.id });
  }
  public async remove(ids: number[]) {
    await CrontabViewModel.destroy({ where: { id: ids } });
  }
  public async list(): Promise<CrontabView[]> {
    try {
      const result = await CrontabViewModel.findAll({
        where: {},
        order: [['position', 'DESC']],
      });
      return result;
    } catch (error) {
      throw error;
    }
  }
  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.get({ plain: true });
  }
  public async disabled(ids: number[]) {
    await CrontabViewModel.update({ isDisabled: 1 }, { where: { id: ids } });
  }
  public async enabled(ids: number[]) {
    await CrontabViewModel.update({ isDisabled: 0 }, { where: { id: ids } });
  }
  private async checkPosition(position: number) {
    const precisionPosition = parseFloat(position.toPrecision(16));
    if (precisionPosition < minPosition || precisionPosition > maxPosition) {
      const envs = await this.list();
      let position = initPosition;
      for (const env of envs) {
        position = position - stepPosition;
        await this.updateDb({ id: env.id, position });
      }
    }
  }
  private getPrecisionPosition(position: number): number {
    return parseFloat(position.toPrecision(16));
  }
  public async move({
    id,
    fromIndex,
    toIndex,
  }: {
    fromIndex: number;
    toIndex: number;
    id: number;
  }): Promise<CrontabView> {
    let targetPosition: number;
    const isUpward = fromIndex > toIndex;
    const views = await this.list();
    if (toIndex === 0 || toIndex === views.length - 1) {
      targetPosition = isUpward
        ? views[0].position! * 2
        : views[toIndex].position! / 2;
    } else {
      targetPosition = isUpward
        ? (views[toIndex].position! + views[toIndex - 1].position!) / 2
        : (views[toIndex].position! + views[toIndex + 1].position!) / 2;
    }
    const newDoc = await this.update({
      id,
      position: this.getPrecisionPosition(targetPosition),
    });
    await this.checkPosition(targetPosition);
    return newDoc;
  }
 }
@@ -1,381 +1,280 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import config from '../config';
 import DataStore from 'nedb';
 import {
  Dependence,
  InstallDependenceCommandTypes,
  DependenceStatus,
  DependenceTypes,
-  DependenceModel,
+  unInstallDependenceCommandTypes,
  versionDependenceCommandTypes,
 } from '../data/dependence';
-import { spawn } from 'cross-spawn';
+import _ from 'lodash';
 import { spawn } from 'child_process';
 import SockService from './sock';
-import { FindOptions, Op } from 'sequelize';
+import { dbs } from '../loaders/db';
 import {
  fileExist,
  getPid,
  killTask,
  promiseExecSuccess,
  getInstallCommand,
  getUninstallCommand,
  getGetCommand,
 } from '../config/util';
 import dayjs from 'dayjs';
 import taskLimit from '../shared/pLimit';
@Service()
 export default class DependenceService {
  private dependenceDb = dbs.dependenceDb;
  constructor(
    @Inject('logger') private logger: winston.Logger,
    private sockService: SockService,
-  ) { }
+  ) {}
  public async create(payloads: Dependence[]): Promise<Dependence[]> {
    const tabs = payloads.map((x) => {
-      const tab = new Dependence({ ...x, status: DependenceStatus.queued });
+      const tab = new Dependence({ ...x, status: DependenceStatus.installing });
      return tab;
    });
    const docs = await this.insert(tabs);
-    this.installDependenceOneByOne(docs);
+    this.installOrUninstallDependencies(docs);
    return docs;
  }
  public async insert(payloads: Dependence[]): Promise<Dependence[]> {
-    const docs = await DependenceModel.bulkCreate(payloads);
+    return new Promise((resolve) => {
-    return docs;
+      this.dependenceDb.insert(payloads, (err, docs) => {
        if (err) {
          this.logger.error(err);
        } else {
          resolve(docs);
        }
      });
    });
  }
  public async update(
-    payload: Dependence & { id: string },
+    payload: Dependence & { _id: string },
  ): Promise<Dependence> {
-    const { id, ...other } = payload;
+    const { _id, ...other } = payload;
-    const doc = await this.getDb({ id });
+    const doc = await this.get(_id);
    const tab = new Dependence({
      ...doc,
      ...other,
-      status: DependenceStatus.queued,
+      status: DependenceStatus.installing,
    });
    const newDoc = await this.updateDb(tab);
-    this.installDependenceOneByOne([newDoc]);
+    this.installOrUninstallDependencies([newDoc]);
    return newDoc;
  }
  private async updateDb(payload: Dependence): Promise<Dependence> {
-    await DependenceModel.update(payload, { where: { id: payload.id } });
+    return new Promise((resolve) => {
-    return await this.getDb({ id: payload.id });
+      this.dependenceDb.update(
-  }
+        { _id: payload._id },
-
+        payload,
-  public async remove(ids: number[], force = false): Promise<Dependence[]> {
+        { returnUpdatedDocs: true },
-    const docs = await DependenceModel.findAll({ where: { id: ids } });
+        (err, num, doc) => {
-    for (const doc of docs) {
+          if (err) {
-      taskLimit.removeQueuedDependency(doc);
+            this.logger.error(err);
-    }
+          } else {
-    const unInstalledDeps = docs.filter(
+            resolve(doc as Dependence);
-      (x) => x.status !== DependenceStatus.installed,
+          }
-    );
+        },
    const installedDeps = docs.filter(
      (x) => x.status === DependenceStatus.installed,
    );
    await this.removeDb(unInstalledDeps.map((x) => x.id!));
    if (installedDeps.length) {
      await DependenceModel.update(
        { status: DependenceStatus.queued, log: [] },
        { where: { id: ids } },
      );
-
+    });
      this.installDependenceOneByOne(docs, false, force);
    }
    return docs;
  }
-  public async removeDb(ids: number[]) {
+  public async remove(ids: string[]) {
-    await DependenceModel.destroy({ where: { id: ids } });
+    return new Promise((resolve: any) => {
      this.dependenceDb.update(
        { _id: { $in: ids } },
        { $set: { status: DependenceStatus.removing, log: [] } },
        { multi: true, returnUpdatedDocs: true },
        async (err, num, docs: Dependence[]) => {
          this.installOrUninstallDependencies(docs, false);
          resolve(docs);
        },
      );
    });
  }
  public async removeDb(ids: string[]) {
    return new Promise((resolve: any) => {
      this.dependenceDb.remove(
        { _id: { $in: ids } },
        { multi: true },
        async (err) => {
          resolve();
        },
      );
    });
  }
  public async dependencies(
-    {
+    { searchValue, type }: { searchValue: string; type: string },
-      searchValue,
+    sort: any = { position: -1 },
      type,
      status,
    }: {
      searchValue: string;
      type: keyof typeof DependenceTypes;
      status: string;
    },
    sort: any = [],
    query: any = {},
  ): Promise<Dependence[]> {
-    let condition = query;
+    let condition = { ...query, type: DependenceTypes[type as any] };
    if (DependenceTypes[type]) {
      condition.type = DependenceTypes[type];
    }
    if (status) {
      condition.status = status.split(',').map(Number);
    }
    if (searchValue) {
-      const encodeText = encodeURI(searchValue);
+      const reg = new RegExp(searchValue);
-      condition.name = {
+      condition = {
-        [Op.or]: [
+        ...condition,
-          { [Op.like]: `%${searchValue}%` },
+        $or: [
-          { [Op.like]: `%${encodeText}%` },
+          {
            name: reg,
          },
        ],
      };
    }
-    try {
+    const newDocs = await this.find(condition, sort);
-      return await this.find(condition, sort);
+    return newDocs;
    } catch (error) {
      throw error;
    }
  }
-  public installDependenceOneByOne(
+  public async reInstall(ids: string[]): Promise<Dependence[]> {
-    docs: Dependence[],
+    return new Promise((resolve: any) => {
-    isInstall: boolean = true,
+      this.dependenceDb.update(
-    force: boolean = false,
+        { _id: { $in: ids } },
-  ): Promise<void> {
+        { $set: { status: DependenceStatus.installing, log: [] } },
-    docs.forEach((dep) => {
+        { multi: true, returnUpdatedDocs: true },
-      this.installOrUninstallDependency(dep, isInstall, force);
+        async (err, num, docs: Dependence[]) => {
-    });
+          this.installOrUninstallDependencies(docs);
-
+          resolve(docs);
-    return taskLimit.waitDependencyQueueDone();
+        },
-  }
+      );
  public async reInstall(ids: number[]): Promise<Dependence[]> {
    await DependenceModel.update(
      { status: DependenceStatus.queued, log: [] },
      { where: { 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.findAll({ where: { id: ids } });
    for (const doc of docs) {
      taskLimit.removeQueuedDependency(doc);
      const depInstallCommand = getInstallCommand(doc.type, doc.name);
      const depUnInstallCommand = getUninstallCommand(doc.type, doc.name);
      const pids = await Promise.all([
        getPid(depInstallCommand),
        getPid(depUnInstallCommand),
      ]);
      for (const pid of pids) {
        pid && (await killTask(pid));
      }
    }
    await DependenceModel.update(
      { status: DependenceStatus.cancelled },
      { where: { id: ids } },
    );
  }
  private async find(query: any, sort: any = []): Promise<Dependence[]> {
    const docs = await DependenceModel.findAll({
      where: { ...query },
      order: [...sort, ['createdAt', 'DESC']],
    });
    return docs;
  }
  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.get({ plain: true });
  }
  private async updateLog(ids: number[], log: string): Promise<void> {
    taskLimit.updateDepLog(async () => {
      const docs = await DependenceModel.findAll({ where: { id: ids } });
      for (const doc of docs) {
        const newLog = doc?.log ? [...doc.log, log] : [log];
        await DependenceModel.update(
          { log: newLog },
          { where: { id: doc.id } },
        );
      }
      return null;
    });
  }
-  public installOrUninstallDependency(
+  private async find(query: any, sort: any): Promise<Dependence[]> {
-    dependency: Dependence,
+    return new Promise((resolve) => {
-    isInstall: boolean = true,
+      this.dependenceDb
-    force: boolean = false,
+        .find(query)
-  ) {
+        .sort({ ...sort })
-    return taskLimit.runDependeny(dependency, () => {
+        .exec((err, docs) => {
-      return new Promise(async (resolve) => {
+          resolve(docs);
        if (taskLimit.firstDependencyId !== dependency.id) {
          return resolve(null);
        }
        taskLimit.removeQueuedDependency(dependency);
        const depIds = [dependency.id!];
        const status = isInstall
          ? DependenceStatus.installing
          : DependenceStatus.removing;
        await DependenceModel.update({ status }, { where: { id: depIds } });
        const socketMessageType = isInstall
          ? 'installDependence'
          : 'uninstallDependence';
        let depName = dependency.name.trim();
        const command = isInstall
          ? getInstallCommand(dependency.type, depName)
          : getUninstallCommand(dependency.type, depName);
        const actionText = isInstall ? '安装' : '删除';
        const startTime = dayjs();
        const message = `开始${actionText}依赖 ${depName}，开始时间 ${startTime.format(
          'YYYY-MM-DD HH:mm:ss',
        )}\n\n`;
        this.sockService.sendMessage({
          type: socketMessageType,
          message,
          references: depIds,
        });
-        this.updateLog(depIds, message);
+    });
  }
-        // 判断是否已经安装过依赖
+  public async get(_id: string): Promise<Dependence> {
-        if (isInstall && !force) {
+    return new Promise((resolve) => {
-          const getCommand = getGetCommand(dependency.type, depName);
+      this.dependenceDb.find({ _id }).exec((err, docs) => {
-          const depVersionStr = versionDependenceCommandTypes[dependency.type];
+        resolve(docs[0]);
          let depVersion = '';
          if (depName.includes(depVersionStr)) {
            const symbolRegx = new RegExp(
              `(.*)${depVersionStr}([0-9\\.\\-\\+a-zA-Z]*)`,
            );
            const [, _depName, _depVersion] = depName.match(symbolRegx) || [];
            if (_depVersion && _depName) {
              depName = _depName;
              depVersion = _depVersion;
            }
          }
          const isNodeDependence = dependency.type === DependenceTypes.nodejs;
          const isLinuxDependence = dependency.type === DependenceTypes.linux;
          const isPythonDependence =
            dependency.type === DependenceTypes.python3;
          const depInfo = (await promiseExecSuccess(getCommand))
            .replace(/\s{2,}/, ' ')
            .replace(/\s+$/, '');
          if (
            depInfo &&
            ((isNodeDependence && depInfo.split(' ')?.[0] === depName) ||
              (isLinuxDependence &&
                depInfo.toLocaleLowerCase().includes('installed')) ||
              isPythonDependence) &&
            (!depVersion || depInfo.includes(depVersion))
          ) {
            const endTime = dayjs();
            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,
            });
            this.updateLog(depIds, _message);
            await DependenceModel.update(
              { status: DependenceStatus.installed },
              { where: { id: depIds } },
            );
            return resolve(null);
          }
        }
        const dependenceProxyFileExist = await fileExist(
          config.dependenceProxyFile,
        );
        const proxyStr = dependenceProxyFileExist
          ? `source ${config.dependenceProxyFile} &&`
          : '';
        const cp = spawn(`${proxyStr} ${command}`, {
          shell: '/bin/bash',
        });
        cp.stdout.on('data', async (data) => {
          this.sockService.sendMessage({
            type: socketMessageType,
            message: data.toString(),
            references: depIds,
          });
          this.updateLog(depIds, data.toString());
        });
        cp.stderr.on('data', async (data) => {
          this.sockService.sendMessage({
            type: socketMessageType,
            message: data.toString(),
            references: depIds,
          });
          this.updateLog(depIds, data.toString());
        });
        cp.on('error', async (err) => {
          this.sockService.sendMessage({
            type: socketMessageType,
            message: JSON.stringify(err),
            references: depIds,
          });
          this.updateLog(depIds, JSON.stringify(err));
        });
        cp.on('exit', async (code) => {
          const endTime = dayjs();
          const isSucceed = code === 0;
          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,
          });
          this.updateLog(depIds, message);
          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.update(
              { status },
              { where: { id: _docIds } },
            );
          }
          // 如果删除依赖成功或者强制删除
          if ((isSucceed || force) && !isInstall) {
            this.removeDb(depIds);
          }
          resolve(null);
        });
      });
    });
  }
  private async updateLog(ids: string[], log: string): Promise<void> {
    return new Promise((resolve) => {
      this.dependenceDb.update(
        { _id: { $in: ids } },
        { $push: { log } },
        { multi: true },
        (err, num, doc) => {
          if (err) {
            this.logger.error(err);
          } else {
            resolve();
          }
        },
      );
    });
  }
  public installOrUninstallDependencies(
    dependencies: Dependence[],
    isInstall: boolean = true,
  ) {
    if (dependencies.length === 0) {
      return;
    }
    const depNames = dependencies.map((x) => x.name).join(' ');
    const depRunCommand = (
      isInstall
        ? InstallDependenceCommandTypes
        : unInstallDependenceCommandTypes
    )[dependencies[0].type as any];
    const actionText = isInstall ? '安装' : '删除';
    const depIds = dependencies.map((x) => x._id) as string[];
    const cp = spawn(`${depRunCommand} ${depNames}`, { shell: '/bin/bash' });
    const startTime = Date.now();
    this.sockService.sendMessage({
      type: 'installDependence',
      message: `开始${actionText}依赖 ${depNames}，开始时间 ${new Date(
        startTime,
      ).toLocaleString()}`,
      references: depIds,
    });
    this.updateLog(
      depIds,
      `开始${actionText}依赖 ${depNames}，开始时间 ${new Date(
        startTime,
      ).toLocaleString()}\n`,
    );
    cp.stdout.on('data', (data) => {
      this.sockService.sendMessage({
        type: 'installDependence',
        message: data.toString(),
        references: depIds,
      });
      this.updateLog(depIds, data.toString());
    });
    cp.stderr.on('data', (data) => {
      this.sockService.sendMessage({
        type: 'installDependence',
        message: data.toString(),
        references: depIds,
      });
      this.updateLog(depIds, data.toString());
    });
    cp.on('error', (err) => {
      this.sockService.sendMessage({
        type: 'installDependence',
        message: JSON.stringify(err),
        references: depIds,
      });
      this.updateLog(depIds, JSON.stringify(err));
    });
    cp.on('close', (code) => {
      const endTime = Date.now();
      const isSucceed = code === 0;
      const resultText = isSucceed ? '成功' : '失败';
      this.sockService.sendMessage({
        type: 'installDependence',
        message: `依赖${actionText}${resultText}，结束时间 ${new Date(
          endTime,
        ).toLocaleString()}，耗时 ${(endTime - startTime) / 1000} 秒`,
        references: depIds,
      });
      this.updateLog(
        depIds,
        `依赖${actionText}${resultText}，结束时间 ${new Date(
          endTime,
        ).toLocaleString()}，耗时 ${(endTime - startTime) / 1000} 秒`,
      );
      let status = null;
      if (isSucceed) {
        status = isInstall
          ? DependenceStatus.installed
          : DependenceStatus.removed;
      } else {
        status = isInstall
          ? DependenceStatus.installFailed
          : DependenceStatus.removeFailed;
      }
      this.dependenceDb.update(
        { _id: { $in: depIds } },
        {
          $set: { status },
          $unset: { pid: true },
        },
        { multi: true },
      );
      // 如果删除依赖成功，3秒后删除数据库记录
      if (isSucceed && !isInstall) {
        setTimeout(() => {
          this.removeDb(depIds);
        }, 5000);
      }
    });
  }
 }
@@ -1,73 +1,84 @@
-import groupBy from 'lodash/groupBy';
+import { Service, Inject } from 'typedi';
 import { FindOptions, Op } from 'sequelize';
 import { Inject, Service } from 'typedi';
 import winston from 'winston';
 import { getFileContentByName } from '../config/util';
 import config from '../config';
-import {
+import * as fs from 'fs';
-  Env,
+import DataStore from 'nedb';
-  EnvModel,
+import { Env, EnvStatus, initEnvPosition } from '../data/env';
-  EnvStatus,
+import _ from 'lodash';
-  initPosition,
+import { dbs } from '../loaders/db';
  maxPosition,
  minPosition,
  stepPosition,
 } from '../data/env';
 import { writeFileWithLock } from '../shared/utils';
@Service()
 export default class EnvService {
  private envDb = dbs.envDb;
  constructor(@Inject('logger') private logger: winston.Logger) {}
  public async create(payloads: Env[]): Promise<Env[]> {
    const envs = await this.envs();
-    let position = initPosition;
+    let position = initEnvPosition;
-    if (
+    if (envs && envs.length > 0 && envs[envs.length - 1].position) {
-      envs &&
+      position = envs[envs.length - 1].position as number;
      envs.length > 0 &&
      typeof envs[envs.length - 1].position === 'number'
    ) {
      position = envs[envs.length - 1].position!;
    }
    const tabs = payloads.map((x) => {
-      position = position - stepPosition;
+      position = position / 2;
      const tab = new Env({ ...x, position });
      return tab;
    });
    const docs = await this.insert(tabs);
    await this.set_envs();
    await this.checkPosition(tabs[tabs.length - 1].position!);
    return docs;
  }
  public async insert(payloads: Env[]): Promise<Env[]> {
-    const result: Env[] = [];
+    return new Promise((resolve) => {
-    for (const env of payloads) {
+      this.envDb.insert(payloads, (err, docs) => {
-      const doc = await EnvModel.create(env, { returning: true });
+        if (err) {
-      result.push(doc);
+          this.logger.error(err);
-    }
+        } else {
-    return result;
+          resolve(docs);
        }
      });
    });
  }
  public async update(payload: Env): Promise<Env> {
-    const doc = await this.getDb({ id: payload.id });
+    const { _id, ...other } = payload;
-    const tab = new Env({ ...doc, ...payload });
+    const doc = await this.get(_id);
    const tab = new Env({ ...doc, ...other });
    const newDoc = await this.updateDb(tab);
    await this.set_envs();
    return newDoc;
  }
  private async updateDb(payload: Env): Promise<Env> {
-    await EnvModel.update({ ...payload }, { where: { id: payload.id } });
+    return new Promise((resolve) => {
-    return await this.getDb({ id: payload.id });
+      this.envDb.update(
        { _id: payload._id },
        payload,
        { returnUpdatedDocs: true },
        (err, num, doc) => {
          if (err) {
            this.logger.error(err);
          } else {
            resolve(doc as Env);
          }
        },
      );
    });
  }
-  public async remove(ids: number[]) {
+  public async remove(ids: string[]) {
-    await EnvModel.destroy({ where: { id: ids } });
+    return new Promise((resolve: any) => {
-    await this.set_envs();
+      this.envDb.remove({ _id: { $in: ids } }, { multi: true }, async (err) => {
        await this.set_envs();
        resolve();
      });
    });
  }
  public async move(
-    id: number,
+    _id: string,
    {
      fromIndex,
      toIndex,
@@ -81,161 +92,141 @@ export default class EnvService {
    const envs = await this.envs();
    if (toIndex === 0 || toIndex === envs.length - 1) {
      targetPosition = isUpward
-        ? envs[0].position! + stepPosition
+        ? envs[0].position * 2
-        : envs[toIndex].position! - stepPosition;
+        : envs[toIndex].position / 2;
    } else {
      targetPosition = isUpward
-        ? (envs[toIndex].position! + envs[toIndex - 1].position!) / 2
+        ? (envs[toIndex].position + envs[toIndex - 1].position) / 2
-        : (envs[toIndex].position! + envs[toIndex + 1].position!) / 2;
+        : (envs[toIndex].position + envs[toIndex + 1].position) / 2;
    }
    const newDoc = await this.update({
-      id,
+      _id,
-      position: this.getPrecisionPosition(targetPosition),
+      position: targetPosition,
    });
    await this.checkPosition(targetPosition, envs[toIndex].position!);
    return newDoc;
  }
-  private async checkPosition(position: number, edge: number = 0) {
+  public async envs(
-    const precisionPosition = parseFloat(position.toPrecision(16));
+    searchText: string = '',
-    if (
+    sort: any = { position: -1 },
-      precisionPosition < minPosition ||
+    query: any = {},
-      precisionPosition > maxPosition ||
+  ): Promise<Env[]> {
      Math.abs(precisionPosition - edge) < minPosition
    ) {
      const envs = await this.envs();
      let position = initPosition;
      for (const env of envs) {
        position = position - stepPosition;
        await this.updateDb({ id: env.id, position });
      }
    }
  }
  private getPrecisionPosition(position: number): number {
    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 = new RegExp(searchText);
      const reg = {
        [Op.or]: [
          { [Op.like]: `%${searchText}%` },
          { [Op.like]: `%${encodeText}%` },
        ],
      };
      condition = {
-        ...condition,
+        $or: [
        [Op.or]: [
          {
            name: reg,
          },
          {
            value: reg,
          },
          {
            name: reg,
          },
          {
            remarks: reg,
          },
        ],
      };
    }
-    try {
+    const newDocs = await this.find(condition, sort);
-      const result = await this.find(condition, [
+    return newDocs;
        ['isPinned', 'DESC'],
        ['position', 'DESC'],
        ['createdAt', 'ASC'],
      ]);
      return result;
    } catch (error) {
      throw error;
    }
  }
-  private async find(query: any, sort: any = []): Promise<Env[]> {
+  private async find(query: any, sort: any): Promise<Env[]> {
-    const docs = await EnvModel.findAll({
+    return new Promise((resolve) => {
-      where: { ...query },
+      this.envDb
-      order: [...sort],
+        .find(query)
        .sort({ ...sort })
        .exec((err, docs) => {
          resolve(docs);
        });
    });
    return docs.map((x) => x.get({ plain: true }));
  }
-  public async getDb(query: FindOptions<Env>['where']): Promise<Env> {
+  public async get(_id: string): Promise<Env> {
-    const doc: any = await EnvModel.findOne({ where: { ...query } });
+    return new Promise((resolve) => {
-    if (!doc) {
+      this.envDb.find({ _id }).exec((err, docs) => {
-      throw new Error(`Env ${JSON.stringify(query)} not found`);
+        resolve(docs[0]);
-    }
+      });
-    return doc.get({ plain: true });
+    });
  }
-  public async disabled(ids: number[]) {
+  public async getBySort(sort: any): Promise<Env> {
-    await EnvModel.update(
+    return new Promise((resolve) => {
-      { status: EnvStatus.disabled },
+      this.envDb
-      { where: { id: ids } },
+        .find({})
-    );
+        .sort({ ...sort })
-    await this.set_envs();
+        .limit(1)
        .exec((err, docs) => {
          resolve(docs[0]);
        });
    });
  }
-  public async enabled(ids: number[]) {
+  public async disabled(ids: string[]) {
-    await EnvModel.update({ status: EnvStatus.normal }, { where: { id: ids } });
+    return new Promise((resolve: any) => {
-    await this.set_envs();
+      this.envDb.update(
        { _id: { $in: ids } },
        { $set: { status: EnvStatus.disabled } },
        { multi: true },
        async (err) => {
          await this.set_envs();
          resolve();
        },
      );
    });
  }
-  public async updateNames({ ids, name }: { ids: number[]; name: string }) {
+  public async enabled(ids: string[]) {
-    await EnvModel.update({ name }, { where: { id: ids } });
+    return new Promise((resolve: any) => {
-    await this.set_envs();
+      this.envDb.update(
        { _id: { $in: ids } },
        { $set: { status: EnvStatus.normal } },
        { multi: true },
        async (err, num) => {
          await this.set_envs();
          resolve();
        },
      );
    });
  }
-  public async pin(ids: number[]) {
+  public async updateNames({ ids, name }: { ids: string[]; name: string }) {
-    await EnvModel.update({ isPinned: 1 }, { where: { id: ids } });
+    return new Promise((resolve: any) => {
-  }
+      this.envDb.update(
-
+        { _id: { $in: ids } },
-  public async unPin(ids: number[]) {
+        { $set: { name } },
-    await EnvModel.update({ isPinned: 0 }, { where: { id: ids } });
+        { multi: true },
        async (err, num) => {
          await this.set_envs();
          resolve();
        },
      );
    });
  }
  public async set_envs() {
-    const envs = await this.envs('', {
+    const envs = await this.envs(
-      name: { [Op.not]: null },
+      '',
-      status: EnvStatus.normal,
+      { position: -1 },
-    });
+      { name: { $exists: true } },
-    const groups = groupBy(envs, 'name');
+    );
    const groups = _.groupBy(envs, 'name');
    let env_string = '';
    let js_env_string = '';
    let py_env_string = 'import os\n';
    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)) {
+        if (/^[a-zA-Z_][0-9a-zA-Z_]+$/.test(key)) {
-          let value = group
+          env_string += `export ${key}="${_(group)
-            .map((x) => x.value)
+            .filter((x) => x.status !== EnvStatus.disabled)
            .map('value')
            .join('&')
-            .replace(/'/g, "'\\''")
+            .replace(/ /g, '')}"\n`;
            .trim();
          env_string += `export ${key}='${value}'\n`;
          const _env_value = `${group
            .map((x) => x.value)
            .join('&')
            .replace(/\\/g, '\\\\')}`;
          js_env_string += `process.env.${key}=\`${_env_value.replace(
            /\`/g,
            '\\`',
          )}\`;\n`;
          py_env_string += `os.environ['${key}']='''${_env_value.replace(
            /\'/g,
            "\\'",
          )}'''\n`;
        }
      }
    }
-    await writeFileWithLock(config.envFile, env_string);
+    fs.writeFileSync(config.envFile, env_string);
    await writeFileWithLock(config.jsEnvFile, js_env_string);
    await writeFileWithLock(config.pyEnvFile, py_env_string);
  }
 }
@@ -1,348 +0,0 @@
 // Graph Execution Engine for Visual Workflow
 import winston from 'winston';
 interface WorkflowNode {
  id: string;
  type: string;
  position: { x: number; y: number };
  data: any;
 }
 interface WorkflowEdge {
  id: string;
  source: string;
  target: string;
 }
 interface WorkflowGraph {
  nodes: WorkflowNode[];
  edges: WorkflowEdge[];
 }
 interface ExecutionContext {
  triggerData: any;
  variables: Map<string, any>;
  executedNodes: Set<string>;
  results: Map<string, any>;
 }
 export class GraphExecutor {
  private logger: winston.Logger;
  constructor(logger: winston.Logger) {
    this.logger = logger;
  }
  /**
   * Execute a workflow graph
   */
  public async executeGraph(
    workflowGraph: WorkflowGraph,
    triggerData: any,
    executor: any, // ScenarioService instance
  ): Promise<{ success: boolean; results: any; executedNodes: string[] }> {
    const context: ExecutionContext = {
      triggerData,
      variables: new Map(),
      executedNodes: new Set(),
      results: new Map(),
    };
    try {
      // Find trigger nodes (entry points)
      const triggerNodes = workflowGraph.nodes.filter(
        (node) => node.type === 'trigger',
      );
      if (triggerNodes.length === 0) {
        throw new Error('No trigger node found in workflow');
      }
      // Execute from each trigger node
      for (const triggerNode of triggerNodes) {
        await this.executeNode(
          triggerNode,
          workflowGraph,
          context,
          executor,
        );
      }
      return {
        success: true,
        results: Object.fromEntries(context.results),
        executedNodes: Array.from(context.executedNodes),
      };
    } catch (error: any) {
      this.logger.error('Graph execution failed:', error);
      return {
        success: false,
        results: { error: error.message },
        executedNodes: Array.from(context.executedNodes),
      };
    }
  }
  /**
   * Execute a single node and its connected nodes
   */
  private async executeNode(
    node: WorkflowNode,
    graph: WorkflowGraph,
    context: ExecutionContext,
    executor: any,
  ): Promise<any> {
    // Skip if already executed
    if (context.executedNodes.has(node.id)) {
      return context.results.get(node.id);
    }
    this.logger.info(`Executing node: ${node.id} (${node.type})`);
    context.executedNodes.add(node.id);
    let result: any = null;
    try {
      // Execute based on node type
      switch (node.type) {
        case 'trigger':
          result = await this.executeTriggerNode(node, context, executor);
          break;
        case 'condition':
          result = await this.executeConditionNode(node, context, executor);
          break;
        case 'action':
          result = await this.executeActionNode(node, context, executor);
          break;
        case 'control':
          result = await this.executeControlNode(node, context, executor);
          break;
        case 'logic_gate':
          result = await this.executeLogicGateNode(node, context, executor);
          break;
        default:
          this.logger.warn(`Unknown node type: ${node.type}`);
          result = { skipped: true };
      }
      context.results.set(node.id, result);
      // Find and execute next nodes
      const nextEdges = graph.edges.filter((edge) => edge.source === node.id);
      for (const edge of nextEdges) {
        const nextNode = graph.nodes.find((n) => n.id === edge.target);
        if (nextNode) {
          await this.executeNode(nextNode, graph, context, executor);
        }
      }
      return result;
    } catch (error: any) {
      this.logger.error(`Node execution failed: ${node.id}`, error);
      context.results.set(node.id, { error: error.message });
      throw error;
    }
  }
  private async executeTriggerNode(
    node: WorkflowNode,
    context: ExecutionContext,
    executor: any,
  ): Promise<any> {
    // Trigger nodes just pass through the trigger data
    return { triggered: true, data: context.triggerData };
  }
  private async executeConditionNode(
    node: WorkflowNode,
    context: ExecutionContext,
    executor: any,
  ): Promise<any> {
    const { field, operator, value } = node.data;
    // Get field value from trigger data or variables
    let fieldValue = this.getFieldValue(field, context);
    // Evaluate condition
    const matched = this.evaluateCondition(fieldValue, operator, value);
    this.logger.info(
      `Condition ${node.id}: ${field} ${operator} ${value} = ${matched}`,
    );
    return { matched, fieldValue, expectedValue: value };
  }
  private async executeActionNode(
    node: WorkflowNode,
    context: ExecutionContext,
    executor: any,
  ): Promise<any> {
    const { actionType } = node.data;
    switch (actionType) {
      case 'run_task':
        return await executor.executeRunTask(node.data);
      case 'set_variable':
        return await executor.executeSetVariable(node.data);
      case 'execute_command':
        return await executor.executeCommand(node.data);
      case 'send_notification':
        return await executor.executeSendNotification(node.data);
      default:
        throw new Error(`Unknown action type: ${actionType}`);
    }
  }
  private async executeControlNode(
    node: WorkflowNode,
    context: ExecutionContext,
    executor: any,
  ): Promise<any> {
    const { controlType } = node.data;
    switch (controlType) {
      case 'delay':
        const delayMs = (node.data.delaySeconds || 0) * 1000;
        await new Promise((resolve) => setTimeout(resolve, delayMs));
        return { delayed: delayMs };
      case 'retry':
        // Retry logic handled by caller
        return { retryConfig: node.data };
      case 'circuit_breaker':
        // Circuit breaker logic handled by caller
        return { circuitBreakerConfig: node.data };
      default:
        throw new Error(`Unknown control type: ${controlType}`);
    }
  }
  private async executeLogicGateNode(
    node: WorkflowNode,
    context: ExecutionContext,
    executor: any,
  ): Promise<any> {
    const { gateType } = node.data;
    // Logic gates are evaluated by checking incoming edges
    return { gateType, passed: true };
  }
  private getFieldValue(field: string, context: ExecutionContext): any {
    // Support dot notation for nested fields
    const parts = field.split('.');
    let value: any = context.triggerData;
    for (const part of parts) {
      if (value && typeof value === 'object' && part in value) {
        value = value[part];
      } else {
        // Check variables
        if (context.variables.has(field)) {
          return context.variables.get(field);
        }
        return undefined;
      }
    }
    return value;
  }
  private evaluateCondition(
    fieldValue: any,
    operator: string,
    expectedValue: any,
  ): boolean {
    switch (operator) {
      case 'equals':
        return fieldValue == expectedValue;
      case 'not_equals':
        return fieldValue != expectedValue;
      case 'greater_than':
        return Number(fieldValue) > Number(expectedValue);
      case 'less_than':
        return Number(fieldValue) < Number(expectedValue);
      case 'contains':
        return String(fieldValue).includes(String(expectedValue));
      case 'not_contains':
        return !String(fieldValue).includes(String(expectedValue));
      default:
        this.logger.warn(`Unknown operator: ${operator}`);
        return false;
    }
  }
  /**
   * Validate a workflow graph
   */
  public validateGraph(workflowGraph: WorkflowGraph): {
    valid: boolean;
    errors: string[];
  } {
    const errors: string[] = [];
    // Check for at least one trigger node
    const triggerNodes = workflowGraph.nodes.filter(
      (node) => node.type === 'trigger',
    );
    if (triggerNodes.length === 0) {
      errors.push('Workflow must have at least one trigger node');
    }
    // Check for cycles (simple check)
    const visited = new Set<string>();
    const recursionStack = new Set<string>();
    const hasCycle = (nodeId: string): boolean => {
      visited.add(nodeId);
      recursionStack.add(nodeId);
      const outgoingEdges = workflowGraph.edges.filter(
        (edge) => edge.source === nodeId,
      );
      for (const edge of outgoingEdges) {
        if (!visited.has(edge.target)) {
          if (hasCycle(edge.target)) {
            return true;
          }
        } else if (recursionStack.has(edge.target)) {
          return true;
        }
      }
      recursionStack.delete(nodeId);
      return false;
    };
    for (const node of workflowGraph.nodes) {
      if (!visited.has(node.id) && hasCycle(node.id)) {
        errors.push('Workflow contains cycles');
        break;
      }
    }
    // Check for disconnected nodes (excluding triggers)
    const connectedNodes = new Set<string>();
    workflowGraph.edges.forEach((edge) => {
      connectedNodes.add(edge.source);
      connectedNodes.add(edge.target);
    });
    const disconnectedNodes = workflowGraph.nodes.filter(
      (node) =>
        node.type !== 'trigger' && !connectedNodes.has(node.id),
    );
    if (disconnectedNodes.length > 0) {
      errors.push(
        `Disconnected nodes found: ${disconnectedNodes.map((n) => n.id).join(', ')}`,
      );
    }
    return {
      valid: errors.length === 0,
      errors,
    };
  }
 }
@@ -1,64 +0,0 @@
 import { Server, ServerCredentials } from '@grpc/grpc-js';
 import { CronService } from '../protos/cron';
 import { HealthService } from '../protos/health';
 import { ApiService } from '../protos/api';
 import { addCron } from '../schedule/addCron';
 import { delCron } from '../schedule/delCron';
 import { check } from '../schedule/health';
 import * as Api from '../schedule/api';
 import Logger from '../loaders/logger';
 import { promisify } from 'util';
 import config from '../config';
 import { metricsService } from './metrics';
 import { Service } from 'typedi';
@Service()
 export class GrpcServerService {
  private server: Server = new Server({ 'grpc.enable_http_proxy': 0 });
  async initialize() {
    try {
      this.server.addService(HealthService, { check });
      this.server.addService(CronService, { addCron, delCron });
      this.server.addService(ApiService, Api);
      const grpcPort = config.grpcPort;
      const bindAsync = promisify(this.server.bindAsync).bind(this.server);
      await bindAsync(
        `0.0.0.0:${grpcPort}`,
        ServerCredentials.createInsecure(),
      );
      Logger.debug(`✌️ gRPC service started successfully`);
      metricsService.record('grpc_service_start', 1, {
        port: grpcPort.toString(),
      });
      return grpcPort;
    } catch (err) {
      Logger.error('Failed to start gRPC service:', err);
      throw err;
    }
  }
  async shutdown() {
    try {
      if (this.server) {
        await new Promise((resolve) => {
          this.server.tryShutdown(() => {
            Logger.debug('gRPC service stopped');
            metricsService.record('grpc_service_stop', 1);
            resolve(null);
          });
        });
      }
    } catch (err) {
      Logger.error('Error while shutting down gRPC service:', err);
      throw err;
    }
  }
  getServer() {
    return this.server;
  }
 }
@@ -1,72 +0,0 @@
 import { Service } from 'typedi';
 import Logger from '../loaders/logger';
 import { GrpcServerService } from './grpc';
 import { HttpServerService } from './http';
 interface HealthStatus {
  status: 'ok' | 'error';
  services: {
    http: boolean;
    grpc: boolean;
  };
  metrics: {
    uptime: number;
    memory: {
      used: number;
      total: number;
    };
  };
 }
@Service()
 export class HealthService {
  private startTime = Date.now();
  constructor(
    private grpcServerService: GrpcServerService,
    private httpServerService: HttpServerService,
  ) {}
  async check(): Promise<HealthStatus> {
    const status: HealthStatus = {
      status: 'ok',
      services: {
        http: true,
        grpc: true,
      },
      metrics: {
        uptime: Math.floor((Date.now() - this.startTime) / 1000),
        memory: {
          used: process.memoryUsage().heapUsed,
          total: process.memoryUsage().heapTotal,
        },
      },
    };
    try {
      const httpServer = this.httpServerService.getServer();
      if (!httpServer) {
        status.services.http = false;
        status.status = 'error';
      }
    } catch (err) {
      status.services.http = false;
      status.status = 'error';
      Logger.error('HTTP server check failed:', err);
    }
    try {
      const grpcServer = this.grpcServerService.getServer();
      if (!grpcServer) {
        status.services.grpc = false;
        status.status = 'error';
      }
    } catch (err) {
      status.services.grpc = false;
      status.status = 'error';
      Logger.error('gRPC server check failed:', err);
    }
    return status;
  }
 }
@@ -1,53 +0,0 @@
 import express from 'express';
 import Logger from '../loaders/logger';
 import { metricsService } from './metrics';
 import { Service } from 'typedi';
 import { Server } from 'http';
@Service()
 export class HttpServerService {
  private server?: Server = undefined;
  async initialize(expressApp: express.Application, port: number) {
    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?.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;
    }
  }
  async shutdown() {
    try {
      if (this.server) {
        await new Promise((resolve) => {
          this.server?.close(() => {
            Logger.debug('HTTP service stopped');
            metricsService.record('http_service_stop', 1);
            resolve(null);
          });
        });
      }
    } catch (err) {
      Logger.error('Error while shutting down HTTP service:', err);
      throw err;
    }
  }
  getServer() {
    return this.server;
  }
 }
@@ -1,14 +0,0 @@
 import path from 'path';
 import { Inject, Service } from 'typedi';
 import winston from 'winston';
 import config from '../config';
@Service()
 export default class LogService {
  constructor(@Inject('logger') private logger: winston.Logger) {}
  public checkFilePath(filePath: string, fileName: string) {
    const finalPath = path.resolve(config.logPath, filePath, fileName);
    return finalPath.startsWith(config.logPath) ? finalPath : '';
  }
 }
@@ -1,92 +0,0 @@
 import { performance } from 'perf_hooks';
 import Logger from '../loaders/logger';
 interface Metric {
  name: string;
  value: number;
  timestamp: number;
  tags?: Record<string, string>;
 }
 class MetricsService {
  private metrics: Metric[] = [];
  private static instance: MetricsService;
  private constructor() {
    // 定期清理旧数据
    setInterval(() => {
      const oneHourAgo = Date.now() - 3600000;
      this.metrics = this.metrics.filter(m => m.timestamp > oneHourAgo);
    }, 60000);
  }
  static getInstance(): MetricsService {
    if (!MetricsService.instance) {
      MetricsService.instance = new MetricsService();
    }
    return MetricsService.instance;
  }
  record(name: string, value: number, tags?: Record<string, string>) {
    this.metrics.push({
      name,
      value,
      timestamp: Date.now(),
      tags,
    });
  }
  measure(name: string, fn: () => void, tags?: Record<string, string>) {
    const start = performance.now();
    try {
      fn();
    } finally {
      const duration = performance.now() - start;
      this.record(name, duration, tags);
    }
  }
  async measureAsync(name: string, fn: () => Promise<void>, tags?: Record<string, string>) {
    const start = performance.now();
    try {
      await fn();
    } finally {
      const duration = performance.now() - start;
      this.record(name, duration, tags);
    }
  }
  getMetrics(name?: string, tags?: Record<string, string>) {
    let filtered = this.metrics;
    if (name) {
      filtered = filtered.filter(m => m.name === name);
    }
    if (tags) {
      filtered = filtered.filter(m => {
        if (!m.tags) return false;
        return Object.entries(tags).every(([key, value]) => m.tags![key] === value);
      });
    }
    return {
      count: filtered.length,
      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,
    };
  }
  report() {
    const report = {
      timestamp: Date.now(),
      metrics: this.getMetrics(),
    };
    Logger.info('性能指标报告:', report);
    return report;
  }
 }
 export const metricsService = MetricsService.getInstance(); 
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
whyour	a266425348	修复拷贝deps	2021-11-13 22:05:54 +08:00
whyour	6dbe02e321	修复dep目录	2021-11-13 21:54:45 +08:00
whyour	39979879c9	更新版本 v2.10.7	2021-11-13 21:21:35 +08:00
whyour	ba3f604a5c	修复bot安装依赖判断	2021-11-13 20:58:27 +08:00
whyour	9572582401	修改拷贝依赖	2021-11-13 19:05:34 +08:00
whyour	2bcef0ba75	修复脚本管理搜索	2021-11-13 17:42:06 +08:00
whyour	31cd7c4007	外部依赖改为系统直接分发通知文件js和py版	2021-11-13 17:21:27 +08:00
whyour	1c4c1799b0	修复环境变量表格样式	2021-11-13 16:44:21 +08:00
whyour	2d558df15e	修复schedule服务	2021-11-13 12:34:49 +08:00
whyour	7b769da4e2	修复脚本管理树结构	2021-11-13 11:14:43 +08:00
whyour	4e95d62933	更新版本 v2.10.6	2021-11-13 00:03:12 +08:00
whyour	83255280b9	修复检查更新	2021-11-12 23:55:57 +08:00
whyour	2546cebdea	修复定时匹配	2021-11-12 23:42:11 +08:00
whyour	f14a3fe0f1	修复脚本管理数据	2021-11-12 23:18:24 +08:00
whyour	c3eb845be4	修改workflow变量	2021-11-12 22:09:02 +08:00
MiniersandGitHub	1eef77dca5	增加环境变量更新时间 (#887 )	2021-11-12 21:55:03 +08:00
风之凌殇andGitHub	d7d9f47fe5	增加在添加语义化版本tag时自动生成static并构建多个不同tag的容器的workflow，简化版本发布流程 (#888 )	2021-11-12 21:54:42 +08:00
whyour	fce6a996d9	更新版本号 v2.10.5	2021-11-12 14:23:16 +08:00
whyour	48a484d7de	修复文件判断引起服务异常	2021-11-12 14:22:21 +08:00
whyour	4b81d3c612	更新版本号	2021-11-12 13:18:32 +08:00
whyour	21b6edd7eb	修复entrypoint启动失败	2021-11-12 13:16:53 +08:00
whyour	9a43e022e9	修改版本说明序号	2021-11-11 23:04:29 +08:00
whyour	62bef3f13d	更新版本号 v2.10.3	2021-11-11 23:03:28 +08:00
whyour	c87f5fa004	服务重启时依赖改为单独安装，避免同时失败	2021-11-11 22:56:47 +08:00
whyour	8d99f3ffbb	修复获取日志判断	2021-11-11 22:50:28 +08:00
whyour	100ca7b54b	单个数据库文件大于500兆时，裁剪文件，避免服务无法启动	2021-11-11 22:41:12 +08:00
whyour	4a2624f12a	脚本管理改成树结构	2021-11-11 00:10:05 +08:00
whyour	21b01a85a8	修复pushplus通知设置	2021-11-10 23:33:19 +08:00
whyour	e039ae436e	修复依赖文件获取	2021-11-10 23:26:21 +08:00
whyour	b13a1a45f8	修复repo依赖路径	2021-11-10 10:35:53 +08:00
whyour	667fe2bbba	修复shell语法	2021-11-09 23:55:50 +08:00
whyour	f083871ca0	修复repo文件比对	2021-11-09 23:23:07 +08:00
whyour	782e1ba235	修改ql repo逻辑	2021-11-09 23:07:43 +08:00
whyour	b92c6edc4e	添加动态引入	2021-11-09 22:34:24 +08:00
whyour	bdf4657c73	修改退出下拉样式	2021-11-08 22:56:53 +08:00
whyour	8559438611	修改数据库加载	2021-11-08 22:47:46 +08:00
whyour	04045fd410	修复centos -x兼容性	2021-11-07 21:54:31 +08:00
whyour	1c71a9d8a8	回退shell [	2021-11-07 19:18:36 +08:00
whyour	9a9ae9782c	修改pnpm安装源	2021-11-07 12:51:10 +08:00
whyour	da2569850b	修复entrypoint	2021-11-07 11:25:18 +08:00
whyour	b475035415	修复 arm 没有nginx conf.d 目录	2021-11-07 11:08:21 +08:00
OreoandGitHub	7baee27585	更新 Python 通知文件 (#832 ) 已在 Python3.6.x（云函数平台），3.8.x，3.10.0 测试通过特性如下 1. 支持 11 种推送方式，未来还会继续添加 2. 多线程通知 3. 支持一言（一句话）和控制台输出开关 4. 对于现有推送方式，补充了配置变量	2021-11-06 20:45:53 +08:00
whyour	2cb2f1ce0a	更新dockerfile	2021-11-06 20:19:07 +08:00
whyour	8c1407e2a9	修改dockerfile	2021-11-06 19:04:01 +08:00
whyour	7bcb113085	更新docker yml	2021-11-06 18:58:18 +08:00
whyour	42dc27addf	修复任务日志结束时间展示	2021-11-06 00:50:44 +08:00
whyour	aac30398c4	修复toLocaleString 0点显示24点	2021-11-05 23:56:16 +08:00
whyour	ceae888372	修改shell语法	2021-11-05 23:39:22 +08:00
whyour	61df7050db	修复移动端展开导航	2021-11-04 19:24:55 +08:00
whyour	af5561cbbf	更新版本号 v2.10.2	2021-11-04 18:10:43 +08:00
whyour	bce30f922d	修复基础镜像pip3依赖	2021-11-04 18:10:14 +08:00
whyour	d6ed394557	修复openapi路由	2021-11-04 18:07:34 +08:00
whyour	7b512a1681	更新版本号 v2.10.1	2021-11-04 15:09:07 +08:00
whyour	7af0597cd5	添加白屏时间及错误上报	2021-11-04 15:05:34 +08:00
whyour	2f5cf6d93c	修复check命令	2021-11-03 16:35:18 +08:00
whyour	d672d2d104	修改失败任务日志	2021-11-01 23:06:23 +08:00
whyour	c0d1fb1ef4	shell 中 [ 改为 [[	2021-11-01 23:04:10 +08:00
whyour	3c882ad0ce	移动退出登录位置	2021-11-01 15:23:06 +08:00
whyour	58acd2eb68	修复表格滚动高度	2021-10-31 19:45:51 +08:00
whyour	590473e7d2	修复无法覆盖安装依赖	2021-10-31 17:34:19 +08:00
14kk GitHub 14K	21139157c8	修改错误文字 (#809 ) Co-authored-by: 14K <9112790+the14k@user.noreply.gitee.com>	2021-10-29 23:26:44 +08:00
whyour	8f8296ab64	支持服务端端口直接访问前端	2021-10-28 23:35:21 +08:00
whyour	40bf07d2a4	修复置顶后编辑置顶消失	2021-10-28 22:38:34 +08:00
whyour	fd2b4fb86d	更新版本号 v2.10.0	2021-10-24 17:51:20 +08:00
whyour	783e867ef6	修复python移除依赖命令	2021-10-24 17:19:14 +08:00
whyour	3873d9f978	添加依赖管理	2021-10-24 17:07:16 +08:00
whyour	7dece938c8	依赖安装日志增加安装时间	2021-10-24 11:11:23 +08:00
whyour	0842d66c79	修复表格初次获取滚动高度	2021-10-23 23:44:11 +08:00
whyour	d071e50d62	由于浏览器兼容性，移除dynamicImport	2021-10-23 23:31:46 +08:00
whyour	337f01aff1	修复python3任务无法停止	2021-10-23 23:22:08 +08:00
whyour	5614e41eb0	修复service引入路径	2021-10-23 18:46:24 +08:00
whyour	4f0fdbe453	初始化安装所有依赖	2021-10-23 18:44:25 +08:00
whyour	49c068db78	修改依赖安装结束标识	2021-10-23 18:27:20 +08:00
whyour	fbba44d482	添加依赖管理	2021-10-23 18:23:32 +08:00
whyour	10c07b0a09	两步验证输入框自动聚焦	2021-10-21 22:25:15 +08:00
whyour	20893698ba	更新版本号 v2.9.10	2021-10-21 21:59:24 +08:00
longjuanandGitHub	31de659ed3	更新install.md (#789 )	2021-10-21 21:55:26 +08:00
whyour	6c08a16c66	修改websocket日志	2021-10-21 21:52:06 +08:00
whyour	21e7178f48	修复table滚动高度	2021-10-21 19:13:38 +08:00
whyour	aefd267eb2	更新monaco	2021-10-19 22:41:59 +08:00
whyour	fb1a3980d4	检查密码默认值	2021-10-19 21:46:24 +08:00
whyour	cfc467f8a5	修复tg系统通知认证参数	2021-10-18 19:18:46 +08:00
whyour	48120f012d	修复检查更新日志展示	2021-10-18 17:05:38 +08:00
whyour	c907a78437	修复shell变量重复	2021-10-16 19:32:23 +08:00
whyour	915c0d09a9	升级umi	2021-10-16 17:21:19 +08:00
whyour	80638862cc	添加 yarn.lock	2021-10-16 17:07:05 +08:00
whyour	a7350948cd	更新版本号 v2.9.9	2021-10-16 15:19:53 +08:00
whyour	1e1be013b5	脚本管理移动端支持添加脚本、编辑脚本	2021-10-16 15:11:23 +08:00
hanhh	4062584eae	移除无用代码	2021-10-16 13:39:18 +08:00
hanhh	abedddffa6	修复表格样式	2021-10-16 10:53:14 +08:00
hanhh	38858ccdb2	修改pm2任务日志	2021-10-15 22:32:32 +08:00
hanhh	d56e6359d0	修复更新日志匹配正则	2021-10-15 22:14:42 +08:00
hanhh	5886991464	放开ql update删除操作	2021-10-15 22:01:34 +08:00
hanhh	838326616b	更新版本号 v2.9.8-001	2021-10-15 11:47:32 +08:00
hanhh	fcf80fe946	修复设置删除日志	2021-10-15 10:53:27 +08:00
phoenixandGitHub	2e63a7056c	修复nginx.conf错误 (#776 ) Fix nginx: [emerg] unknown directive. Log `nginx: [emerg] unknown directive "client_body_buffer_size:" in /etc/nginx/nginx.conf:18 `	2021-10-15 10:40:58 +08:00
hanhh	7c807e3ec8	更新版本 2.9.8	2021-10-14 22:07:21 +08:00
hanhh	b558aa0934	修复初始化流程	2021-10-14 22:00:36 +08:00
hanhh	38757758cb	增加日志删除频率设置	2021-10-14 10:58:54 +08:00
hanhh	84dd3d8fd1	修改版本更新执行命令	2021-10-13 23:50:25 +08:00
hanhh	19423c2d30	添加ql -l update	2021-10-13 23:45:46 +08:00
hanhh	98bba7d7fa	更新nginx配置文件	2021-10-13 23:31:38 +08:00
hanhh	dcaa9ce000	修复websocket连接域名	2021-10-13 23:09:48 +08:00
hanhh	3cae44a136	修复版本号匹配正则	2021-10-13 22:53:10 +08:00
hanhh	df8a3d2692	修复版本号匹配	2021-10-13 22:45:24 +08:00
hanhh	56e43f1808	移除远程版本更新链接	2021-10-13 22:41:59 +08:00
hanhh	2f6b95cccf	修复获取最后版本文件	2021-10-13 22:39:59 +08:00
hanhh	ad9f6b2b64	修复获取最新版本号	2021-10-13 22:05:54 +08:00
hanhh	165c3dc976	容器启动忽略config和env中的错误	2021-10-13 14:25:38 +08:00
hanhh	cbe6390b41	修复版本检查	2021-10-12 23:06:28 +08:00
hanhh	026eaf6606	完善检查更新操作	2021-10-12 22:54:17 +08:00
hanhh	ee184f8e62	并发命令支持指定账号	2021-10-12 21:58:41 +08:00
hanhh	5745231dc9	添加系统更新操作和设置删除日志频率	2021-10-12 00:27:42 +08:00
hanhh	cbdc3a9861	添加检查更新和删除日志频率操作	2021-10-08 23:02:45 +08:00
hanhh	ba5c42ad6d	修复表格滚动样式和交互	2021-10-08 22:39:17 +08:00
hanhh	b056a731a1	增加新版本检测	2021-10-07 15:26:25 +08:00
hanhh	b4cd94f2d9	增加环境变量名称正则校验	2021-10-06 16:38:46 +08:00
hanhh	3b8cb43f02	添加新版本提醒	2021-10-06 16:22:53 +08:00
hanhh	82cb11c3c4	更新版本号 v2.9.7	2021-10-03 22:26:16 +08:00
SowevoandGitHub	eb7522a90b	增加企业微信机器人推送的python版本 (#748 )	2021-10-03 22:16:07 +08:00
hanhh	3898201b1e	修复登录两步提醒样式	2021-10-03 22:05:56 +08:00
hanhh	bb6ab0c17b	修改初始化判断条件	2021-10-03 22:01:44 +08:00
hanhh	652c40ab1f	增加初始化过程	2021-10-03 20:58:55 +08:00
hanhh	ca0d6215a9	修复entrypoint启动nginx配置	2021-09-30 23:49:19 +08:00
hanhh	61d155257c	ql update添加patch	2021-09-30 19:14:40 +08:00
hanhh	91399f1a1f	移除check中init git	2021-09-30 19:08:13 +08:00
hanhh	2e738c5977	更新版本号 v2.9.6	2021-09-29 23:16:59 +08:00
hanhh	c0bd51cf03	修复类型检查	2021-09-29 23:15:09 +08:00
hanhh	ca5afe04f8	修复退出登录获取token出错	2021-09-29 23:09:13 +08:00
hanhh	47db0b9f4e	对比工具支持对比config目录下的文件	2021-09-29 22:48:49 +08:00
hanhh	27f17a377a	重启服务时自动压缩db	2021-09-29 21:40:35 +08:00
hanhh	ecaf731ecf	修复loading状态位置	2021-09-29 21:19:25 +08:00
hanhh	9fba2a85f6	修复清空文件操作	2021-09-27 22:04:47 +08:00
hanhh	93f75be182	task和ql命令添加基础目录检测	2021-09-27 19:38:06 +08:00
hanhh	d537901f59	测试动态加载	2021-09-25 12:11:13 +08:00
hanhh	260c1ed4a4	修改定时任务列表滚动宽度	2021-09-25 11:40:55 +08:00
hanhh	ac2bd52463	修复status接口参数	2021-09-25 02:00:50 +08:00
hanhh	16c6f8fee1	修复并发参数	2021-09-25 01:51:18 +08:00
hanhh	8a0db21f17	更新版本号	2021-09-25 00:43:05 +08:00
hanhh	9ab08a71c0	增加登录设备展示	2021-09-25 00:42:03 +08:00
hanhh	381c32a3b4	修复更新任务状态api	2021-09-25 00:28:18 +08:00
hanhh	350c0f10c4	修复ql resettfa命令	2021-09-25 00:15:23 +08:00
hanhh	d5b982f813	ql resettfa增加兼容字段	2021-09-24 23:33:52 +08:00
hanhh	6587375ff2	移除定时任务左右列固定n	2021-09-24 23:31:50 +08:00
hanhh	f5ecb81bad	ql bot移除自动更新远程仓库	2021-09-24 23:22:40 +08:00
hanhh	0141cd81c4	修复服务端ts类型检查	2021-09-24 22:49:14 +08:00
hanhh	ff412c7497	更新版本号	2021-09-24 22:30:09 +08:00
hanhh	623f239f91	修复定时任务操作宽度	2021-09-24 22:28:25 +08:00
hanhh	c7ba304c6a	支持多端登录	2021-09-24 22:24:39 +08:00
hanhh	c8393604d1	修复task运行指定账号	2021-09-24 00:24:54 +08:00
hanhh	c5d47a67aa	修复定时任务列表下次运行时间	2021-09-24 00:11:14 +08:00
hanhh	3a1423cd59	task支持指定账号运行	2021-09-23 23:59:53 +08:00
hanhh	d57f4cf6cd	修改定时任务表格布局	2021-09-23 22:12:19 +08:00
hanhh	af420942c4	添加最后运行时间和运行时长	2021-09-23 13:42:32 +08:00
hanhh	eac4e5e66f	修复主题切换全局class未变化	2021-09-21 23:29:38 +08:00
hanhh	b8822a98f7	定时任务添加下次运行时间	2021-09-21 20:11:39 +08:00
hanhh	95322b42c0	修改登录通知消息	2021-09-20 23:56:20 +08:00
hanhh	33f5a06d32	修复pushplus通知参数	2021-09-20 22:23:56 +08:00
hanhh	a7e5126c92	修复新建文件	2021-09-20 00:59:38 +08:00
hanhh	c62f3e5b8e	添加bak目录ignore	2021-09-20 00:47:58 +08:00
hanhh	5d3f413a05	修改测试通知内容	2021-09-19 23:10:58 +08:00
hanhh	644154ca38	更新版本号	2021-09-19 23:00:53 +08:00
hanhh	cccce5ff74	修复通知	2021-09-19 23:00:21 +08:00
hanhh	aa1fe98188	定时任务增加置顶功能	2021-09-19 22:25:57 +08:00
hanhh	b6a78550d6	添加全局主题className	2021-09-19 21:27:20 +08:00
hanhh	70b7f2c493	脚本管理支持新增文件	2021-09-19 21:23:03 +08:00
hanhh	ea44e5f209	修复pageTitle	2021-09-18 23:27:50 +08:00
hanhh	41ef87d9f8	任务详情日志添加loading	2021-09-18 16:33:12 +08:00
hanhh	c0b4a70aa0	添加全局loading	2021-09-18 15:08:45 +08:00
hanhh	955875cb7a	修复关闭通知	2021-09-18 02:09:06 +08:00
hanhh	827e8571aa	添加通知设置页面	2021-09-18 01:44:55 +08:00
whyour	aed08b0f59	添加通知api	2021-09-17 18:06:14 +08:00
hanhh	3ddaf41e27	更新通知服务	2021-09-17 00:35:27 +08:00
whyour	38a9cce6bf	更新通知服务	2021-09-16 21:01:29 +08:00
whyour	ae255ef381	添加通知服务	2021-09-16 18:01:25 +08:00
prcxuandGitHub	4316bef01e	更新安装说明 (#705 )	2021-09-15 11:18:58 +08:00
JH2628andGitHub	8491c5706d	修复config sample序号 (#694 )	2021-09-14 19:25:00 +08:00
hanhh	7b7fab1f32	修改系统异常提醒	2021-09-13 00:12:44 +08:00
hanhh	5a6fccdc2f	更新tg链接	2021-09-12 20:28:43 +08:00
hanhh	23668be46d	更新版本号	2021-09-11 13:53:58 +08:00
hanhh	f92f2c1666	修复写入任务错误日志逻辑	2021-09-11 13:53:24 +08:00
hanhh	895740a3cb	修改获取用户数据逻辑	2021-09-11 02:03:31 +08:00
hanhh	4c76c3231f	移除自动压缩db数据	2021-09-09 13:02:49 +08:00
hanhh	ca9d3f9559	更新版本号	2021-09-08 12:26:21 +08:00
hanhh	3ca3c5e75c	修复开启两步失败提醒	2021-09-08 12:26:05 +08:00
hanhh	c2c0b1dfdc	添加应用名称改为选填	2021-09-08 12:15:30 +08:00
hanhh	c633774487	修复两步验证逻辑	2021-09-08 12:13:19 +08:00
hanhh	c2d86fc517	更新版本号	2021-09-07 23:53:01 +08:00
hanhh	d7c8d150ca	修改登陆日志title	2021-09-07 23:52:40 +08:00
L1n3andGitHub	6b8a4e65f2	添加安装说明 (#667 )	2021-09-07 17:46:53 +08:00
LeonandGitHub	482e43dd1f	修复 Python 和 JavaScript Server酱和企业微信推送的环境变量不一致 (#673 )	2021-09-07 17:46:14 +08:00
hanhh	1437babc6c	增加登录日志	2021-09-07 01:40:41 +08:00
Zy143LandGitHub	5ed882943a	修复python和JavaScript钉钉推送的环境变量不一致 (#659 )	2021-09-05 23:53:18 +08:00
hanhh	e678b3fb3a	config文件读取添加黑名单	2021-09-05 23:48:58 +08:00
hanhh	a5770bc4e4	添加环境变量命令input改为textarea	2021-09-05 23:38:36 +08:00
hanhh	59821bb939	修改ql check依赖安装逻辑	2021-09-03 22:30:24 +08:00
hanhh	b58040be44	修改两步验证逻辑	2021-09-03 19:09:09 +08:00
hanhh	be3b8ad52e	修复环境变量拖拽	2021-09-02 19:16:28 +08:00
hanhh	0fdaf97461	更新两步验证逻辑	2021-09-01 23:03:27 +08:00
L1n3andGitHub	f5f036372f	添加 docker-compose.yml (#629 )	2021-08-31 15:52:24 +08:00
hanhh	3fceb983e6	增加上次登录状态	2021-08-31 15:29:23 +08:00
hanhh	ae6a39196d	增加ql resettfa禁用两步验证	2021-08-31 11:06:20 +08:00
hanhh	2810ff2753	更新版本号	2021-08-31 10:56:37 +08:00
hanhh	205c0cf8d3	两步验证失败增加ip记录	2021-08-31 10:54:46 +08:00
hanhh	d9c801a091	添加两步验证	2021-08-30 23:37:26 +08:00
hanhh	0833aa3b30	增加nedb数据自定比对，测试对db文件不断增大的影响	2021-08-29 00:52:21 +08:00
hanhh	9c90bbc146	修复移动端无法打开脚本管理、任务日志	2021-08-29 00:34:47 +08:00
hanhh	231b387076	更换ip地址查询接口	2021-08-27 14:00:11 +08:00
hanhh	3de432652f	更换ip查询接口	2021-08-27 13:27:32 +08:00
hanhh	cad714493e	更新版本号	2021-08-27 11:08:08 +08:00
hanhh	6a690a6108	更新nginx配置	2021-08-27 11:04:31 +08:00
hanhh	1b85c52557	修改新建应用placeholder	2021-08-27 10:52:49 +08:00
hanhh	b37be92ea9	搜索时去掉前后空格	2021-08-27 10:47:30 +08:00
HeroWongandGitHub	f95979f445	fix: 只有一页时不隐藏分页栏，确保用户可以更改 pagesize (#613 )	2021-08-26 21:27:22 +08:00
hanhh	09e07218ae	添加openapi模块	2021-08-26 19:01:39 +08:00
hanhh	085f5a9451	更新版本号	2021-08-25 23:55:16 +08:00
hanhh	eb4e935554	修复cron分隔符，修复登录获取ip逻辑	2021-08-25 23:54:42 +08:00
hanhh	57986cf425	修复登录倒计时颜色	2021-08-25 18:58:45 +08:00
hanhh	7bf14b9acc	更新版本号	2021-08-25 18:20:29 +08:00
hanhh	3ba0be34d9	修复6位cron判断	2021-08-25 18:19:22 +08:00
hanhh	0f828a3c75	修复群辉update之后403	2021-08-25 17:58:21 +08:00
hanhh	16a768a142	更新版本号	2021-08-24 18:21:19 +08:00
hanhh	f380d20279	添加重置登录错误次数命令	2021-08-24 18:20:36 +08:00
hanhh	be908ab36c	添加默认定时规则配置	2021-08-23 19:10:57 +08:00
hanhh	b545454537	task传递参数给task_before和task_after	2021-08-23 15:58:25 +08:00
hanhh	a5ff8dd1d6	更新readme图片	2021-08-23 15:31:13 +08:00
hanhh	59f23e518b	修复readme图片	2021-08-23 15:26:30 +08:00
hanhh	858b3f0176	更新版本号	2021-08-23 13:50:44 +08:00
hanhh	89b8494ad0	修复获取ip api失败时，无法登陆修复禁用或者运行定时任务出现重复	2021-08-23 13:44:54 +08:00
hanhh	64ecd75bd5	修复定时任务搜索后页码	2021-08-23 12:29:29 +08:00
hanhh	138eb3393d	修复error_log文件读取	2021-08-23 11:41:34 +08:00
hanhh	1ad51d2925	更新版本号	2021-08-23 10:47:11 +08:00
hanhh	317e175bca	回退update.sh	2021-08-23 10:43:26 +08:00
hanhh	0e287aa7d1	修复task_before eval	2021-08-22 22:33:07 +08:00
hanhh	28018b705b	修复未产生日志文件cat报错	2021-08-22 22:02:31 +08:00
hanhh	46ec72d6be	ql命令增加-l参数	2021-08-22 21:57:10 +08:00
hanhh	82494a87af	修改task.sh任务顺序	2021-08-22 20:54:40 +08:00
hanhh	95c19b447a	修复task语法	2021-08-22 18:57:52 +08:00
hanhh	9c6eae936a	修复task.sh执行语法	2021-08-22 18:21:31 +08:00
hanhh	77605a9360	修改task.sh中参数名	2021-08-22 16:05:58 +08:00
hanhh	82880c3f06	修复最后登录ip读取	2021-08-22 15:25:16 +08:00
hanhh	11143c771b	更新版本号	2021-08-22 15:23:58 +08:00
hanhh	0968eaa5a8	修复任务执行参数出错	2021-08-22 15:23:12 +08:00
hanhh	0687f9d472	修改登陆成功提示文本	2021-08-22 14:47:07 +08:00
hanhh	25f0f5951a	更新版本号	2021-08-22 14:07:43 +08:00
hanhh	eec0ce65ad	修复获取访问ip逻辑	2021-08-22 14:07:00 +08:00
hanhh	be4e100168	更新版本号	2021-08-22 12:59:54 +08:00
hanhh	59e4f1063c	修复登录重试判断	2021-08-22 12:59:34 +08:00
hanhh	359e21f02b	登录增加错误延迟提醒	2021-08-22 12:28:45 +08:00
hanhh	6894bd9c0e	登录增加最后登录时间地点，登录失败增加重试间隔	2021-08-22 01:22:23 +08:00
hanhh	7040f02823	默认定时改为随机时间	2021-08-21 19:26:37 +08:00
hanhh	41408de337	修复更新环境变量备注无法删除	2021-08-21 18:34:53 +08:00
hanhh	72e243dce8	增加命令行运行日志实时打印	2021-08-21 17:26:41 +08:00
hanhh	77d4840e2a	定时任务，环境变量添加状态筛选	2021-08-20 16:31:24 +08:00
hanhh	0d5961821c	更新版本号	2021-08-20 16:17:04 +08:00
hanhh	f34980b173	移除console	2021-08-20 14:26:12 +08:00
hanhh	5b21a6e529	手动运行任务添加错误捕获	2021-08-20 10:59:59 +08:00
hanhh	6dbb737d4b	修复脚本管理编辑交互，修复ico无法加载	2021-08-19 23:46:26 +08:00
hanhh	76ecfbaaa2	更新版本号	2021-08-19 14:47:07 +08:00
hanhh	d9aacbcb92	定时任务支持任务名，定时，命令排序环境变量支持名称排序	2021-08-19 14:45:42 +08:00
hanhh	e088325d95	脚本管理支持编辑删除文件	2021-08-19 14:18:25 +08:00
hanhh	b29dd2c580	修复未勾选拆分环境变量参数验证失败	2021-08-17 22:31:39 +08:00
hanhh	89e82fd5b0	修复未勾选拆分环境变量参数验证失败	2021-08-17 22:26:33 +08:00
hanhh	9f0b671d42	修复手动运行任务进程	2021-08-17 22:06:04 +08:00
hanhh	7de7c724dc	更新版本号	2021-08-17 18:35:53 +08:00
hanhh	3525b1d92a	支持批量创建同名称环境变量，日志和脚本管理PC页支持宽度拖拽	2021-08-17 18:34:55 +08:00
hanhh	30cea84886	修改暗黑模式默认值	2021-08-16 18:05:52 +08:00
DerekandGitHub	0c2cc7f575	更正ql"本脚本用法"中的序号 (#552 )	2021-08-16 17:17:45 +08:00