修复拷贝deps

已在 Python3.6.x（云函数平台），3.8.x，3.10.0 测试通过
特性如下
1. 支持 11 种推送方式，未来还会继续添加
2. 多线程通知
3. 支持一言（一句话）和控制台输出开关
4. 对于现有推送方式，补充了配置变量

.env.example

@@ -1,11 +1,9 @@
-GRPC_PORT=5500
-BACK_PORT=5700
+MONGODB_URI='mongodb://'
+YIYAN_MONGODB_URI=''
 
-LOG_LEVEL='info'
+CRON_PORT=5500
+PORT=5600
 
-JWT_SECRET=
-JWT_EXPIRES_IN=
+LOG_LEVEL='debug'
 
-QINIU_AK=
-QINIU_SK=
-QINIU_SCOPE=
+SECRET='whyour'

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -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.

.github/ISSUE_TEMPLATE/config.yml

@@ -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.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -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

.github/PULL_REQUEST_TEMPLATE.md

@@ -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

.github/agents/ql.agent.md

@@ -1,4 +0,0 @@
----
-name: Bug Fixer
-description: Fix this issue following our error handling pattern.
----

.github/config.yml

@@ -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! 🎉🎉🎉

.github/workflows/build-docker-image.yml

@@ -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 }}

.github/workflows/build_docker_image.yml

@@ -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 }}

.github/workflows/docker.yml

@@ -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/

.gitignore

@@ -4,12 +4,12 @@
 /node_modules
 /npm-debug.log*
 /yarn-error.log
-/yarn.lock
+/pnpm-lock.yaml
 /package-lock.json
 
 # production
-/static
-/data
+/dist
+/build
 
 # misc
 .DS_Store
@@ -22,9 +22,10 @@
 .env
 .history
 .version.ts
-/.tmp
-__pycache__
-/shell/preload/env.*
-/shell/preload/notify.*
-/shell/preload/*-notify.json
-/shell/preload/__ql_notify__.*
+
+/config
+/log
+/db
+/manual_log
+/scripts
+/bak

.npmrc

@@ -1 +0,0 @@
-strict-peer-dependencies=false

.prettierignore

@@ -2,23 +2,7 @@
 **/*.svg
 **/*.ejs
 **/*.html
-/.umi
-/.umi-production
-/.umi-test
-/.history
-/.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
+package.json
+.umi
+.umi-production
+.umi-test

.umirc.ts

@@ -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',
-  antd: {},
-  locale: {
-    antd: true,
-    title: true,
-    baseNavigator: true,
+  layout: false,
+  nodeModulesTransform: {
+    type: 'none',
   },
-  outputPath: 'static/dist',
-  fastRefresh: true,
-  favicons: [`https://qn.whyour.cn/favicon.svg`],
-  publicPath: process.env.NODE_ENV === 'production' ? './' : '/',
+  fastRefresh: {},
+  dynamicImport: {
+    loading: '@/components/pageLoading',
+  },
+  favicon: '/images/g5.ico',
   proxy: {
-    [`${baseUrl}api`]: {
-      target: 'http://127.0.0.1:5700/',
+    '/api': {
+      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`],
-  copy: [
-    {
-      from: 'node_modules/monaco-editor/min/vs',
-      to: 'static/dist/monaco-editor/min/vs',
   },
+  externals: {
+    react: 'window.React',
+    'react-dom': 'window.ReactDOM',
+    darkreader: 'window.DarkReader',
+    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',
 });

COMPLETE_SUMMARY.md

@@ -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)
-
-🎉 场景模式功能已完全实现并可投入使用！

FLOWGRAM_IMPLEMENTATION_COMPLETE.md

@@ -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

FLOWGRAM_INTEGRATION_STATUS.md

@@ -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 等替代方案

FLOWGRAM_MIGRATION_GUIDE.md

@@ -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 文档不完整）

IMPLEMENTATION_SUMMARY.md

@@ -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 文档
-✅ **国际化** - 完整的中英文支持
-
-这个功能将青龙面板从简单的定时任务管理工具升级为智能的自动化运维中枢！

INSTALL.md

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

LICENSE

@@ -1,201 +1,22 @@
-                              Apache License
-                        Version 2.0, January 2004
-                    http://www.apache.org/licenses/
+MIT LICENSE
 
-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,
-  and distribution as defined by Sections 1 through 9 of this document.
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-  "Licensor" shall mean the copyright owner or entity authorized by
-  the copyright owner that is granting the License.
-
-  "Legal Entity" shall mean the union of the acting entity and all
-  other entities that control, are controlled by, or are under common
-  control with that entity. For the purposes of this definition,
-  "control" means (i) the power, direct or indirect, to cause the
-  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.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README-en.md

@@ -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.

README.md

@@ -1,101 +1,54 @@
-<div align="center">
-<img width="100" src="https://user-images.githubusercontent.com/22700758/191449379-f9f56204-0e31-4a16-be5a-331f52696a73.png">
+<p align="center">
+  <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]
-
-[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
+[donate-image]: https://img.shields.io/badge/donate-wechat-green?style=flat
+[donate-url]: https://qinglong.whyour.cn/nice.png
 [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)
-
-## 功能
-
-- 支持多种脚本语言（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)
-
-## 名称来源
+<p align="center">
+  <img width="49%" src="/public/images/login.png">
+  <img width="49%" src="/public/images/home.png">
+</p>
 
 青龙，又名苍龙，在中国传统文化中是四象之一、[天之四灵](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)

SCENARIO_MODE.md

@@ -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

SECURITY.md

@@ -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.

back/api/config.ts

@@ -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',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        res.send({
-          code: 200,
-          data: SAMPLE_FILES,
-        });
-      } catch (e) {
-        return next(e);
-      }
-    },
-  );
-
-  route.get(
-    '/files',
+    '/configs/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);
-        await configService.getFile(req.query.path as string, res);
+        let content = '';
+        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);
-        if (name.startsWith('data/scripts/')) {
-          path = join(config.rootPath, name);
-        }
-        await writeFileWithLock(path, content);
+        const path = `${config.configPath}${name}`;
+        fs.writeFileSync(path, content);
         res.send({ code: 200, message: '保存成功' });
       } catch (e) {
-        return next(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) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },

back/api/cron.ts

@@ -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',
-    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',
+    '/crons',
     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 {
+        if (cron_parser.parseExpression(req.body.schedule).hasNext()) {
           const cronService = Container.get(CronService);
           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);
-      }
-    },
-  );
-
-  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) {
+        logger.error('🔥 error: %o', 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(),
-      }),
-    }),
-    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(),
+        id: 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.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),
-        log_path: Joi.string().optional().allow(null),
-        last_running_time: Joi.number().optional().allow(null),
-        last_execution_time: Joi.number().optional().allow(null),
+        pid: Joi.string().optional(),
+        log_path: Joi.string().optional(),
+        last_running_time: Joi.number().optional(),
+        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,
-          pid: req.body.pid ? parseInt(req.body.pid) : undefined,
+          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 cronService = Container.get(CronService);
-        const data = await cronService.logs(req.params.id);
-        return res.send({ code: 200, data });
-      } catch (e) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },

back/api/dependence.ts

@@ -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(
-    '/',
-    celebrate({
-      query: 
-        Joi.object({
-          searchValue: Joi.string().optional().allow(''),
-          type: Joi.string().optional().allow(''),
-          status: Joi.string().optional().allow(''),
-        }),
-    }),
+    '/dependencies',
     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);
-      }
-    },
-  );
-
-  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) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },

back/api/env.ts

@@ -1,28 +1,15 @@
-import { Joi, celebrate } from 'celebrate';
-import { NextFunction, Request, Response, Router } from 'express';
-import fs from 'fs';
-import multer from 'multer';
+import { Router, Request, Response, NextFunction } from 'express';
 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);
-
-  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
+  app.use('/', route);
+  route.get(
+    '/envs',
+    async (req: Request, res: Response, next: NextFunction) => {
       const logger: Logger = Container.get('logger');
       try {
         const envService = Container.get(EnvService);
@@ -32,17 +19,16 @@ export default (app: Router) => {
         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()
-            .required()
-            .pattern(/^[a-zA-Z_][0-9a-zA-Z_]*$/),
+          name: Joi.string().required(),
           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),
-        id: Joi.number().required(),
+        remarks: Joi.string().optional().allow(''),
+        _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);
-      }
-    },
-  );
-
-  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) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },

back/api/health.ts

@@ -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,
-      });
-    }
-  });
-};

back/api/index.ts

@@ -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;
 };

back/api/log.ts

@@ -1,140 +1,75 @@
-import { celebrate, Joi } from 'celebrate';
-import { NextFunction, Request, Response, Router } from 'express';
+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 {
-  getFileContentByName,
-  readDirs,
-  removeAnsi,
-  rmPath,
-} from '../config/util';
-import LogService from '../services/log';
+import { getFileContentByName } from '../config/util';
 const route = Router();
-const blacklist = ['.tmp'];
 
 export default (app: Router) => {
-  app.use('/logs', route);
-
-  route.get('/', async (req: Request, res: Response, next: NextFunction) => {
+  app.use('/', route);
+  route.get(
+    '/logs',
+    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,
+        const fileList = fs.readdirSync(config.logPath, 'utf-8');
+        const dirs = [];
+        for (let i = 0; i < fileList.length; i++) {
+          const stat = fs.lstatSync(config.logPath + fileList[i]);
+          if (stat.isDirectory()) {
+            const fileListTmp = fs.readdirSync(
+              `${config.logPath}/${fileList[i]}`,
+              'utf-8',
+            );
+            dirs.push({
+              name: fileList[i],
+              isDir: true,
+              files: fileListTmp.reverse(),
             });
+          } else {
+            dirs.push({
+              name: fileList[i],
+              isDir: false,
+              files: [],
+            });
+          }
+        }
+        res.send({ code: 200, dirs });
       } catch (e) {
         logger.error('🔥 error: %o', e);
         return next(e);
       }
-  });
-
-  route.get(
-    '/detail',
-    async (req: Request, res: Response, next: NextFunction) => {
-      try {
-        const logService = Container.get(LogService);
-        const finalPath = logService.checkFilePath(
-          (req.query.path as string) || '',
-          (req.query.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: removeAnsi(content) });
-      } catch (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 finalPath = logService.checkFilePath(
-          (req.query.path as string) || '',
-          (req.params.file as string) || '',
+        const { dir, file } = req.params;
+        const content = getFileContentByName(
+          `${config.logPath}/${dir}/${file}`,
         );
-        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(
-    '/',
-    celebrate({
-      body: Joi.object({
-        filename: Joi.string().required(),
-        path: Joi.string().allow(''),
-        type: Joi.string().optional(),
-      }),
-    }),
+  route.get(
+    '/logs/:file',
     async (req: Request, res: Response, next: NextFunction) => {
+      const logger: Logger = Container.get('logger');
       try {
-        let { filename, path } = req.body as {
-          filename: string;
-          path: string;
-        };
-        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);
-          }
-        });
+        const { file } = req.params;
+        const content = getFileContentByName(`${config.logPath}/${file}`);
+        res.send({ code: 200, data: content });
       } catch (e) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },

back/api/open.ts

@@ -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);
       }
     },

back/api/scenario.ts

@@ -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);
-      }
-    },
-  );
-};

back/api/script.ts

@@ -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 ScriptService from '../services/script';
-import multer from 'multer';
-import { writeFileWithLock } from '../shared/utils';
+import path from 'path';
 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(
-    '/',
-    celebrate({
-      query: Joi.object({
-        path: Joi.string().optional().allow(''),
-      }),
-    }),
+    '/scripts/files',
     async (req: Request, res: Response, next: NextFunction) => {
       const logger: Logger = Container.get('logger');
       try {
-        let result: IFile[] = [];
-        const blacklist = [
-          'node_modules',
-          '.git',
-          '.pnpm',
-          'pnpm-lock.yaml',
-          'yarn.lock',
-          'package-lock.json',
-        ];
-        if (req.query.path) {
-          result = await readDir(
-            req.query.path as string,
-            config.scriptPath,
-            blacklist,
-          );
-        } else {
-          result = await readDirs(
-            config.scriptPath,
-            config.scriptPath,
-            blacklist,
-            (a, b) => {
-              if (a.type === b.type) {
-                return a.title.localeCompare(b.title);
-              } else {
-                return a.type === 'directory' ? -1 : 1;
+        const fileList = fs.readdirSync(config.scriptPath, 'utf-8');
+
+        let result = [];
+        for (let i = 0; i < fileList.length; i++) {
+          const fileOrDir = fileList[i];
+          const fPath = path.join(config.scriptPath, fileOrDir);
+          const dirStat = fs.statSync(fPath);
+          if (['node_modules'].includes(fileOrDir)) {
+            continue;
           }
-            },
-          );
+
+          if (dirStat.isDirectory()) {
+            const childFileList = fs.readdirSync(fPath, 'utf-8');
+            let children = [];
+            for (let j = 0; j < childFileList.length; j++) {
+              const childFile = childFileList[j];
+              const sPath = path.join(config.scriptPath, fileOrDir, childFile);
+              const _fileExist = await fileExist(sPath);
+              if (_fileExist && fs.statSync(sPath).isFile()) {
+                const statObj = fs.statSync(sPath);
+                children.push({
+                  title: childFile,
+                  value: childFile,
+                  key: `${fileOrDir}-${childFile}`,
+                  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',
-    celebrate({
-      params: Joi.object({
-        file: Joi.string().required(),
-      }),
-      query: Joi.object({
-        path: Joi.string().optional().allow(''),
-      }),
-    }),
+    '/scripts/:file',
     async (req: Request, res: Response, next: NextFunction) => {
+      const logger: Logger = Container.get('logger');
       try {
-        const scriptService = Container.get(ScriptService);
-        const content = await scriptService.getFile(
-          req.query?.path as string || '',
-          req.params.file,
+        const path = req.query.path ? `${req.query.path}/` : '';
+        const content = getFileContentByName(
+          `${config.scriptPath}${path}${req.params.file}`,
         );
         res.send({ code: 200, data: content });
       } catch (e) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },
   );
 
   route.post(
-    '/',
-    upload.single('file'),
+    '/scripts',
     celebrate({
       body: Joi.object({
         filename: Joi.string().required(),
-        path: Joi.string().optional().allow(''),
-        content: Joi.string().optional().allow(''),
-        originFilename: Joi.string().optional().allow(''),
-        directory: Joi.string().optional().allow(''),
+        path: Joi.string().allow(''),
+        content: Joi.string().allow(''),
+        originFilename: Joi.string().allow(''),
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
+      const logger: Logger = Container.get('logger');
       try {
-        let { filename, path, content, originFilename, directory } =
-          req.body as {
+        let { filename, path, content, originFilename } = req.body as {
           filename: string;
           path: string;
           content: 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,
-            message: '暂无权限',
+            code: 430,
+            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(
-          path,
-          `${originFilename.replace(/\//g, '')}`,
-        );
-        const filePath = join(path, `${filename.replace(/\//g, '')}`);
-        const fileExists = await fileExist(filePath);
-        if (fileExists) {
-          await fs.copyFile(
+        const originFilePath = `${path}${originFilename.replace(/\//g, '')}`;
+        const filePath = `${path}${filename.replace(/\//g, '')}`;
+        if (fs.existsSync(originFilePath)) {
+          if (!fs.existsSync(config.bakPath)) {
+            fs.mkdirSync(config.bakPath);
+          }
+          fs.copyFileSync(
             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(''),
-        content: Joi.string().required().allow(''),
+        path: Joi.string().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 = scriptService.checkFilePath(path, filename);
-        if (!filePath) {
-          return res.send({
-            code: 403,
-            message: '暂无权限',
-          });
-        }
-        await writeFileWithLock(filePath, content);
+        const filePath = `${config.scriptPath}${path}/${filename}`;
+        fs.writeFileSync(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) {
-          path = '';
-        }
-        const scriptService = Container.get(ScriptService);
-        const filePath = scriptService.checkFilePath(path, filename);
-        if (!filePath) {
-          return res.send({
-            code: 403,
-            message: '暂无权限',
-          });
-        }
-        await rmPath(filePath);
+        const filePath = `${config.scriptPath}${filename}`;
+        fs.unlinkSync(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;
-        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 {
+        let { filename } = req.body as {
           filename: string;
-          path: string;
-          newFilename: string;
         };
-        if (!path) {
-          path = '';
-        }
-        const filePath = join(config.scriptPath, path, filename);
-        const newPath = join(config.scriptPath, path, newFilename);
-        await fs.rename(filePath, newPath);
-        res.send({ code: 200 });
+        const filePath = `${config.scriptPath}${filename}`;
+        // const stats = fs.statSync(filePath);
+        // res.set({
+        //   'Content-Type': 'application/octet-stream', //告诉浏览器这是一个二进制文件
+        //   'Content-Disposition': 'attachment; filename=' + filename, //告诉浏览器这是一个需要下载的文件
+        //   'Content-Length': stats.size  //文件大小
+        // });
+        // fs.createReadStream(filePath).pipe(res);
+        return res.download(filePath, filename, (err) => {
+          return next(err);
+        });
       } catch (e) {
+        logger.error('🔥 error: %o', e);
         return next(e);
       }
     },

back/api/subscription.ts

@@ -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);
-      }
-    },
-  );
-};

back/api/system.ts

@@ -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);
-      }
-    },
-  );
-};

back/api/update.ts

@@ -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);
-      }
-    },
-  );
-};

back/api/user.ts

@@ -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 path from 'path';
-import { v4 as uuidV4 } from 'uuid';
-import rateLimit from 'express-rate-limit';
-import config from '../config';
-import { isDemoEnv } from '../config/util';
+import { getFileContentByName } 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,29 +55,29 @@ 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(
+    '/user',
+    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 authInfo = await userService.getUserInfo();
         res.send({
           code: 200,
           data: {
             username: authInfo.username,
-          avatar: authInfo.avatar,
             twoFactorActivated: authInfo.twoFactorActivated,
           },
         });
@@ -103,10 +85,11 @@ export default (app: Router) => {
         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',
-    upload.single('avatar'),
+    '/system/log/remove',
+    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);
       }
     },

back/app.ts

@@ -1,242 +1,34 @@
-import 'reflect-metadata';
-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 'reflect-metadata'; // We need this in order to use @Decorators
+
 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 {
-  id: number;
-  pid: number;
-  serviceType: string;
-  startTime: Date;
+async function startServer() {
+  const app = express();
+
+  await require('./loaders/sentry').default({ expressApp: app });
+
+  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 {
-  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);
-});
+startServer();

back/config/const.ts

@@ -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;

back/config/http.ts

@@ -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,
-};

back/config/index.ts

@@ -1,127 +1,58 @@
 import dotenv from 'dotenv';
 import path from 'path';
-import { createRandomString } from './share';
+import { createRandomString } from './util';
 
-dotenv.config({
-  path: path.join(__dirname, '../../.env'),
-});
+process.env.NODE_ENV = process.env.NODE_ENV || 'development';
 
-interface Config {
-  port: number;
-  grpcPort: number;
-  nodeEnv: string;
-  isDevelopment: boolean;
-  isProduction: boolean;
-  jwt: {
-    secret: string;
-    expiresIn?: string;
-  };
-  cors: {
-    origin: string[];
-    methods: string[];
-  };
-  logs: {
-    level: string;
-  };
-  api: {
-    prefix: string;
-  };
+const lastVersionFile =
+  'https://ghproxy.com/https://raw.githubusercontent.com/whyour/qinglong/master/src/version.ts';
+
+const envFound = dotenv.config();
+const rootPath = process.cwd();
+const envFile = path.join(rootPath, 'config/env.sh');
+const confFile = path.join(rootPath, 'config/config.sh');
+const sampleFile = path.join(rootPath, 'sample/config.sample.sh');
+const crontabFile = path.join(rootPath, 'config/crontab.list');
+const confBakDir = path.join(rootPath, 'config/bak/');
+const authConfigFile = path.join(rootPath, 'config/auth.json');
+const extraFile = path.join(rootPath, 'config/extra.sh');
+const configPath = path.join(rootPath, 'config/');
+const scriptPath = path.join(rootPath, 'scripts/');
+const bakPath = path.join(rootPath, 'bak/');
+const samplePath = path.join(rootPath, 'sample/');
+const logPath = path.join(rootPath, 'log/');
+const authError = '错误的用户名密码，请重试';
+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 = {
-  port: parseInt(process.env.BACK_PORT || '5700', 10),
-  grpcPort: parseInt(process.env.GRPC_PORT || '5500', 10),
-  nodeEnv: process.env.NODE_ENV || 'development',
-  isDevelopment: process.env.NODE_ENV === 'development',
-  isProduction: process.env.NODE_ENV === 'production',
+if (configFound.error) {
+  throw new Error("⚠️  Couldn't find config.sh file  ⚠️");
+}
+
+export default {
+  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/health',
+    '/api/login',
     '/open/auth/token',
     '/api/user/two-factor/login',
     '/api/system',
-    '/api/user/init',
-    '/api/user/notification/init',
-    '/open/user/login',
-    '/open/user/two-factor/login',
-    '/open/system',
-    '/open/user/init',
-    '/open/user/notification/init',
+    '/api/init/user',
+    '/api/init/notification',
   ],
   versionFile,
   lastVersionFile,
-  sqliteFile,
-  sshdPath,
-  systemLogPath,
-  dependenceCachePath,
 };

back/config/serverEnv.ts

@@ -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'),
-  );
-}

back/config/share.ts

@@ -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('');
-}

back/config/subscription.ts

@@ -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;
-}

back/config/util.ts

@@ -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 psTreeFun from 'ps-tree';
-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';
+import got from 'got';
+import iconv from 'iconv-lite';
 
-export * from './share';
-
-export async function getFileContentByName(fileName: string) {
-  const _exsit = await fileExist(fileName);
-  if (_exsit) {
-    return await fs.readFile(fileName, 'utf8');
+export function getFileContentByName(fileName: string) {
+  if (fs.existsSync(fileName)) {
+    return fs.readFileSync(fileName, 'utf8');
   }
   return '';
 }
 
-export function removeAnsi(text: string) {
-  return text.replace(/\x1b\[\d+m/g, '');
-}
-
-export async function getLastModifyFilePath(dir: string) {
+export function getLastModifyFilePath(dir: string) {
   let filePath = '';
 
-  const _exsit = await fileExist(dir);
-  if (_exsit) {
-    const arr = await fs.readdir(dir);
+  if (fs.existsSync(dir)) {
+    const arr = fs.readdirSync(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 (
-    system === 'android' ||
-    system === 'ios' ||
-    system === 'openharmony' ||
-    testUa(/mobile/g)
-  ) {
+  } else if (system === 'android' || system === 'ios' || testUa(/mobile/g)) {
     platform = 'mobile';
   }
 
@@ -97,475 +222,12 @@ export function getPlatform(userAgent: string): 'mobile' | 'desktop' {
 }
 
 export async function fileExist(file: any) {
+  return new Promise((resolve) => {
     try {
-    await fs.access(file);
-    return true;
+      fs.accessSync(file);
+      resolve(true);
     } catch (error) {
-    return false;
+      resolve(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;
-      const jsonValue = JSON.parse(_value);
-      matches[_key] = jsonValue;
-    } catch (error) {
-      matches[_key] = _value;
-    }
-  }
-
-  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';
-}

back/data/auth.ts

@@ -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',
+}

back/data/cron.ts

@@ -1,36 +1,26 @@
-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.status =
-      typeof options.status === 'number' && CrontabStatus[options.status]
+    this._id = options._id;
+    this.created = options.created;
+    this.status = CrontabStatus[options.status]
       ? options.status
       : CrontabStatus.idle;
     this.timestamp = new Date().toString();
@@ -39,52 +29,12 @@ export class Crontab {
     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,
-  'queued' = 0.5,
-  'idle' = 1,
+  'running',
+  'idle',
   '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,
-});

back/data/cronView.ts

@@ -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,
-  },
-);

back/data/dependence.ts

@@ -1,24 +1,20 @@
-import { sequelize } from '.';
-import { DataTypes, Model, ModelDefined } from 'sequelize';
-
 export class Dependence {
   timestamp?: string;
-  id?: number;
-  status: DependenceStatus;
-  type: DependenceTypes;
-  name: string;
+  created?: number;
+  _id?: string;
+  status?: DependenceStatus;
+  type?: DependenceTypes;
+  name?: number;
   log?: string[];
   remark?: string;
 
   constructor(options: Dependence) {
-    this.id = options.id;
-    this.status =
-      typeof options.status === 'number' && DependenceStatus[options.status]
-        ? options.status
-        : DependenceStatus.queued;
+    this._id = options._id;
+    this.created = options.created || new Date().valueOf();
+    this.status = options.status || DependenceStatus.installing;
     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
-  extends Model<Dependence, Dependence>,
-    Dependence {}
-export const DependenceModel = sequelize.define<DependenceInstance>(
-  'Dependence',
-  {
-    name: DataTypes.STRING,
-    type: DataTypes.NUMBER,
-    timestamp: DataTypes.STRING,
-    status: DataTypes.NUMBER,
-    log: DataTypes.JSON,
-    remark: DataTypes.STRING,
-  },
-);
+export enum unInstallDependenceCommandTypes {
+  'npm uninstall -g --force',
+  'pip3 uninstall -y',
+  'apk del -f',
+}

back/data/env.ts

@@ -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;
-  remarks?: string;
-  isPinned?: 1 | 0;
+  name?: number;
+  remarks?: number;
 
   constructor(options: Env) {
     this.value = options.value;
-    this.id = options.id;
-    this.status =
-      typeof options.status === 'number' && EnvStatus[options.status]
-        ? options.status
-        : EnvStatus.normal;
+    this._id = options._id;
+    this.created = options.created || new Date().valueOf();
+    this.status = options.status || EnvStatus.normal;
     this.timestamp = new Date().toString();
     this.position = options.position;
     this.name = options.name;
-    this.remarks = options.remarks || '';
-    this.isPinned = options.isPinned || 0;
+    this.remarks = options.remarks;
   }
 }
 
@@ -31,18 +25,4 @@ export enum EnvStatus {
   'disabled',
 }
 
-export const maxPosition = 9000000000000000;
-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,
-});
+export const initEnvPosition = 9999999999;

back/data/index.ts

@@ -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 };

back/data/notify.ts

@@ -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,
-    PushMeNotification,
-    WebhookNotification,
-    ChronocatNotification,
-    LarkNotification,
-    NtfyNotification,
-    WxPusherBotNotification {}
+    EmailNotification {}

back/data/open.ts

@@ -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 const AppModel = sequelize.define<AppInstance>('App', {
-  name: { type: DataTypes.STRING, unique: 'name' },
-  scopes: DataTypes.JSON,
-  client_id: DataTypes.STRING,
-  client_secret: DataTypes.STRING,
-  tokens: DataTypes.JSON,
-});
+export enum CrontabStatus {
+  'running',
+  'idle',
+  'disabled',
+  'queued',
+}

back/data/scenario.ts

@@ -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,
-  },
-});

back/data/scenarioLog.ts

@@ -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,
-    },
-  },
-);

back/data/sock.ts

@@ -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'
-  | 'manuallyRunScript'
-  | 'runSubscriptionEnd'
-  | 'reloadSystem'
-  | 'updateNodeMirror'
-  | 'updateLinuxMirror';
+  | 'updateSystemVersion';

back/data/subscription.ts

@@ -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 },
-  },
-);

back/data/system.ts

@@ -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,
-  },
-});

back/index.d.ts

@@ -0,0 +1,5 @@
+declare namespace Express {
+  interface Request {
+    platform: 'desktop' | 'mobile';
+  }
+}

back/interface/schedule.ts

@@ -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 }>;
-};

back/loaders/app.ts

@@ -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 }) => {
-  depInjectorLoader();
-  Logger.info('✌️ Dependency loaded');
+export default async ({ expressApp }: { expressApp: Application }) => {
+  await dependencyInjectorLoader({
+    models: [],
+  });
+  Logger.info('✌️ Dependency Injector loaded');
 
-  await linkDeps();
-  Logger.info('✌️ Link deps loaded');
-
-  initFile();
-  Logger.info('✌️ Init file loaded');
+  await expressLoader({ app: expressApp });
+  Logger.info('✌️ Express loaded');
 
   await initData();
-  Logger.info('✌️ Init data loaded');
-
-  initTask();
-  Logger.info('✌️ Init task loaded');
-
-  expressLoader({ app });
-  Logger.info('✌️ Express loaded');
+  Logger.info('✌️ init data loaded');
 };

back/loaders/bootAfter.ts

@@ -1,8 +0,0 @@
-import Container from 'typedi';
-import CronService from '../services/cron';
-
-export default async () => {
-  const cronService = Container.get(CronService);
-
-  await cronService.bootTask();
-};

back/loaders/db.ts

@@ -1,76 +1,63 @@
+import DataStore from 'nedb';
+import config from '../config';
 import Logger from './logger';
-import { EnvModel } from '../data/env';
-import { CrontabModel } from '../data/cron';
-import { DependenceModel } from '../data/dependence';
-import { AppModel } from '../data/open';
-import { SystemModel } from '../data/system';
-import { SubscriptionModel } from '../data/subscription';
-import { CrontabViewModel } from '../data/cronView';
-import { ScenarioModel } from '../data/scenario';
-import { ScenarioLogModel } from '../data/scenarioLog';
-import { sequelize } from '../data';
+import fs from 'fs';
+import { fileExist } from '../config/util';
 
+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 DependenceModel.sync();
-    await AppModel.sync();
-    await SystemModel.sync();
-    await EnvModel.sync();
-    await SubscriptionModel.sync();
-    await CrontabViewModel.sync();
-    await ScenarioModel.sync();
-    await ScenarioLogModel.sync();
+    await truncateDb();
 
-    // 初始化新增字段
-    try {
-      await sequelize.query(
-        'alter table CrontabViews add column filterRelation VARCHAR(255)',
-      );
-    } catch (error) {}
-    try {
-      await sequelize.query(
-        'alter table Subscriptions add column proxy VARCHAR(255)',
-      );
-    } catch (error) {}
-    try {
-      await sequelize.query('alter table CrontabViews add column type NUMBER');
-    } catch (error) {}
-    try {
-      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) {}
+    db.cronDb = new DataStore({ filename: config.cronDbFile, autoload: true });
+    db.dependenceDb = new DataStore({
+      filename: config.dependenceDbFile,
+      autoload: true,
+    });
+    db.envDb = new DataStore({ filename: config.envDbFile, autoload: true });
+    db.appDb = new DataStore({ filename: config.appDbFile, autoload: true });
+    db.authDb = new DataStore({ filename: config.authDbFile, autoload: true });
+
+    // compaction data file
+    db.cronDb.persistence.compactDatafile();
+    db.envDb.persistence.compactDatafile();
+    db.dependenceDb.persistence.compactDatafile();
+    db.appDb.persistence.compactDatafile();
+    db.authDb.persistence.compactDatafile();
 
     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;

back/loaders/dependencyInjector.ts

@@ -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);

back/loaders/deps.ts

@@ -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));
-};

back/loaders/express.ts

@@ -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 { getPlatform, getToken } from '../config/util';
+import jwt from 'express-jwt';
+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 { serveEnv } from '../config/serverEnv';
-import { IKeyvStore, shareStore } from '../shared/store';
-import path from 'path';
+import UserService from '../services/user';
+import handler from 'serve-handler';
+import * as Sentry from '@sentry/node';
 
 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({
-      secret: config.jwt.secret,
+    jwt({
+      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) => {
-    if (!['/open/', '/api/'].some((x) => req.path.startsWith(x))) {
-      return next();
-    }
-
+  app.use(async (req, res, next) => {
     const headerToken = getToken(req);
     if (req.path.startsWith('/open/')) {
-      const apps = await shareStore.getApps();
-      const doc = apps?.filter((x) =>
-        x.tokens?.find((y) => y.value === headerToken),
-      )?.[0];
+      const openService = Container.get(OpenService);
+      const doc = await openService.findTokenByValue(headerToken);
       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 &&
-      config.apiWhiteList.includes(originPath)
+      req.path &&
+      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();
-    if (authInfo && headerToken) {
-      const { token = '', tokens = {} } = authInfo;
+    const data = fs.readFileSync(config.authConfigFile, 'utf8');
+    if (data) {
+      const { token = '', tokens = {} } = JSON.parse(data);
       if (headerToken === token || tokens[req.platform] === headerToken) {
         return next();
       }
     }
 
-    const errorCode = headerToken ? 'invalid_token' : 'credentials_required';
-    const errorMessage = headerToken
-      ? 'jwt malformed'
-      : 'No authorization token was found';
-    const err = new UnauthorizedError(errorCode, { message: errorMessage });
+    const err: any = new Error('UnauthorizedError');
+    err.status = 401;
     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 =
-      (await shareStore.getAuthInfo()) || ({} as IKeyvStore['authInfo']);
+    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'
+      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) => {
-    const indexPath = path.join(frontendPath, 'index.html');
-    res.sendFile(indexPath, (err) => {
-      if (err) {
+  app.use((req, res, next) => {
     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,

back/loaders/initData.ts

@@ -1,148 +1,47 @@
 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 { Op } from 'sequelize';
-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';
+import _ from 'lodash';
+import { dbs } from '../loaders/db';
 
 export default async () => {
   const cronService = Container.get(CronService);
   const envService = Container.get(EnvService);
   const dependenceService = Container.get(DependenceService);
-  const systemService = Container.get(SystemService);
-  const userService = Container.get(UserService);
-  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,
-      });
-    }
-  });
+  const cronDb = dbs.cronDb;
+  const dependenceDb = dbs.dependenceDb;
 
   // 初始化更新所有任务状态为空闲
-  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({
-    where: {
-      isDisabled: { [Op.ne]: 1 },
-      command: {
-        [Op.or]: [{ [Op.like]: `%ql repo%` }, { [Op.like]: `%ql raw%` }],
-      },
-    },
-  }).then((docs) => {
+  // 初始化时安装所有处于安装中，安装成功，安装失败的依赖
+  dependenceDb.find({ status: { $in: [0, 1, 2] } }).exec((err, docs) => {
+    const groups = _.groupBy(docs, 'type');
+    for (const key in groups) {
+      if (Object.prototype.hasOwnProperty.call(groups, key)) {
+        const group = groups[key];
+        const depIds = group.map((x) => x._id);
+        for (const dep of depIds) {
+          dependenceService.reInstall([dep]);
+        }
+      }
+    }
+  });
+
+  // 初始化时执行一次所有的ql repo 任务
+  cronDb
+    .find({
+      command: /ql (repo|raw)/,
+      isDisabled: { $ne: 1 },
+    })
+    .exec((err, docs) => {
       for (let i = 0; i < docs.length; i++) {
         const doc = docs[i];
         if (doc) {
@@ -151,73 +50,42 @@ export default async () => {
       }
     });
 
-  // 更新2.11.3以前的脚本路径
-  CrontabModel.findAll({
-    where: {
-      command: {
-        [Op.or]: [
-          { [Op.like]: `%\/${config.rootPath}\/scripts\/%` },
-          { [Op.like]: `%\/${config.rootPath}\/config\/%` },
-          { [Op.like]: `%\/${config.rootPath}\/log\/%` },
-          { [Op.like]: `%\/${config.rootPath}\/db\/%` },
-        ],
+  // 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();
           },
-    },
-  }).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 } },
-          );
-        }
-      }
-    }
     });
 
   // 初始化保存一次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;
+}

back/loaders/initFile.ts

@@ -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');
-};

back/loaders/initTask.ts

@@ -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);
-  }
-};

back/loaders/logger.ts

@@ -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> = {
-  info: 'ℹ️', // info图标
-  warn: '⚠️', // 警告图标
-  error: '❌', // 错误图标
-  debug: '🐛', // debug调试图标
-};
-
-const baseFormat = [
+const transports = [];
+if (process.env.NODE_ENV !== 'development') {
+  transports.push(new winston.transports.Console());
+} else {
+  transports.push(
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.cli(),
         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],
-  exceptionHandlers: [consoleTransport, fileTransport],
-  rejectionHandlers: [consoleTransport, fileTransport],
-});
-
-LoggerInstance.on('error', (error) => {
-  console.error('Logger error:', error);
+  format: winston.format.combine(
+    winston.format.timestamp({
+      format: 'YYYY-MM-DD HH:mm:ss',
+    }),
+    winston.format.errors({ stack: true }),
+    winston.format.splat(),
+    winston.format.json(),
+  ),
+  transports,
 });
 
 export default LoggerInstance;

back/loaders/sentry.ts

@@ -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');
+};

back/loaders/server.ts

@@ -6,11 +6,11 @@ export default async ({ server }: { server: Server }) => {
   await Sock({ server });
   Logger.info('✌️ Sock loaded');
 
-  process.on('uncaughtException', (error) => {
-    Logger.error('Uncaught exception:', error);
+  process.on('SIGINT', () => {
+    Logger.info('✌️ Server need close');
+    server.close(() => {
+      Logger.info('✌️ Server closed');
+      process.exit(0);
     });
-
-  process.on('unhandledRejection', (reason, promise) => {
-    Logger.error('Unhandled rejection:', reason, promise);
   });
 };

back/loaders/sock.ts

@@ -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) {
-      const { token = '', tokens = {} } = authInfo;
+    if (data) {
+      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' }));
       }
     }
 

back/middlewares/monitoring.ts

@@ -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),
-  };
-};

back/protos/api.proto

@@ -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) {}
-}

back/protos/cron.proto

@@ -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 {}

back/protos/cron.ts

@@ -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;
-}

back/protos/health.proto

@@ -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);
-}

back/protos/health.ts

@@ -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;
-}

back/schedule.ts

@@ -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);
+  });

back/schedule/addCron.ts

@@ -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 };

back/schedule/api.ts

@@ -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);
-  }
-};

back/schedule/client.ts

@@ -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();

back/schedule/data.ts

@@ -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();

back/schedule/delCron.ts

@@ -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 };

back/schedule/health.ts

@@ -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 };

back/services/config.ts

@@ -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 });
-  }
-}

back/services/cronView.ts

@@ -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;
-  }
-}

back/services/dependence.ts

@@ -1,352 +1,256 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import config from '../config';
+import DataStore from 'nedb';
 import {
   Dependence,
+  InstallDependenceCommandTypes,
   DependenceStatus,
   DependenceTypes,
-  DependenceModel,
-  versionDependenceCommandTypes,
+  unInstallDependenceCommandTypes,
 } 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 {
-  fileExist,
-  getPid,
-  killTask,
-  promiseExecSuccess,
-  getInstallCommand,
-  getUninstallCommand,
-  getGetCommand,
-} from '../config/util';
-import dayjs from 'dayjs';
-import taskLimit from '../shared/pLimit';
+import { dbs } from '../loaders/db';
 
 @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 docs;
+    return new Promise((resolve) => {
+      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 doc = await this.getDb({ id });
+    const { _id, ...other } = payload;
+    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 await this.getDb({ id: payload.id });
+    return new Promise((resolve) => {
+      this.dependenceDb.update(
+        { _id: payload._id },
+        payload,
+        { returnUpdatedDocs: true },
+        (err, num, doc) => {
+          if (err) {
+            this.logger.error(err);
+          } else {
+            resolve(doc as Dependence);
           }
-
-  public async remove(ids: number[], force = false): Promise<Dependence[]> {
-    const docs = await DependenceModel.findAll({ where: { id: ids } });
-    for (const doc of docs) {
-      taskLimit.removeQueuedDependency(doc);
-    }
-    const unInstalledDeps = docs.filter(
-      (x) => x.status !== DependenceStatus.installed,
+        },
       );
-    const installedDeps = docs.filter(
-      (x) => x.status === DependenceStatus.installed,
-    );
-    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[]) {
-    await DependenceModel.destroy({ where: { id: ids } });
+  public async remove(ids: string[]) {
+    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,
-      status,
-    }: {
-      searchValue: string;
-      type: keyof typeof DependenceTypes;
-      status: string;
-    },
-    sort: any = [],
+    { searchValue, type }: { searchValue: string; type: string },
+    sort: any = { position: -1 },
     query: any = {},
   ): Promise<Dependence[]> {
-    let condition = query;
-    if (DependenceTypes[type]) {
-      condition.type = DependenceTypes[type];
-    }
-    if (status) {
-      condition.status = status.split(',').map(Number);
-    }
+    let condition = { ...query, type: DependenceTypes[type as any] };
     if (searchValue) {
-      const encodeText = encodeURI(searchValue);
-      condition.name = {
-        [Op.or]: [
-          { [Op.like]: `%${searchValue}%` },
-          { [Op.like]: `%${encodeText}%` },
+      const reg = new RegExp(searchValue);
+      condition = {
+        ...condition,
+        $or: [
+          {
+            name: reg,
+          },
         ],
       };
     }
-    try {
-      return await this.find(condition, sort);
-    } catch (error) {
-      throw error;
-    }
+    const newDocs = await this.find(condition, sort);
+    return newDocs;
   }
 
-  public installDependenceOneByOne(
-    docs: Dependence[],
+  public async reInstall(ids: string[]): Promise<Dependence[]> {
+    return new Promise((resolve: any) => {
+      this.dependenceDb.update(
+        { _id: { $in: ids } },
+        { $set: { status: DependenceStatus.installing, log: [] } },
+        { multi: true, returnUpdatedDocs: true },
+        async (err, num, docs: Dependence[]) => {
+          this.installOrUninstallDependencies(docs);
+          resolve(docs);
+        },
+      );
+    });
+  }
+
+  private async find(query: any, sort: any): Promise<Dependence[]> {
+    return new Promise((resolve) => {
+      this.dependenceDb
+        .find(query)
+        .sort({ ...sort })
+        .exec((err, docs) => {
+          resolve(docs);
+        });
+    });
+  }
+
+  public async get(_id: string): Promise<Dependence> {
+    return new Promise((resolve) => {
+      this.dependenceDb.find({ _id }).exec((err, docs) => {
+        resolve(docs[0]);
+      });
+    });
+  }
+
+  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,
-    force: boolean = false,
-  ): Promise<void> {
-    docs.forEach((dep) => {
-      this.installOrUninstallDependency(dep, isInstall, force);
-    });
-
-    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(
-    dependency: Dependence,
-    isInstall: boolean = true,
-    force: boolean = false,
   ) {
-    return taskLimit.runDependeny(dependency, () => {
-      return new Promise(async (resolve) => {
-        if (taskLimit.firstDependencyId !== dependency.id) {
-          return resolve(null);
+    if (dependencies.length === 0) {
+      return;
     }
-
-        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 depNames = dependencies.map((x) => x.name).join(' ');
+    const depRunCommand = (
+      isInstall
+        ? InstallDependenceCommandTypes
+        : unInstallDependenceCommandTypes
+    )[dependencies[0].type as any];
     const actionText = isInstall ? '安装' : '删除';
-        const startTime = dayjs();
-
-        const message = `开始${actionText}依赖 ${depName}，开始时间 ${startTime.format(
-          'YYYY-MM-DD HH:mm:ss',
-        )}\n\n`;
+    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: socketMessageType,
-          message,
+      type: 'installDependence',
+      message: `开始${actionText}依赖 ${depNames}，开始时间 ${new Date(
+        startTime,
+      ).toLocaleString()}`,
       references: depIds,
     });
-        this.updateLog(depIds, message);
-
-        // 判断是否已经安装过依赖
-        if (isInstall && !force) {
-          const getCommand = getGetCommand(dependency.type, depName);
-          const depVersionStr = versionDependenceCommandTypes[dependency.type];
-          let depVersion = '';
-          if (depName.includes(depVersionStr)) {
-            const symbolRegx = new RegExp(
-              `(.*)${depVersionStr}([0-9\\.\\-\\+a-zA-Z]*)`,
+    this.updateLog(
+      depIds,
+      `开始${actionText}依赖 ${depNames}，开始时间 ${new Date(
+        startTime,
+      ).toLocaleString()}\n`,
     );
-            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')} 秒`;
+    cp.stdout.on('data', (data) => {
       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,
+        type: 'installDependence',
         message: data.toString(),
         references: depIds,
       });
       this.updateLog(depIds, data.toString());
     });
 
-        cp.stderr.on('data', async (data) => {
+    cp.stderr.on('data', (data) => {
       this.sockService.sendMessage({
-            type: socketMessageType,
+        type: 'installDependence',
         message: data.toString(),
         references: depIds,
       });
       this.updateLog(depIds, data.toString());
     });
 
-        cp.on('error', async (err) => {
+    cp.on('error', (err) => {
       this.sockService.sendMessage({
-            type: socketMessageType,
+        type: 'installDependence',
         message: JSON.stringify(err),
         references: depIds,
       });
       this.updateLog(depIds, JSON.stringify(err));
     });
 
-        cp.on('exit', async (code) => {
-          const endTime = dayjs();
+    cp.on('close', (code) => {
+      const endTime = Date.now();
       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,
+        type: 'installDependence',
+        message: `依赖${actionText}${resultText}，结束时间 ${new Date(
+          endTime,
+        ).toLocaleString()}，耗时 ${(endTime - startTime) / 1000} 秒`,
         references: depIds,
       });
-          this.updateLog(depIds, message);
+      this.updateLog(
+        depIds,
+        `依赖${actionText}${resultText}，结束时间 ${new Date(
+          endTime,
+        ).toLocaleString()}，耗时 ${(endTime - startTime) / 1000} 秒`,
+      );
 
-          let status: number;
+      let status = null;
       if (isSucceed) {
         status = isInstall
           ? DependenceStatus.installed
@@ -356,26 +260,21 @@ export default class DependenceService {
           ? 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 } },
+      this.dependenceDb.update(
+        { _id: { $in: depIds } },
+        {
+          $set: { status },
+          $unset: { pid: true },
+        },
+        { multi: true },
       );
-          }
 
-          // 如果删除依赖成功或者强制删除
-          if ((isSucceed || force) && !isInstall) {
+      // 如果删除依赖成功，3秒后删除数据库记录
+      if (isSucceed && !isInstall) {
+        setTimeout(() => {
           this.removeDb(depIds);
+        }, 5000);
       }
-
-          resolve(null);
-        });
-      });
     });
   }
 }

back/services/env.ts

@@ -1,73 +1,84 @@
-import groupBy from 'lodash/groupBy';
-import { FindOptions, Op } from 'sequelize';
-import { Inject, Service } from 'typedi';
+import { Service, Inject } from 'typedi';
 import winston from 'winston';
+import { getFileContentByName } from '../config/util';
 import config from '../config';
-import {
-  Env,
-  EnvModel,
-  EnvStatus,
-  initPosition,
-  maxPosition,
-  minPosition,
-  stepPosition,
-} from '../data/env';
-import { writeFileWithLock } from '../shared/utils';
+import * as fs from 'fs';
+import DataStore from 'nedb';
+import { Env, EnvStatus, initEnvPosition } from '../data/env';
+import _ from 'lodash';
+import { dbs } from '../loaders/db';
 
 @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;
-    if (
-      envs &&
-      envs.length > 0 &&
-      typeof envs[envs.length - 1].position === 'number'
-    ) {
-      position = envs[envs.length - 1].position!;
+    let position = initEnvPosition;
+    if (envs && envs.length > 0 && envs[envs.length - 1].position) {
+      position = envs[envs.length - 1].position as number;
     }
     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[] = [];
-    for (const env of payloads) {
-      const doc = await EnvModel.create(env, { returning: true });
-      result.push(doc);
+    return new Promise((resolve) => {
+      this.envDb.insert(payloads, (err, docs) => {
+        if (err) {
+          this.logger.error(err);
+        } else {
+          resolve(docs);
         }
-    return result;
+      });
+    });
   }
 
   public async update(payload: Env): Promise<Env> {
-    const doc = await this.getDb({ id: payload.id });
-    const tab = new Env({ ...doc, ...payload });
+    const { _id, ...other } = 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 await this.getDb({ id: payload.id });
+    return new Promise((resolve) => {
+      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[]) {
-    await EnvModel.destroy({ where: { id: ids } });
+  public async remove(ids: string[]) {
+    return new Promise((resolve: any) => {
+      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[toIndex].position! - stepPosition;
+        ? envs[0].position * 2
+        : 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,
-      position: this.getPrecisionPosition(targetPosition),
+      _id,
+      position: targetPosition,
     });
-
-    await this.checkPosition(targetPosition, envs[toIndex].position!);
     return newDoc;
   }
 
-  private async checkPosition(position: number, edge: number = 0) {
-    const precisionPosition = parseFloat(position.toPrecision(16));
-    if (
-      precisionPosition < minPosition ||
-      precisionPosition > maxPosition ||
-      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[]> {
+  public async envs(
+    searchText: string = '',
+    sort: any = { position: -1 },
+    query: any = {},
+  ): Promise<Env[]> {
     let condition = { ...query };
     if (searchText) {
-      const encodeText = encodeURI(searchText);
-      const reg = {
-        [Op.or]: [
-          { [Op.like]: `%${searchText}%` },
-          { [Op.like]: `%${encodeText}%` },
-        ],
-      };
-
+      const reg = new RegExp(searchText);
       condition = {
-        ...condition,
-        [Op.or]: [
-          {
-            name: reg,
-          },
+        $or: [
           {
             value: reg,
           },
+          {
+            name: reg,
+          },
           {
             remarks: reg,
           },
         ],
       };
     }
-    try {
-      const result = await this.find(condition, [
-        ['isPinned', 'DESC'],
-        ['position', 'DESC'],
-        ['createdAt', 'ASC'],
-      ]);
-      return result;
-    } catch (error) {
-      throw error;
-    }
+    const newDocs = await this.find(condition, sort);
+    return newDocs;
   }
 
-  private async find(query: any, sort: any = []): Promise<Env[]> {
-    const docs = await EnvModel.findAll({
-      where: { ...query },
-      order: [...sort],
+  private async find(query: any, sort: any): Promise<Env[]> {
+    return new Promise((resolve) => {
+      this.envDb
+        .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> {
-    const doc: any = await EnvModel.findOne({ where: { ...query } });
-    if (!doc) {
-      throw new Error(`Env ${JSON.stringify(query)} not found`);
-    }
-    return doc.get({ plain: true });
+  public async get(_id: string): Promise<Env> {
+    return new Promise((resolve) => {
+      this.envDb.find({ _id }).exec((err, docs) => {
+        resolve(docs[0]);
+      });
+    });
   }
 
-  public async disabled(ids: number[]) {
-    await EnvModel.update(
-      { status: EnvStatus.disabled },
-      { where: { id: ids } },
+  public async getBySort(sort: any): Promise<Env> {
+    return new Promise((resolve) => {
+      this.envDb
+        .find({})
+        .sort({ ...sort })
+        .limit(1)
+        .exec((err, docs) => {
+          resolve(docs[0]);
+        });
+    });
+  }
+
+  public async disabled(ids: string[]) {
+    return new Promise((resolve: any) => {
+      this.envDb.update(
+        { _id: { $in: ids } },
+        { $set: { status: EnvStatus.disabled } },
+        { multi: true },
+        async (err) => {
+          await this.set_envs();
+          resolve();
+        },
       );
+    });
+  }
+
+  public async enabled(ids: string[]) {
+    return new Promise((resolve: any) => {
+      this.envDb.update(
+        { _id: { $in: ids } },
+        { $set: { status: EnvStatus.normal } },
+        { multi: true },
+        async (err, num) => {
           await this.set_envs();
+          resolve();
+        },
+      );
+    });
   }
 
-  public async enabled(ids: number[]) {
-    await EnvModel.update({ status: EnvStatus.normal }, { where: { id: ids } });
+  public async updateNames({ ids, name }: { ids: string[]; name: string }) {
+    return new Promise((resolve: any) => {
+      this.envDb.update(
+        { _id: { $in: ids } },
+        { $set: { name } },
+        { multi: true },
+        async (err, num) => {
           await this.set_envs();
-  }
-
-  public async updateNames({ ids, name }: { ids: number[]; name: string }) {
-    await EnvModel.update({ name }, { where: { id: ids } });
-    await this.set_envs();
-  }
-
-  public async pin(ids: number[]) {
-    await EnvModel.update({ isPinned: 1 }, { where: { id: ids } });
-  }
-
-  public async unPin(ids: number[]) {
-    await EnvModel.update({ isPinned: 0 }, { where: { id: ids } });
+          resolve();
+        },
+      );
+    });
   }
 
   public async set_envs() {
-    const envs = await this.envs('', {
-      name: { [Op.not]: null },
-      status: EnvStatus.normal,
-    });
-    const groups = groupBy(envs, 'name');
+    const envs = await this.envs(
+      '',
+      { position: -1 },
+      { name: { $exists: true } },
+    );
+    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)) {
-          let value = group
-            .map((x) => x.value)
+        if (/^[a-zA-Z_][0-9a-zA-Z_]+$/.test(key)) {
+          env_string += `export ${key}="${_(group)
+            .filter((x) => x.status !== EnvStatus.disabled)
+            .map('value')
             .join('&')
-            .replace(/'/g, "'\\''")
-            .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`;
+            .replace(/ /g, '')}"\n`;
         }
       }
     }
-    await writeFileWithLock(config.envFile, env_string);
-    await writeFileWithLock(config.jsEnvFile, js_env_string);
-    await writeFileWithLock(config.pyEnvFile, py_env_string);
+    fs.writeFileSync(config.envFile, env_string);
   }
 }

back/services/graphExecutor.ts

@@ -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,
-    };
-  }
-}

back/services/grpc.ts

@@ -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;
-  }
-}

back/services/health.ts

@@ -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;
-  }
-}

back/services/http.ts

@@ -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;
-  }
-}

back/services/log.ts

@@ -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 : '';
-  }
-}

back/services/metrics.ts

@@ -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();