更新版本 v2.19.1

* 增加 wxPusher 推送方式

* 补全 wxPusher 推送方式代码

* fix js 方法多进行了一次 JSON 格式化

.env.example

@@ -1,13 +1,12 @@
-PUBLIC_PORT=5400
+GRPC_PORT=5500
-CRON_PORT=5500
 BACK_PORT=5600
 PORT=5700
 
-LOG_LEVEL='debug'
+LOG_LEVEL='info'
 
-SECRET='whyour'
+JWT_SECRET=
+JWT_EXPIRES_IN=
 
-QINIU_AK=''
+QINIU_AK=
-QINIU_SK=''
+QINIU_SK=
-QINIU_SCOPE=''
+QINIU_SCOPE=
-TEMP=''

.github/workflows/build_docker_image.yml

@@ -2,54 +2,55 @@ name: Build And Push Docker Image
 
 on:
   push:
+    paths-ignore:
+      - "*.md"
     branches:
-      - 'master'
+      - "master"
-      - 'develop'
+      - "develop"
     tags:
-      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+      - "v*"
   schedule:
-    # 参考 https://jasonet.co/posts/scheduled-actions/
+    - cron: "00 20 * * *"
-    - cron: '00 14 * * *' # GMT 15:00 => 北京时间 23:00
   workflow_dispatch:
 
 jobs:
-  to_gitlab:
+  code_gitlab:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: pixta-dev/repository-mirroring-action@v1
+      - uses: wearerequired/git-mirror-action@v1
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PK }}
         with:
-          target_repo_url:
+          source-repo: https://github.com/whyour/qinglong.git
-            git@gitlab.com:whyour/qinglong.git
+          destination-repo: git@gitlab.com:whyour/qinglong.git
-          ssh_private_key:
+
-            ${{ secrets.GITLAB_SSH_PK }}
+  code_gitee:
-  
-  to_gitee:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           fetch-depth: 0
-      - uses: pixta-dev/repository-mirroring-action@v1
+      - uses: wearerequired/git-mirror-action@v1
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PK }}
         with:
-          target_repo_url:
+          source-repo: https://github.com/whyour/qinglong.git
-            git@gitee.com:whyour/qinglong.git
+          destination-repo: git@gitee.com:whyour/qinglong.git
-          ssh_private_key:
-            ${{ secrets.GITLAB_SSH_PK }}
 
   build-static:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v2
+      - uses: pnpm/action-setup@v3
         with:
-          version: '8.3.1'
+          version: "8.3.1"
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
-          cache: 'pnpm'
+          cache: "pnpm"
 
       - name: build front and back
         run: |
@@ -73,48 +74,66 @@ jobs:
           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: wearerequired/git-mirror-action@v1
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PK }}
+        with:
+          source-repo: https://github.com/whyour/qinglong-static.git
+          destination-repo: git@gitlab.com:whyour/qinglong-static.git
 
-          mkdir -p ~/.ssh
+  static_gitee:
-          echo "${PRIVATE_KEY}" > ~/.ssh/id_rsa
+    needs: build-static
-          chmod 600 ~/.ssh/id_rsa
+    runs-on: ubuntu-latest
-
+    steps:
-          export GIT_SSH_COMMAND="ssh -v -i ~/.ssh/id_rsa -o StrictHostKeyChecking=no -l git"
+      - uses: actions/checkout@v4
-          git remote add gitee "${REPO_GITEE}"
+        with:
-          git remote add gitlab "${REPO_GITLAB}"
+          fetch-depth: 0
-          git push --force --quiet gitee ${GITHUB_BRANCH}:${GITHUB_BRANCH}
+      - uses: wearerequired/git-mirror-action@v1
-          git push --force --quiet gitlab ${GITHUB_BRANCH}:${GITHUB_BRANCH}
+        env:
+          SSH_PRIVATE_KEY: ${{ secrets.GITLAB_SSH_PK }}
+        with:
+          source-repo: https://github.com/whyour/qinglong-static.git
+          destination-repo: git@gitee.com:whyour/qinglong-static.git
 
   build:
     needs: build-static
 
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     permissions:
       packages: write
       contents: read
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
-      - uses: pnpm/action-setup@v2
+      - uses: pnpm/action-setup@v3
         with:
-          version: '8.3.1'
+          version: "8.3.1"
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
-          cache: 'pnpm'
+          cache: "pnpm"
 
       - name: Setup timezone
-        uses: zcong1993/setup-timezone@master
+        uses: szenius/set-timezone@v2.0
         with:
-          timezone: Asia/Shanghai
+          timezoneLinux: Asia/Shanghai
 
       - name: Login to DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Login to GHCR
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -122,7 +141,7 @@ jobs:
 
       - name: Extract metadata (tags, labels) for Docker
         id: meta
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v5
         with:
           images: |
             ${{ github.repository }}
@@ -142,21 +161,22 @@ jobs:
             type=semver,pattern={{major}}
 
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
-      
+
       - name: Build and push
         id: docker_build
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v6
         with:
           build-args: |
             MAINTAINER=${{ github.repository_owner }}
             QL_BRANCH=${{ github.ref_name }}
             SOURCE_COMMIT=${{ github.sha }}
           network: host
-          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/s390x,linux/386
+          # linux/s390x npm 暂不可用
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/ppc64le,linux/386
           context: .
           file: ./docker/Dockerfile
           push: true
@@ -164,6 +184,72 @@ jobs:
           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 }}
+        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 }}

.gitignore

@@ -22,11 +22,9 @@
 .env
 .history
 .version.ts
-
+/.tmp
-/config
+__pycache__
-/log
+/shell/preload/env.*
-/db
+/shell/preload/notify.*
-/manual_log
+/shell/preload/*-notify.json
-/scripts
+/shell/preload/__ql_notify__.*
-/bak
-/.tmp

.npmrc

@@ -1,2 +1 @@
-sentrycli_cdnurl=https://npmmirror.com/mirrors/sentry-cli/
 strict-peer-dependencies=false

.prettierignore

@@ -2,31 +2,23 @@
 **/*.svg
 **/*.ejs
 **/*.html
-package.json
+/.umi
-.umi
+/.umi-production
-.umi-production
+/.umi-test
-.umi-test
+/.history
-.history
+/.tmp
-.tmp
+/node_modules
-node_modules
 npm-debug.log*
 yarn-error.log
 yarn.lock
 package-lock.json
-static
+/static
-data
+/data
 DS_Store
-src/.umi
+/src/.umi
-src/.umi-production
+/src/.umi-production
-src/.umi-test
+/src/.umi-test
 .env.local
 .env
-history
 version.ts
-config
+/.tmp
-log
-db
-manual_log
-scripts
-bak
-.tmp

.umirc.ts

@@ -16,11 +16,6 @@ export default defineConfig({
   favicons: [`https://qn.whyour.cn/favicon.svg`],
   publicPath: process.env.NODE_ENV === 'production' ? './' : '/',
   proxy: {
-    [`${baseUrl}api/public`]: {
-      target: 'http://127.0.0.1:5400/',
-      changeOrigin: true,
-      pathRewrite: { [`^${baseUrl}api/public`]: '/api' },
-    },
     [`${baseUrl}api`]: {
       target: 'http://127.0.0.1:5600/',
       changeOrigin: true,
@@ -38,13 +33,12 @@ export default defineConfig({
       }),
     );
   }) as any,
-  externals: {
+  headScripts: [`./api/env.js`],
-    react: 'window.React',
+  copy: [
-    'react-dom': 'window.ReactDOM',
+    {
-  },
+      from: 'node_modules/monaco-editor/min/vs',
-  headScripts: [
+      to: 'static/dist/monaco-editor/min/vs',
-    `./api/env.js`,
+    },
-    'https://gw.alipayobjects.com/os/lib/react/18.2.0/umd/react.production.min.js',
-    'https://gw.alipayobjects.com/os/lib/react-dom/18.2.0/umd/react-dom.production.min.js',
   ],
+  npmClient: 'pnpm',
 });

README-en.md

@@ -18,9 +18,9 @@ Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 [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.dlww.cc:4433/) / [Issues](https://github.com/whyour/qinglong/issues) / [Telegram Channel](https://t.me/jiao_long) / [Buy Me a Coffee](https://www.buymeacoffee.com/qinglong)
+[Demo](http://demo.ninesix.cc: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.dlww.cc: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)
+[演示](http://demo.ninesix.cc: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)
@@ -36,6 +36,7 @@ Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 - 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.
@@ -47,7 +48,7 @@ docker pull whyour/qinglong:debian
 
 ### npm
 
-The npm version supports `debian/ubuntu/centos/alpine` systems and requires `node/python3` to be installed.
+The npm version supports `debian/ubuntu/alpine` systems and requires `node/npm/python3/pip3/pnpm` to be installed.
 
 ```bash
 npm i @whyour/qinglong
@@ -55,126 +56,29 @@ npm i @whyour/qinglong
 
 ## Deployment
 
-### Docker (Recommended)
+[View Documentation](https://qinglong.online/guide/getting-started/installation-guide)
 
-```bash
+## Built-in API
-# curl -sSL get.docker.com | sh
-docker run -dit \
-  -v $PWD/ql/data:/ql/data \
-  -p 5700:5700 \
-  --name qinglong \
-  --hostname qinglong \
-  --restart unless-stopped \
-  whyour/qinglong:latest
-```
 
-### Docker-compose (Recommended)
+[View Documentation](https://qinglong.online/guide/user-guide/built-in-api)
 
-```bash
+## Built-in commands
-# curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
-mkdir qinglong
-wget https://raw.githubusercontent.com/whyour/qinglong/master/docker/docker-compose.yml
 
-# start
+[View Documentation](https://qinglong.online/guide/user-guide/basic-explanation)
-docker-compose up -d
-# stop
-docker-compose down
-```
-
-### Podman (Recommended)
-
-```bash
-# https://podman.io/getting-started/installation
-podman run -dit \
-  --network bridge \
-  -v $PWD/ql/data:/ql/data \
-  -p 5700:5700 \
-  --name qinglong \
-  --hostname qinglong \
-  docker.io/whyour/qinglong:latest
-```
-
-### Local
-
-It is recommended to use a pure system installation to avoid losing the original system data, you need to install node/npm/python3/pip3 yourself
-
-```bash
-npm install -g @whyour/qinglong
-qinglong
-# Add the environment variables QL_DIR and QL_DATA_DIR when prompted
-export QL_DIR=""
-export QL_DATA_DIR=""
-# Run again
-qinglong
-```
-
-## Use
-
-1. built-in commands
-
-```bash
-# Update and restart Green Dragon
-ql update                                                    
-# Run custom scripts extra.sh
-ql extra                                                     
-# Adding a single script file
-ql raw <file_url>                                             
-# Add a specific script for a single repository
-ql repo <repo_url> <whitelist> <blacklist> <dependence> <branch>   
-# Delete old logs
-ql rmlog <days>                                              
-# Start bot
-ql bot                                                       
-# Detecting the Green Dragon environment and repairing it
-ql check                                                     
-# Reset the number of login errors
-ql resetlet                                                  
-# Disable two-step login
-ql resettfa                                                  
-
-# Execute in sequence, if a random delay is set, it will be randomly delayed by a certain number of seconds
-task <file_path>                                             
-# Execute in sequence, regardless of whether a random delay is set, all run immediately, 
-# and the foreground will output the day, while recorded in the log file
-task <file_path> now                                         
-# Concurrent execution, regardless of whether a random delay is set, are run immediately, 
-# the foreground does not generate the day, directly recorded in the log file, and can be specified account execution
-task <file_path> conc <env_name> <account_number>(Optional) 
-# Specify the account to execute and run immediately regardless of whether a random delay is set 
-task <file_path> desi <env_name> <account_number>       
-# Set task timeout   
-task -m <max_time> <file_path>
-# Print task log in real time, no need to carry this parameter when creating timed tasks
-task -l <file_path>  
-```
-
-2. parameter description
-
-* file_url: Script address
-* repo_url: Repository address
-* whitelist: The whitelist when pulling the repository, i.e., the string contained in the path of the script to be pulled
-* blacklist: Blacklisting when pulling repositories, i.e. strings that are not included in the path of the script to be pulled
-* dependence: Pulling the dependencies needed for the repository will be copied directly from the repository to the repository directory under scripts, regardless of the blacklist
-* branch: Pull the branch of the repository
-* days: Number of days of logs to be kept
-* file_path: File path for task execution
-* env_name: The name of the environment variable that needs to be concurrent or specified at the time of task execution
-* account_number: Specify the account number of an environment variable to be executed when the task is executed
-* max_time: Timeout, suffix "s" for seconds (default), "m" for minutes, "h" for hours, "d" for days
 
 ## Development
 
 ```bash
-$ git clone git@github.com:whyour/qinglong.git
+git clone https://github.com/whyour/qinglong.git
-$ cd qinglong
+cd qinglong
-$ cp .env.example .env
+cp .env.example .env
 # Recommended use pnpm https://pnpm.io/zh/installation
-$ npm install -g pnpm@8.3.1
+npm install -g pnpm@8.3.1
-$ pnpm install
+pnpm install
-$ pnpm start
+pnpm start
 ```
 
-Open your browser and visit http://127.0.0.1:5700
+Open your browser and visit <http://127.0.0.1:5700>
 
 ## Links
 
@@ -192,4 +96,4 @@ The Green Dragon, also known as the Canglong, is one of the four elephants and o
 
 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.
+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

@@ -20,9 +20,9 @@ Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 [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.dlww.cc:4433/) / [Issues](https://github.com/whyour/qinglong/issues) / [Telegram Channel](https://t.me/jiao_long) / [Buy Me a Coffee](https://www.buymeacoffee.com/qinglong)
+[Demo](http://demo.ninesix.cc: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.dlww.cc: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)
+[演示](http://demo.ninesix.cc: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)
@@ -38,6 +38,7 @@ Timed task management platform supporting Python3, JavaScript, Shell, Typescript
 - 支持手机端操作
 
 ## 版本
+
 ### docker
 
 `latest` 镜像是基于 `alpine` 构建，`debian` 镜像是基于 `debian-slim` 构建。如果需要使用 `alpine` 不支持的依赖，建议使用 `debian` 镜像
@@ -49,7 +50,7 @@ docker pull whyour/qinglong:debian
 
 ### npm
 
-npm 版本支持 `debian/ubuntu/centos/alpine` 系统，需要自行安装 `node/python3`
+npm 版本支持 `debian/ubuntu/alpine` 系统，需要自行安装 `node/npm/python3/pip3/pnpm`
 
 ```bash
 npm i @whyour/qinglong
@@ -57,129 +58,29 @@ npm i @whyour/qinglong
 
 ## 部署
 
-### docker (推荐)
+[查看文档](https://qinglong.online/guide/getting-started/installation-guide)
 
-```bash
+## 内置 API
-# curl -sSL get.docker.com | sh
-docker run -dit \
-  -v $PWD/ql/data:/ql/data \
-  -p 5700:5700 \
-  # 部署路径非必须，以斜杠开头和结尾，比如 /test/
-  -e QlBaseUrl="/" \
-  --name qinglong \
-  --hostname qinglong \
-  --restart unless-stopped \
-  whyour/qinglong:latest
-```
 
-### docker-compose (推荐)
+[查看文档](https://qinglong.online/guide/user-guide/built-in-api)
 
-```bash
+## 内置命令
-#  curl -L https://github.com/docker/compose/releases/download/1.16.1/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
-mkdir qinglong
-wget https://raw.githubusercontent.com/whyour/qinglong/master/docker/docker-compose.yml
 
-# 启动
+[查看文档](https://qinglong.online/guide/user-guide/basic-explanation)
-docker-compose up -d
-# 停止
-docker-compose down
-```
-
-### podman (推荐)
-
-```bash
-# https://podman.io/getting-started/installation
-podman run -dit \
-  --network bridge \
-  -v $PWD/ql/data:/ql/data \
-  -p 5700:5700 \
-  # 部署路径非必须，以斜杠开头和结尾，比如 /test/
-  -e QlBaseUrl="/" \
-  --name qinglong \
-  --hostname qinglong \
-  docker.io/whyour/qinglong:latest
-```
-
-### 本机
-
-建议使用纯净系统安装，避免系统原有数据丢失，需要自己安装 node/npm/python3/pip3
-
-```bash
-npm install -g @whyour/qinglong
-qinglong
-# 根据提示增加环境变量 QL_DIR 和 QL_DATA_DIR
-export QL_DIR=""
-export QL_DATA_DIR=""
-# 再次执行
-qinglong
-```
-
-## 使用
-
-1. 内置命令
-
-```bash
-# 更新并重启青龙
-ql update                                                    
-# 运行自定义脚本extra.sh
-ql extra                                                     
-# 添加单个脚本文件
-ql raw <file_url>                                             
-# 添加单个仓库的指定脚本
-ql repo <repo_url> <whitelist> <blacklist> <dependence> <branch> <extensions>
-# 删除旧日志
-ql rmlog <days>                                              
-# 启动tg-bot
-ql bot                                                       
-# 检测青龙环境并修复
-ql check                                                     
-# 重置登录错误次数
-ql resetlet                                                  
-# 禁用两步登录
-ql resettfa                                                  
-
-# 依次执行，如果设置了随机延迟，将随机延迟一定秒数
-task <file_path>                                             
-# 依次执行，无论是否设置了随机延迟，均立即运行，前台会输出日，同时记录在日志文件中
-task <file_path> now                                         
-# 并发执行，无论是否设置了随机延迟，均立即运行，前台不产生日，直接记录在日志文件中，且可指定账号执行
-task <file_path> conc <env_name> <account_number>(可选的) 
-# 指定账号执行，无论是否设置了随机延迟，均立即运行 
-task <file_path> desi <env_name> <account_number>      
-# 设置任务超时时间   
-task -m <max_time> <file_path>
-# 实时打印任务日志，创建定时任务时，不用携带此参数
-task -l <file_path>
-```
-
-2. 参数说明
-
-* file_url: 脚本地址
-* repo_url: 仓库地址
-* whitelist: 拉取仓库时的白名单，即就是需要拉取的脚本的路径包含的字符串，多个竖线分割
-* blacklist: 拉取仓库时的黑名单，即就是需要拉取的脚本的路径不包含的字符串，多个竖线分割
-* dependence: 拉取仓库需要的依赖文件，会直接从仓库拷贝到scripts下的仓库目录，不受黑名单影响，多个竖线分割
-* extensions: 拉取仓库的文件后缀，多个竖线分割
-* branch: 拉取仓库的分支
-* days: 需要保留的日志的天数
-* file_path: 任务执行时的文件路径
-* env_name: 任务执行时需要并发或者指定时的环境变量名称
-* account_number: 任务执行时指定某个环境变量需要执行的账号序号
-* max_time: 超时时间，后缀"s"代表秒(默认值), "m"代表分, "h"代表小时, "d"代表天
 
 ## 开发
 
 ```bash
-$ git clone git@github.com:whyour/qinglong.git
+git clone https://github.com/whyour/qinglong.git
-$ cd qinglong
+cd qinglong
-$ cp .env.example .env
+cp .env.example .env
 # 推荐使用 pnpm https://pnpm.io/zh/installation
-$ npm install -g pnpm@8.3.1
+npm install -g pnpm@8.3.1
-$ pnpm install
+pnpm install
-$ pnpm start
+pnpm start
 ```
 
-打开你的浏览器，访问 http://127.0.0.1:5700
+打开你的浏览器，访问 <http://127.0.0.1:5700>
 
 ## 链接
 

SECURITY.md

@@ -0,0 +1,5 @@
+## 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,22 +1,38 @@
-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';
+import * as fs from 'fs/promises';
 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);
 
+  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',
     async (req: Request, res: Response, next: NextFunction) => {
       const logger: Logger = Container.get('logger');
       try {
-        const fileList = fs.readdirSync(config.configPath, 'utf-8');
+        const fileList = await fs.readdir(config.configPath, 'utf-8');
         res.send({
           code: 200,
           data: fileList
@@ -32,24 +48,11 @@ export default (app: Router) => {
   );
 
   route.get(
-    '/:file',
+    '/detail',
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
-        let content = '';
+        const configService = Container.get(ConfigService);
-        if (config.blackFileList.includes(req.params.file)) {
+        await configService.getFile(req.query.path as string, res);
-          res.send({ code: 403, message: '文件无法访问' });
-        }
-        if (req.params.file.includes('sample')) {
-          content = getFileContentByName(
-            join(config.samplePath, req.params.file),
-          );
-        } else {
-          content = getFileContentByName(
-            join(config.configPath, req.params.file),
-          );
-        }
-        res.send({ code: 200, data: content });
       } catch (e) {
         return next(e);
       }
@@ -71,12 +74,27 @@ export default (app: Router) => {
         if (config.blackFileList.includes(name)) {
           res.send({ code: 403, message: '文件无法访问' });
         }
-        const path = join(config.configPath, name);
+        let path = join(config.configPath, name);
-        fs.writeFileSync(path, content);
+        if (name.startsWith('data/scripts/')) {
+          path = join(config.rootPath, name);
+        }
+        await writeFileWithLock(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) {
+        return next(e);
+      }
+    },
+  );
 };

back/api/cron.ts

@@ -4,7 +4,8 @@ import { Logger } from 'winston';
 import CronService from '../services/cron';
 import CronViewService from '../services/cronView';
 import { celebrate, Joi } from 'celebrate';
-import cron_parser from 'cron-parser';
+import { commonCronSchema } from '../validation/schedule';
+
 const route = Router();
 
 export default (app: Router) => {
@@ -170,24 +171,14 @@ export default (app: Router) => {
   route.post(
     '/',
     celebrate({
-      body: Joi.object({
+      body: Joi.object(commonCronSchema),
-        command: Joi.string().required(),
-        schedule: Joi.string().required(),
-        name: Joi.string().optional(),
-        labels: Joi.array().optional(),
-        sub_id: Joi.number().optional().allow(null),
-      }),
     }),
     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 cronService = Container.get(CronService);
+        const data = await cronService.create(req.body);
-          const data = await cronService.create(req.body);
+        return res.send({ code: 200, data });
-          return res.send({ code: 200, data });
-        } else {
-          return res.send({ code: 400, message: 'param schedule error' });
-        }
       } catch (e) {
         return next(e);
       }
@@ -328,27 +319,16 @@ export default (app: Router) => {
     '/',
     celebrate({
       body: Joi.object({
-        labels: Joi.array().optional().allow(null),
+        ...commonCronSchema,
-        command: Joi.string().required(),
-        schedule: Joi.string().required(),
-        name: Joi.string().optional().allow(null),
-        sub_id: Joi.number().optional().allow(null),
         id: Joi.number().required(),
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
       const logger: Logger = Container.get('logger');
       try {
-        if (
+        const cronService = Container.get(CronService);
-          !req.body.schedule ||
+        const data = await cronService.update(req.body);
-          cron_parser.parseExpression(req.body.schedule).hasNext()
+        return res.send({ code: 200, data });
-        ) {
-          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) {
         return next(e);
       }
@@ -412,7 +392,7 @@ export default (app: Router) => {
       const logger: Logger = Container.get('logger');
       try {
         const cronService = Container.get(CronService);
-        const data = await cronService.import_crontab();
+        const data = await cronService.importCrontab();
         return res.send({ code: 200, data });
       } catch (e) {
         return next(e);
@@ -452,13 +432,12 @@ export default (app: Router) => {
       }),
     }),
     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: parseInt(req.body.status),
+          status: req.body.status ? parseInt(req.body.status) : undefined,
-          pid: parseInt(req.body.pid) || '',
+          pid: req.body.pid ? parseInt(req.body.pid) : undefined,
         });
         return res.send({ code: 200, data });
       } catch (e) {

back/api/dependence.ts

@@ -32,7 +32,6 @@ export default (app: Router) => {
       ),
     }),
     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);
@@ -54,7 +53,6 @@ export default (app: Router) => {
       }),
     }),
     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);
@@ -71,7 +69,6 @@ export default (app: Router) => {
       body: Joi.array().items(Joi.number().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);
@@ -88,7 +85,6 @@ export default (app: Router) => {
       body: Joi.array().items(Joi.number().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);
@@ -107,7 +103,6 @@ export default (app: Router) => {
       }),
     }),
     async (req: Request<{ id: number }>, 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 });
@@ -124,7 +119,6 @@ export default (app: Router) => {
       body: Joi.array().items(Joi.number().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);
@@ -134,4 +128,20 @@ export default (app: Router) => {
       }
     },
   );
+
+  route.put(
+    '/cancel',
+    celebrate({
+      body: Joi.array().items(Joi.number().required()),
+    }),
+    async (req: Request, res: Response, next: NextFunction) => {
+      try {
+        const dependenceService = Container.get(DependenceService);
+        await dependenceService.cancel(req.body);
+        return res.send({ code: 200 });
+      } catch (e) {
+        return next(e);
+      }
+    },
+  );
 };

back/api/env.ts

@@ -51,6 +51,9 @@ 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) {
@@ -217,7 +220,7 @@ export default (app: Router) => {
         } else {
           return res.send({
             code: 400,
-            message: '文件缺少name或者value字段，参考导出文件格式',
+            message: '每条数据 name 或者 value 字段不能为空，参考导出文件格式',
           });
         }
       } catch (e) {

back/api/health.ts

@@ -0,0 +1,27 @@
+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

@@ -9,6 +9,8 @@ import open from './open';
 import dependence from './dependence';
 import system from './system';
 import subscription from './subscription';
+import update from './update';
+import health from './health';
 
 export default () => {
   const app = Router();
@@ -22,6 +24,8 @@ export default () => {
   dependence(app);
   system(app);
   subscription(app);
+  update(app);
+  health(app);
 
   return app;
 };

back/api/log.ts

@@ -1,11 +1,15 @@
-import { Router, Request, Response, NextFunction } from 'express';
+import { celebrate, Joi } from 'celebrate';
+import { NextFunction, Request, Response, Router } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
-import * as fs from 'fs';
 import config from '../config';
-import { emptyDir, getFileContentByName, readDirs } from '../config/util';
+import {
-import { join } from 'path';
+  getFileContentByName,
-import { celebrate, Joi } from 'celebrate';
+  readDirs,
+  removeAnsi,
+  rmPath,
+} from '../config/util';
+import LogService from '../services/log';
 const route = Router();
 const blacklist = ['.tmp'];
 
@@ -15,7 +19,7 @@ export default (app: Router) => {
   route.get('/', async (req: Request, res: Response, next: NextFunction) => {
     const logger: Logger = Container.get('logger');
     try {
-      const result = readDirs(config.logPath, config.logPath, blacklist);
+      const result = await readDirs(config.logPath, config.logPath, blacklist);
       res.send({
         code: 200,
         data: result,
@@ -26,20 +30,45 @@ export default (app: Router) => {
     }
   });
 
+  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',
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
-        if (blacklist.includes(req.path)) {
+        const logService = Container.get(LogService);
-          return res.send({ code: 403, message: '暂无权限' });
+        const finalPath = logService.checkFilePath(
-        }
+          (req.query.path as string) || '',
-        const filePath = join(
+          (req.params.file as string) || '',
-          config.logPath,
-          (req.query.path || '') as string,
-          req.params.file,
         );
-        const content = getFileContentByName(filePath);
+        if (!finalPath || blacklist.includes(req.query.path as string)) {
+          return res.send({
+            code: 403,
+            message: '暂无权限',
+          });
+        }
+        const content = await getFileContentByName(finalPath);
         res.send({ code: 200, data: content });
       } catch (e) {
         return next(e);
@@ -58,21 +87,56 @@ export default (app: Router) => {
     }),
     async (req: Request, res: Response, next: NextFunction) => {
       try {
-        let { filename, path, type } = req.body as {
+        let { filename, path } = req.body as {
           filename: string;
           path: string;
-          type: string;
         };
-        const filePath = join(config.logPath, path, filename);
+        const logService = Container.get(LogService);
-        if (type === 'directory') {
+        const finalPath = logService.checkFilePath(path, filename);
-          emptyDir(filePath);
+        if (!finalPath || blacklist.includes(path)) {
-        } else {
+          return res.send({
-          fs.unlinkSync(filePath);
+            code: 403,
+            message: '暂无权限',
+          });
         }
+        await rmPath(finalPath);
         res.send({ code: 200 });
       } catch (e) {
         return next(e);
       }
     },
   );
+
+  route.post(
+    '/download',
+    celebrate({
+      body: Joi.object({
+        filename: Joi.string().required(),
+        path: Joi.string().allow(''),
+      }),
+    }),
+    async (req: Request, res: Response, next: NextFunction) => {
+      try {
+        let { filename, path } = req.body as {
+          filename: string;
+          path: string;
+        };
+        const logService = Container.get(LogService);
+        const filePath = logService.checkFilePath(path, filename);
+        if (!filePath) {
+          return res.send({
+            code: 403,
+            message: '暂无权限',
+          });
+        }
+        return res.download(filePath, filename, (err) => {
+          if (err) {
+            return next(err);
+          }
+        });
+      } catch (e) {
+        return next(e);
+      }
+    },
+  );
 };

back/api/script.ts

@@ -1,20 +1,14 @@
-import {
+import { fileExist, readDirs, readDir, rmPath, IFile } from '../config/util';
-  fileExist,
-  getFileContentByName,
-  readDirs,
-  getLastModifyFilePath,
-  readDir,
-  emptyDir,
-} 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';
+import * as fs from 'fs/promises';
 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';
 const route = Router();
 
 const storage = multer.diskStorage({
@@ -33,16 +27,34 @@ export default (app: Router) => {
   route.get('/', async (req: Request, res: Response, next: NextFunction) => {
     const logger: Logger = Container.get('logger');
     try {
-      let result = [];
+      let result: IFile[] = [];
-      const blacklist = ['node_modules', '.git'];
+      const blacklist = [
+        'node_modules',
+        '.git',
+        '.pnpm',
+        'pnpm-lock.yaml',
+        'yarn.lock',
+        'package-lock.json',
+      ];
       if (req.query.path) {
-        const targetPath = path.join(
+        result = await readDir(
-          config.scriptPath,
           req.query.path as string,
+          config.scriptPath,
+          blacklist,
         );
-        result = readDir(targetPath, config.scriptPath, blacklist);
       } else {
-        result = readDirs(config.scriptPath, config.scriptPath, blacklist);
+        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;
+            }
+          },
+        );
       }
       res.send({
         code: 200,
@@ -54,17 +66,31 @@ export default (app: Router) => {
     }
   });
 
+  route.get(
+    '/detail',
+    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',
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
-        const filePath = join(
+        const scriptService = Container.get(ScriptService);
-          config.scriptPath,
+        const content = await scriptService.getFile(
           req.query.path as string,
           req.params.file,
         );
-        const content = getFileContentByName(filePath);
         res.send({ code: 200, data: content });
       } catch (e) {
         return next(e);
@@ -76,7 +102,6 @@ export default (app: Router) => {
     '/',
     upload.single('file'),
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
         let { filename, path, content, originFilename, directory } =
           req.body as {
@@ -98,18 +123,18 @@ export default (app: Router) => {
         }
         if (config.writePathList.every((x) => !path.startsWith(x))) {
           return res.send({
-            code: 430,
+            code: 403,
-            message: '文件路径禁止访问',
+            message: '暂无权限',
           });
         }
 
         if (req.file) {
-          fs.renameSync(req.file.path, join(path, req.file.filename));
+          await fs.rename(req.file.path, join(path, filename));
           return res.send({ code: 200 });
         }
 
         if (directory) {
-          fs.mkdirSync(join(path, directory), { recursive: true });
+          await fs.mkdir(join(path, directory), { recursive: true });
           return res.send({ code: 200 });
         }
 
@@ -121,16 +146,17 @@ export default (app: Router) => {
           `${originFilename.replace(/\//g, '')}`,
         );
         const filePath = join(path, `${filename.replace(/\//g, '')}`);
-        if (fs.existsSync(originFilePath)) {
+        const fileExists = await fileExist(filePath);
-          fs.copyFileSync(
+        if (fileExists) {
+          await fs.copyFile(
             originFilePath,
             join(config.bakPath, originFilename.replace(/\//g, '')),
           );
           if (filename !== originFilename) {
-            fs.unlinkSync(originFilePath);
+            await rmPath(originFilePath);
           }
         }
-        fs.writeFileSync(filePath, content);
+        await writeFileWithLock(filePath, content);
         return res.send({ code: 200 });
       } catch (e) {
         return next(e);
@@ -148,15 +174,21 @@ export default (app: Router) => {
       }),
     }),
     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 filePath = join(config.scriptPath, path, filename);
+        const scriptService = Container.get(ScriptService);
-        fs.writeFileSync(filePath, content);
+        const filePath = scriptService.checkFilePath(path, filename);
+        if (!filePath) {
+          return res.send({
+            code: 403,
+            message: '暂无权限',
+          });
+        }
+        await writeFileWithLock(filePath, content);
         return res.send({ code: 200 });
       } catch (e) {
         return next(e);
@@ -174,19 +206,20 @@ export default (app: Router) => {
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
-        let { filename, path, type } = req.body as {
+        let { filename, path } = req.body as {
           filename: string;
           path: string;
-          type: string;
         };
-        const filePath = join(config.scriptPath, path, filename);
+        const scriptService = Container.get(ScriptService);
-        if (type === 'directory') {
+        const filePath = scriptService.checkFilePath(path, filename);
-          emptyDir(filePath);
+        if (!filePath) {
-        } else {
+          return res.send({
-          fs.unlinkSync(filePath);
+            code: 403,
+            message: '暂无权限',
+          });
         }
+        await rmPath(filePath);
         res.send({ code: 200 });
       } catch (e) {
         return next(e);
@@ -199,24 +232,30 @@ export default (app: Router) => {
     celebrate({
       body: Joi.object({
         filename: Joi.string().required(),
+        path: Joi.string().optional().allow(''),
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
-        let { filename } = req.body as {
+        let { filename, path } = req.body as {
           filename: string;
+          path: string;
         };
-        const filePath = join(config.scriptPath, filename);
+        if (!path) {
-        // const stats = fs.statSync(filePath);
+          path = '';
-        // res.set({
+        }
-        //   'Content-Type': 'application/octet-stream', //告诉浏览器这是一个二进制文件
+        const scriptService = Container.get(ScriptService);
-        //   'Content-Disposition': 'attachment; filename=' + filename, //告诉浏览器这是一个需要下载的文件
+        const filePath = scriptService.checkFilePath(path, filename);
-        //   'Content-Length': stats.size  //文件大小
+        if (!filePath) {
-        // });
+          return res.send({
-        // fs.createReadStream(filePath).pipe(res);
+            code: 403,
+            message: '暂无权限',
+          });
+        }
         return res.download(filePath, filename, (err) => {
-          return next(err);
+          if (err) {
+            return next(err);
+          }
         });
       } catch (e) {
         return next(e);
@@ -239,7 +278,7 @@ export default (app: Router) => {
         let { filename, content, path } = req.body;
         const { name, ext } = parse(filename);
         const filePath = join(config.scriptPath, path, `${name}.swap${ext}`);
-        fs.writeFileSync(filePath, content || '', { encoding: 'utf8' });
+        await writeFileWithLock(filePath, content || '');
 
         const scriptService = Container.get(ScriptService);
         const result = await scriptService.runScript(filePath);
@@ -260,7 +299,6 @@ export default (app: Router) => {
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
-      const logger: Logger = Container.get('logger');
       try {
         let { filename, path, pid } = req.body;
         const { name, ext } = parse(filename);
@@ -269,7 +307,9 @@ export default (app: Router) => {
 
         const scriptService = Container.get(ScriptService);
         const result = await scriptService.stopScript(filePath, pid);
-        emptyDir(logPath);
+        setTimeout(() => {
+          rmPath(logPath);
+        }, 3000);
         res.send(result);
       } catch (e) {
         return next(e);
@@ -296,7 +336,7 @@ export default (app: Router) => {
         };
         const filePath = join(config.scriptPath, path, filename);
         const newPath = join(config.scriptPath, path, newFilename);
-        fs.renameSync(filePath, newPath);
+        await fs.rename(filePath, newPath);
         res.send({ code: 200 });
       } catch (e) {
         return next(e);

back/api/subscription.ts

@@ -15,6 +15,7 @@ export default (app: Router) => {
       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) {
@@ -212,8 +213,8 @@ export default (app: Router) => {
       body: Joi.array().items(Joi.number().required()),
       query: Joi.object({
         force: Joi.boolean().optional(),
-        t: Joi.number()
+        t: Joi.number(),
-      })
+      }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
       const logger: Logger = Container.get('logger');

back/api/system.ts

@@ -1,12 +1,11 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { Container } from 'typedi';
 import { Logger } from 'winston';
-import * as fs from 'fs';
+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 { EnvModel } from '../data/env';
 import {
   getUniqPath,
   handleLogPath,
@@ -34,7 +33,7 @@ export default (app: Router) => {
     const logger: Logger = Container.get('logger');
     try {
       const userService = Container.get(UserService);
-      const authInfo = await userService.getUserInfo();
+      const authInfo = await userService.getAuthInfo();
       const { version, changeLog, changeLogLink, publishTime } =
         await parseVersion(config.versionFile);
 
@@ -78,18 +77,16 @@ export default (app: Router) => {
   );
 
   route.put(
-    '/config',
+    '/config/log-remove-frequency',
     celebrate({
       body: Joi.object({
-        logRemoveFrequency: Joi.number().optional().allow(null),
+        logRemoveFrequency: Joi.number().allow(null),
-        cronConcurrency: Joi.number().optional().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.updateSystemConfig(req.body);
+        const result = await systemService.updateLogRemoveFrequency(req.body);
         res.send(result);
       } catch (e) {
         return next(e);
@@ -97,6 +94,96 @@ export default (app: Router) => {
     },
   );
 
+  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) => {
@@ -129,7 +216,7 @@ export default (app: Router) => {
     '/reload',
     celebrate({
       body: Joi.object({
-        type: Joi.string().required(),
+        type: Joi.string().optional().allow('').allow(null),
       }),
     }),
     async (req: Request, res: Response, next: NextFunction) => {
@@ -174,7 +261,7 @@ export default (app: Router) => {
     async (req: Request, res: Response, next: NextFunction) => {
       try {
         const systemService = Container.get(SystemService);
-        const command = req.body.command
+        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);
@@ -193,12 +280,12 @@ export default (app: Router) => {
             onError: async (message: string) => {
               res.write(`\n${message}`);
               const absolutePath = await handleLogPath(logPath);
-              fs.appendFileSync(absolutePath, `\n${message}`);
+              await fs.appendFile(absolutePath, `\n${message}`);
             },
             onLog: async (message: string) => {
               res.write(`\n${message}`);
               const absolutePath = await handleLogPath(logPath);
-              fs.appendFileSync(absolutePath, `\n${message}`);
+              await fs.appendFile(absolutePath, `\n${message}`);
             },
           },
         );
@@ -255,14 +342,78 @@ export default (app: Router) => {
 
   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);
+        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);
+      }
+    },
+  );
 };

back/api/update.ts

@@ -0,0 +1,51 @@
+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

@@ -8,6 +8,7 @@ import path from 'path';
 import { v4 as uuidV4 } from 'uuid';
 import rateLimit from 'express-rate-limit';
 import config from '../config';
+import { isDemoEnv } from '../config/util';
 const route = Router();
 
 const storage = multer.diskStorage({
@@ -72,8 +73,10 @@ 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: '更新成功' });
@@ -87,7 +90,7 @@ export default (app: Router) => {
     const logger: Logger = Container.get('logger');
     try {
       const userService = Container.get(UserService);
-      const authInfo = await userService.getUserInfo();
+      const authInfo = await userService.getAuthInfo();
       res.send({
         code: 200,
         data: {

back/app.ts

@@ -1,33 +1,96 @@
-import 'reflect-metadata'; // We need this in order to use @Decorators
+import 'reflect-metadata';
-import config from './config';
+import compression from 'compression';
+import cors from 'cors';
 import express from 'express';
+import helmet from 'helmet';
+import { Container } from 'typedi';
+import config from './config';
 import Logger from './loaders/logger';
-import path from 'path';
+import { monitoringMiddleware } from './middlewares/monitoring';
+import { type GrpcServerService } from './services/grpc';
+import { type HttpServerService } from './services/http';
 
-async function startServer() {
+class Application {
-  const app = express();
+  private app: express.Application;
+  private httpServerService?: HttpServerService;
+  private grpcServerService?: GrpcServerService;
+  private isShuttingDown = false;
 
-  await require('./loaders/db').default();
+  constructor() {
+    this.app = express();
+  }
 
-  await require('./loaders/initFile').default();
+  async start() {
+    try {
+      await this.initializeDatabase();
+      await this.initServer();
+      this.setupMiddlewares();
+      await this.initializeServices();
+      this.setupGracefulShutdown();
 
-  await require('./loaders/sentry').default({ expressApp: app });
-
-  await require('./loaders/app').default({ expressApp: app });
-
-  const server = app
-    .listen(config.port, () => {
-      Logger.debug(`✌️ 后端服务启动成功！`);
-      console.debug(`✌️ 后端服务启动成功！`);
       process.send?.('ready');
-    })
+    } catch (error) {
-    .on('error', (err) => {
+      Logger.error('Failed to start application:', error);
-      Logger.error(err);
-      console.error(err);
       process.exit(1);
-    });
+    }
+  }
 
-  await require('./loaders/server').default({ server });
+  async initServer() {
+    const { HttpServerService } = await import('./services/http');
+    const { GrpcServerService } = await import('./services/grpc');
+    this.httpServerService = Container.get(HttpServerService);
+    this.grpcServerService = Container.get(GrpcServerService);
+  }
+
+  private async initializeDatabase() {
+    await require('./loaders/db').default();
+  }
+
+  private setupMiddlewares() {
+    this.app.use(helmet());
+    this.app.use(cors(config.cors));
+    this.app.use(compression());
+    this.app.use(monitoringMiddleware);
+  }
+
+  private async initializeServices() {
+    await this.grpcServerService?.initialize();
+
+    await require('./loaders/app').default({ app: this.app });
+
+    const server = await this.httpServerService?.initialize(
+      this.app,
+      config.port,
+    );
+
+    await require('./loaders/server').default({ server });
+  }
+
+  private setupGracefulShutdown() {
+    const shutdown = async () => {
+      if (this.isShuttingDown) return;
+      this.isShuttingDown = true;
+
+      Logger.info('Shutting down services...');
+      try {
+        await Promise.all([
+          this.grpcServerService?.shutdown(),
+          this.httpServerService?.shutdown(),
+        ]);
+        process.exit(0);
+      } catch (error) {
+        Logger.error('Error during shutdown:', error);
+        process.exit(1);
+      }
+    };
+
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
 }
 
-startServer();
+const app = new Application();
+app.start().catch((error) => {
+  Logger.error('Application failed to start:', error);
+  process.exit(1);
+});

back/config/const.ts

@@ -5,3 +5,23 @@ 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;

back/config/http.ts

@@ -0,0 +1,68 @@
+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

@@ -2,12 +2,60 @@ import dotenv from 'dotenv';
 import path from 'path';
 import { createRandomString } from './share';
 
+dotenv.config({
+  path: path.join(__dirname, '../../.env'),
+});
+
+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 config: Config = {
+  port: parseInt(process.env.BACK_PORT || '5600', 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',
+  logs: {
+    level: process.env.LOG_LEVEL || 'silly',
+  },
+  api: {
+    prefix: '/api',
+  },
+  jwt: {
+    secret: process.env.JWT_SECRET || createRandomString(16, 32),
+    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) {
-  // 声明QL_DIR环境变量
   let qlHomePath = path.join(__dirname, '../../');
-  // 生产环境
   if (qlHomePath.endsWith('/static/')) {
     qlHomePath = path.join(qlHomePath, '../');
   }
@@ -19,12 +67,19 @@ 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') });
 
-const dataPath = path.join(rootPath, 'data/');
+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/');
@@ -32,7 +87,11 @@ const uploadPath = path.join(dataPath, 'upload/');
 const sshdPath = path.join(dataPath, 'ssh.d/');
 const systemLogPath = path.join(dataPath, 'syslog/');
 
-const envFile = path.join(configPath, 'env.sh');
+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');
@@ -47,27 +106,21 @@ 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 {
-  port: parseInt(process.env.BACK_PORT as string, 10),
+  ...config,
-  cronPort: parseInt(process.env.CRON_PORT as string, 10),
+  jwt: config.jwt,
-  publicPort: parseInt(process.env.PUBLIC_PORT as string, 10),
-  secret: process.env.SECRET || createRandomString(16, 32),
-  logs: {
-    level: process.env.LOG_LEVEL || 'silly',
-  },
-  api: {
-    prefix: '/api',
-  },
   rootPath,
   tmpPath,
   dataPath,
   dataTgzFile,
   shareShellFile,
+  dependenceProxyFile,
   configString,
   loginFaild,
   authError,
@@ -79,23 +132,32 @@ export default {
   sampleFile,
   confFile,
   envFile,
+  jsEnvFile,
+  pyEnvFile,
+  jsNotifyFile,
+  pyNotifyFile,
   dbPath,
   uploadPath,
   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',
     '/open/auth/token',
     '/api/user/two-factor/login',
     '/api/system',

back/config/serverEnv.ts

@@ -1,11 +1,19 @@
 import { Request, Response } from 'express';
-import { pick } from 'lodash';
+import pick from 'lodash/pick';
 
 let pickedEnv: Record<string, string>;
 
 function getPickedEnv() {
   if (pickedEnv) return pickedEnv;
-  const picked = pick(process.env, ['QlBaseUrl', 'DeployEnv']);
+  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;
 }

back/config/subscription.ts

@@ -32,7 +32,9 @@ export function formatCommand(doc: Subscription, url?: string) {
     autoDelCron,
   } = doc;
   if (type === 'file') {
-    command += `raw "${_url}"`;
+    command += `raw "${_url}" "${proxy || ''}" "${
+      isNil(autoAddCron) ? true : Boolean(autoAddCron)
+    }" "${isNil(autoDelCron) ? true : Boolean(autoDelCron)}"`;
   } else {
     command += `repo "${_url}" "${whitelist || ''}" "${blacklist || ''}" "${
       dependences || ''

back/config/util.ts

@@ -1,34 +1,40 @@
-import * as fs from 'fs';
+import * as fs from 'fs/promises';
 import * as path from 'path';
-import got from 'got';
-import iconv from 'iconv-lite';
 import { exec } from 'child_process';
-import FormData from 'form-data';
+import psTreeFun from 'ps-tree';
-import psTreeFun from 'pstree.remy';
 import { promisify } from 'util';
 import { load } from 'js-yaml';
 import config from './index';
-import { TASK_COMMAND } from './const';
+import { PYTHON_INSTALL_DIR, TASK_COMMAND } from './const';
 import Logger from '../loaders/logger';
+import { writeFileWithLock } from '../shared/utils';
+import { DependenceTypes } from '../data/dependence';
+import { FormData } from 'undici';
 
 export * from './share';
 
-export function getFileContentByName(fileName: string) {
+export async function getFileContentByName(fileName: string) {
-  if (fs.existsSync(fileName)) {
+  const _exsit = await fileExist(fileName);
-    return fs.readFileSync(fileName, 'utf8');
+  if (_exsit) {
+    return await fs.readFile(fileName, 'utf8');
   }
   return '';
 }
 
-export function getLastModifyFilePath(dir: string) {
+export function removeAnsi(text: string) {
+  return text.replace(/\x1b\[\d+m/g, '');
+}
+
+export async function getLastModifyFilePath(dir: string) {
   let filePath = '';
 
-  if (fs.existsSync(dir)) {
+  const _exsit = await fileExist(dir);
-    const arr = fs.readdirSync(dir);
+  if (_exsit) {
+    const arr = await fs.readdir(dir);
 
-    arr.forEach((item) => {
+    arr.forEach(async (item) => {
       const fullpath = path.join(dir, item);
-      const stats = fs.statSync(fullpath);
+      const stats = await fs.lstat(fullpath);
       if (stats.isFile()) {
         if (stats.mtimeMs >= 0) {
           filePath = fullpath;
@@ -50,69 +56,6 @@ 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);
@@ -134,12 +77,19 @@ 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' || testUa(/mobile/g)) {
+  } else if (
+    system === 'android' ||
+    system === 'ios' ||
+    system === 'openharmony' ||
+    testUa(/mobile/g)
+  ) {
     platform = 'mobile';
   }
 
@@ -147,22 +97,17 @@ export function getPlatform(userAgent: string): 'mobile' | 'desktop' {
 }
 
 export async function fileExist(file: any) {
-  return new Promise((resolve) => {
+  try {
-    try {
+    await fs.access(file);
-      fs.accessSync(file);
+    return true;
-      resolve(true);
+  } catch (error) {
-    } catch (error) {
+    return false;
-      resolve(false);
+  }
-    }
-  });
 }
 
 export async function createFile(file: string, data: string = '') {
-  return new Promise((resolve) => {
+  await fs.mkdir(path.dirname(file), { recursive: true });
-    fs.mkdirSync(path.dirname(file), { recursive: true });
+  await writeFileWithLock(file, data);
-    fs.writeFileSync(file, data);
-    resolve(true);
-  });
 }
 
 export async function handleLogPath(
@@ -219,102 +164,127 @@ enum FileType {
   'file',
 }
 
-interface IFile {
+export interface IFile {
   title: string;
   key: string;
   type: 'directory' | 'file';
   parent: string;
-  mtime: number;
+  createTime: number;
   size?: number;
   children?: IFile[];
 }
 
 export function dirSort(a: IFile, b: IFile): number {
-  if (a.type !== b.type) {
+  if (a.type === 'file' && b.type === 'file') {
-    return FileType[a.type] < FileType[b.type] ? -1 : 1
+    return b.createTime - a.createTime;
-  } else if (a.mtime !== b.mtime) {
+  } else if (a.type === 'directory' && b.type === 'directory') {
-    return a.mtime > b.mtime ? -1 : 1
+    return a.title.localeCompare(b.title);
   } else {
-    return 0;
+    return a.type === 'directory' ? -1 : 1;
   }
 }
 
-export function readDirs(
+export async function readDirs(
   dir: string,
   baseDir: string = '',
   blacklist: string[] = [],
-): IFile[] {
+  sort: (a: IFile, b: IFile) => number = dirSort,
+): Promise<IFile[]> {
   const relativePath = path.relative(baseDir, dir);
-  const files = fs.readdirSync(dir);
+  const files = await fs.readdir(dir);
-  const result: IFile[] = files
+  const result: IFile[] = [];
-    .filter((x) => !blacklist.includes(x))
+
-    .map((file: string) => {
+  for (const file of files) {
-      const subPath = path.join(dir, file);
+    const subPath = path.join(dir, file);
-      const stats = fs.statSync(subPath);
+    const stats = await fs.lstat(subPath);
-      const key = path.join(relativePath, file);
+    const key = path.join(relativePath, file);
-      if (stats.isDirectory()) {
+
-        return {
+    if (blacklist.includes(file) || stats.isSymbolicLink()) {
-          title: file,
+      continue;
-          key,
+    }
-          type: 'directory',
+
-          parent: relativePath,
+    if (stats.isDirectory()) {
-          mtime: stats.mtime.getTime(),
+      const children = await readDirs(subPath, baseDir, blacklist, sort);
-          children: readDirs(subPath, baseDir).sort(dirSort),
+      result.push({
-        };
+        title: file,
-      }
+        key,
-      return {
+        type: 'directory',
+        parent: relativePath,
+        createTime: stats.birthtime.getTime(),
+        children: children.sort(sort),
+      });
+    } else {
+      result.push({
         title: file,
         type: 'file',
-        isLeaf: true,
         key,
         parent: relativePath,
         size: stats.size,
-        mtime: stats.mtime.getTime(),
+        createTime: stats.birthtime.getTime(),
-      };
+      });
-    });
+    }
-  return result.sort(dirSort);
+  }
+
+  return result.sort(sort);
 }
 
-export function readDir(
+export async function readDir(
   dir: string,
   baseDir: string = '',
   blacklist: string[] = [],
-) {
+): Promise<IFile[]> {
-  const relativePath = path.relative(baseDir, dir);
+  const absoluteDir = path.join(baseDir, dir);
-  const files = fs.readdirSync(dir);
+  const relativePath = path.relative(baseDir, absoluteDir);
-  const result: any = files
-    .filter((x) => !blacklist.includes(x))
-    .map((file: string) => {
-      const subPath = path.join(dir, file);
-      const stats = fs.statSync(subPath);
-      const key = path.join(relativePath, file);
-      return {
-        title: file,
-        type: stats.isDirectory() ? 'directory' : 'file',
-        key,
-        parent: relativePath,
-      };
-    });
-  return result;
-}
 
-export function emptyDir(path: string) {
+  try {
-  const files = fs.readdirSync(path);
+    const files = await fs.readdir(absoluteDir);
-  files.forEach((file) => {
+    const result: IFile[] = [];
-    const filePath = `${path}/${file}`;
+
-    const stats = fs.statSync(filePath);
+    for (const file of files) {
-    if (stats.isDirectory()) {
+      const subPath = path.join(absoluteDir, file);
-      emptyDir(filePath);
+      const stats = await fs.lstat(subPath);
-    } else {
+      const key = path.join(relativePath, file);
-      fs.unlinkSync(filePath);
+
+      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(),
+        });
+      }
     }
-  });
+
-  fs.rmdirSync(path);
+    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' });
+    const { stderr, stdout } = await promisify(exec)(command, {
+      maxBuffer: 200 * 1024 * 1024,
+      encoding: 'utf8',
+    });
     return stdout || stderr;
   } catch (error) {
     return JSON.stringify(error);
@@ -323,7 +293,10 @@ export async function promiseExec(command: string): Promise<string> {
 
 export async function promiseExecSuccess(command: string): Promise<string> {
   try {
-    const { stdout } = await promisify(exec)(command, { maxBuffer: 200 * 1024 * 1024, encoding: 'utf8' });
+    const { stdout } = await promisify(exec)(command, {
+      maxBuffer: 200 * 1024 * 1024,
+      encoding: 'utf8',
+    });
     return stdout || '';
   } catch (error) {
     return '';
@@ -334,9 +307,9 @@ export function parseHeaders(headers: string) {
   if (!headers) return {};
 
   const parsed: any = {};
-  let key;
+  let key: string;
-  let val;
+  let val: string;
-  let i;
+  let i: number;
 
   headers &&
     headers.split('\n').forEach(function parser(line) {
@@ -354,37 +327,49 @@ export function parseHeaders(headers: string) {
   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',
+    | 'application/x-www-form-urlencoded'
+    | 'text/plain',
+  valueFormatFn?: (v: string) => string,
 ) {
-  if (!body) return '';
+  if (contentType === 'text/plain' || !body) {
+    return valueFormatFn && body ? valueFormatFn(body) : body;
+  }
 
-  const parsed: any = {};
+  const parsed = parseString(body, valueFormatFn);
-  let key;
-  let val;
-  let i;
-
-  body &&
-    body.split('\n').forEach(function parser(line) {
-      i = line.indexOf(':');
-      key = line.substring(0, i).trim().toLowerCase();
-      val = line.substring(i + 1).trim();
-
-      if (!key || parsed[key]) {
-        return;
-      }
-
-      try {
-        const jsonValue = JSON.parse(val);
-        parsed[key] = jsonValue;
-      } catch (error) {
-        parsed[key] = val;
-      }
-    });
 
   switch (contentType) {
     case 'multipart/form-data':
@@ -403,31 +388,31 @@ export function parseBody(
 
 export function psTree(pid: number): Promise<number[]> {
   return new Promise((resolve, reject) => {
-    psTreeFun(pid, (err: any, pids: number[]) => {
+    psTreeFun(pid, (err: any, children) => {
       if (err) {
         reject(err);
       }
-      resolve(pids.filter((x) => !isNaN(x)));
+      resolve(children.map((x) => Number(x.PID)).filter((x) => !isNaN(x)));
     });
   });
 }
 
 export async function killTask(pid: number) {
   const pids = await psTree(pid);
-  // SIGINT 2 程序终止(interrupt)信号，不会打印额外信息
+
   if (pids.length) {
     try {
-      [pid, ...pids].forEach((x) => {
+      [pid, ...pids].reverse().forEach((x) => {
-        process.kill(x, 2);
+        process.kill(x, 15);
       });
-    } catch (error) { }
+    } catch (error) {}
   } else {
     process.kill(pid, 2);
   }
 }
 
-export async function getPid(name: string) {
+export async function getPid(cmd: string) {
-  const taskCommand = `ps -eo pid,command | grep "${name}" | grep -v grep | awk '{print $1}' | head -1 | xargs echo -n`;
+  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;
 }
@@ -440,21 +425,29 @@ interface IVersion {
 }
 
 export async function parseVersion(path: string): Promise<IVersion> {
-  return load(await promisify(fs.readFile)(path, 'utf8')) as IVersion;
+  return load(await fs.readFile(path, 'utf8')) as IVersion;
 }
 
-export async function parseContentVersion(content: string): Promise<IVersion> {
+export function parseContentVersion(content: string): IVersion {
   return load(content) as IVersion;
 }
 
-export async function getUniqPath(command: string, id: string): Promise<string> {
+export async function getUniqPath(
+  command: string,
+  id: string,
+): Promise<string> {
+  let suffix = '';
   if (/^\d+$/.test(id)) {
-    id = `_${id}`;
+    suffix = `_${id}`;
-  } else {
+  }
-    id = '';
+
+  let items = command.split(/ +/);
+
+  const maxTimeCommandIndex = items.findIndex((x) => x === '-m');
+  if (maxTimeCommandIndex !== -1) {
+    items = items.slice(maxTimeCommandIndex + 2);
   }
 
-  const items = command.split(/ +/);
   let str = items[0];
   if (items[0] === TASK_COMMAND) {
     str = items[1];
@@ -478,7 +471,7 @@ export async function getUniqPath(command: string, id: string): Promise<string>
     str = `${tempStr}_${str.slice(slashIndex + 1)}`;
   }
 
-  return `${str}${id}`;
+  return `${str}${suffix}`;
 }
 
 export function safeJSONParse(value?: string) {
@@ -489,7 +482,90 @@ export function safeJSONParse(value?: string) {
   try {
     return JSON.parse(value);
   } catch (error) {
-    Logger.error('[JSON.parse失败]', 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/cron.ts

@@ -18,6 +18,9 @@ export class Crontab {
   last_running_time?: number;
   last_execution_time?: number;
   sub_id?: number;
+  extra_schedules?: Array<{ schedule: string }>;
+  task_before?: string;
+  task_after?: string;
 
   constructor(options: Crontab) {
     this.name = options.name;
@@ -39,6 +42,9 @@ export class Crontab {
     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;
   }
 }
 
@@ -49,7 +55,7 @@ export enum CrontabStatus {
   'disabled',
 }
 
-export interface CronInstance extends Model<Crontab, Crontab>, Crontab {}
+export interface CronInstance extends Model<Crontab, Crontab>, Crontab { }
 export const CrontabModel = sequelize.define<CronInstance>('Crontab', {
   name: {
     unique: 'compositeIndex',
@@ -75,4 +81,7 @@ export const CrontabModel = sequelize.define<CronInstance>('Crontab', {
   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,
 });

back/data/dependence.ts

@@ -32,6 +32,7 @@ export enum DependenceStatus {
   'removed',
   'removeFailed',
   'queued',
+  'cancelled',
 }
 
 export enum DependenceTypes {
@@ -40,30 +41,12 @@ export enum DependenceTypes {
   'linux',
 }
 
-export enum InstallDependenceCommandTypes {
-  'pnpm add -g',
-  'pip3 install --disable-pip-version-check --root-user-action=ignore',
-  'apk add --no-check-certificate',
-}
-
-export enum GetDependenceCommandTypes {
-  'pnpm ls -g ',
-  'pip3 show --disable-pip-version-check',
-  'apk info -es',
-}
-
 export enum versionDependenceCommandTypes {
   '@',
   '==',
   '=',
 }
 
-export enum unInstallDependenceCommandTypes {
-  'pnpm remove -g',
-  'pip3 uninstall --disable-pip-version-check --root-user-action=ignore -y',
-  'apk del',
-}
-
 export interface DependenceInstance
   extends Model<Dependence, Dependence>,
     Dependence {}

back/data/env.ts

@@ -20,7 +20,7 @@ export class Env {
     this.timestamp = new Date().toString();
     this.position = options.position;
     this.name = options.name;
-    this.remarks = options.remarks;
+    this.remarks = options.remarks || '';
   }
 }
 

back/data/notify.ts

@@ -14,10 +14,14 @@ export enum NotificationMode {
   '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 {
@@ -45,9 +49,8 @@ export class PushDeerNotification extends NotificationBaseInfo {
   public pushDeerUrl = '';
 }
 
-export class ChatNotification extends NotificationBaseInfo {
+export class synologyChatNotification extends NotificationBaseInfo {
-  public chatUrl = '';
+  public synologyChatUrl = '';
-  public chatToken = '';
 }
 
 export class BarkNotification extends NotificationBaseInfo {
@@ -55,6 +58,9 @@ export class BarkNotification extends NotificationBaseInfo {
   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 {
@@ -63,7 +69,7 @@ export class TelegramBotNotification extends NotificationBaseInfo {
   public telegramBotProxyHost = '';
   public telegramBotProxyPort = '';
   public telegramBotProxyAuth = '';
-  public telegramBotApiHost = 'api.telegram.org';
+  public telegramBotApiHost = 'https://api.telegram.org';
 }
 
 export class DingtalkBotNotification extends NotificationBaseInfo {
@@ -94,16 +100,35 @@ 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 {
@@ -121,12 +146,24 @@ export class LarkNotification extends NotificationBaseInfo {
   public larkKey = '';
 }
 
+export class NtfyNotification extends NotificationBaseInfo {
+  public ntfyUrl = '';
+  public ntfyTopic = '';
+  public ntfyPriority = '';
+}
+
+export class WxPusherBotNotification extends NotificationBaseInfo {
+  public wxPusherBotAppToken = '';
+  public wxPusherBotTopicIds = '';
+  public wxPusherBotUids = '';
+}
+
 export interface NotificationInfo
   extends GoCqHttpBotNotification,
     GotifyNotification,
     ServerChanNotification,
     PushDeerNotification,
-    ChatNotification,
+    synologyChatNotification,
     BarkNotification,
     TelegramBotNotification,
     DingtalkBotNotification,
@@ -135,7 +172,11 @@ export interface NotificationInfo
     AibotkNotification,
     IGotNotification,
     PushPlusNotification,
+    WePlusBotNotification,
     EmailNotification,
     PushMeNotification,
     WebhookNotification,
-    LarkNotification {}
+    ChronocatNotification,
+    LarkNotification,
+    NtfyNotification,
+    WxPusherBotNotification {}

back/data/open.ts

@@ -24,7 +24,7 @@ export interface AppToken {
   expiration: number;
 }
 
-export type AppScope = 'envs' | 'crons' | 'configs' | 'scripts' | 'logs';
+export type AppScope = 'envs' | 'crons' | 'configs' | 'scripts' | 'logs' | 'system';
 
 export interface AppInstance extends Model<App, App>, App {}
 export const AppModel = sequelize.define<AppInstance>('App', {

back/data/sock.ts

@@ -17,4 +17,6 @@ export type SockMessageType =
   | 'updateSystemVersion'
   | 'manuallyRunScript'
   | 'runSubscriptionEnd'
-  | 'reloadSystem';
+  | 'reloadSystem'
+  | 'updateNodeMirror'
+  | 'updateLinuxMirror';

back/data/system.ts

@@ -2,13 +2,13 @@ import { sequelize } from '.';
 import { DataTypes, Model, ModelDefined } from 'sequelize';
 import { NotificationInfo } from './notify';
 
-export class AuthInfo {
+export class SystemInfo {
   ip?: string;
   type: AuthDataType;
-  info?: AuthModelInfo;
+  info?: SystemModelInfo;
   id?: number;
 
-  constructor(options: AuthInfo) {
+  constructor(options: SystemInfo) {
     this.ip = options.ip;
     this.info = options.info;
     this.type = options.type;
@@ -27,11 +27,17 @@ export enum AuthDataType {
   '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 {
@@ -42,12 +48,31 @@ export interface LoginLogInfo {
   status?: LoginStatus;
 }
 
-export type AuthModelInfo = SystemConfigInfo &
+export interface AuthInfo {
-  Partial<NotificationInfo> &
+  username: string;
-  LoginLogInfo;
+  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 interface AuthInstance extends Model<AuthInfo, AuthInfo>, AuthInfo {}
+export type SystemModelInfo = SystemConfigInfo &
-export const AuthModel = sequelize.define<AuthInstance>('Auth', {
+  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: {

back/index.d.ts

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

back/interface/schedule.ts

@@ -0,0 +1,13 @@
+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

@@ -5,30 +5,24 @@ import initData from './initData';
 import { Application } from 'express';
 import linkDeps from './deps';
 import initTask from './initTask';
+import initFile from './initFile';
 
-export default async ({ expressApp }: { expressApp: Application }) => {
+export default async ({ app }: { app: Application }) => {
-  try {
+  depInjectorLoader();
-    depInjectorLoader();
+  Logger.info('✌️ Dependency loaded');
-    Logger.info('✌️ Dependency Injector loaded');
+
-    console.log('✌️ Dependency Injector loaded');
+  await linkDeps();
-  
+  Logger.info('✌️ Link deps loaded');
-    expressLoader({ app: expressApp });
+
-    Logger.info('✌️ Express loaded');
+  initFile();
-    console.log('✌️ Express loaded');
+  Logger.info('✌️ Init file loaded');
-  
+
-    await initData();
+  await initData();
-    Logger.info('✌️ init data loaded');
+  Logger.info('✌️ Init data loaded');
-    console.log('✌️ init data loaded');
+
-  
+  initTask();
-    await linkDeps();
+  Logger.info('✌️ Init task loaded');
-    Logger.info('✌️ link deps loaded');
+
-    console.log('✌️ link deps loaded');
+  expressLoader({ app });
-  
+  Logger.info('✌️ Express loaded');
-    initTask();
-    Logger.info('✌️ init task loaded');
-    console.log('✌️ init task loaded');
-  } catch (error) {
-    Logger.error(`✌️ depInjectorLoader expressLoader initData linkDeps failed, ${error}`);
-    console.error(`✌️ depInjectorLoader expressLoader initData linkDeps failed ${error}`);
-  }
 };

back/loaders/bootAfter.ts

@@ -0,0 +1,8 @@
+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,15 +1,11 @@
 import Logger from './logger';
-import path from 'path';
-import DataStore from 'nedb';
 import { EnvModel } from '../data/env';
 import { CrontabModel } from '../data/cron';
 import { DependenceModel } from '../data/dependence';
 import { AppModel } from '../data/open';
-import { AuthModel } from '../data/auth';
+import { SystemModel } from '../data/system';
-import { fileExist } from '../config/util';
 import { SubscriptionModel } from '../data/subscription';
 import { CrontabViewModel } from '../data/cronView';
-import config from '../config';
 import { sequelize } from '../data';
 
 export default async () => {
@@ -17,7 +13,7 @@ export default async () => {
     await CrontabModel.sync();
     await DependenceModel.sync();
     await AppModel.sync();
-    await AuthModel.sync();
+    await SystemModel.sync();
     await EnvModel.sync();
     await SubscriptionModel.sync();
     await CrontabViewModel.sync();
@@ -49,83 +45,20 @@ export default async () => {
     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) {}
 
-    // 2.10-2.11 升级
-    const cronDbFile = path.join(config.rootPath, 'db/crontab.db');
-    const envDbFile = path.join(config.rootPath, 'db/env.db');
-    const appDbFile = path.join(config.rootPath, 'db/app.db');
-    const authDbFile = path.join(config.rootPath, 'db/auth.db');
-    const dependenceDbFile = path.join(config.rootPath, 'db/dependence.db');
-    const crondbExist = await fileExist(cronDbFile);
-    const dependenceDbExist = await fileExist(dependenceDbFile);
-    const envDbExist = await fileExist(envDbFile);
-    const appDbExist = await fileExist(appDbFile);
-    const authDbExist = await fileExist(authDbFile);
-
-    const cronCount = await CrontabModel.count();
-    const dependenceCount = await DependenceModel.count();
-    const envCount = await EnvModel.count();
-    const appCount = await AppModel.count();
-    const authCount = await AuthModel.count();
-    if (crondbExist && cronCount === 0) {
-      const cronDb = new DataStore({
-        filename: cronDbFile,
-        autoload: true,
-      });
-      cronDb.persistence.compactDatafile();
-      cronDb.find({}).exec(async (err, docs) => {
-        await CrontabModel.bulkCreate(docs, { ignoreDuplicates: true });
-      });
-    }
-
-    if (dependenceDbExist && dependenceCount === 0) {
-      const dependenceDb = new DataStore({
-        filename: dependenceDbFile,
-        autoload: true,
-      });
-      dependenceDb.persistence.compactDatafile();
-      dependenceDb.find({}).exec(async (err, docs) => {
-        await DependenceModel.bulkCreate(docs, { ignoreDuplicates: true });
-      });
-    }
-
-    if (envDbExist && envCount === 0) {
-      const envDb = new DataStore({
-        filename: envDbFile,
-        autoload: true,
-      });
-      envDb.persistence.compactDatafile();
-      envDb.find({}).exec(async (err, docs) => {
-        await EnvModel.bulkCreate(docs, { ignoreDuplicates: true });
-      });
-    }
-
-    if (appDbExist && appCount === 0) {
-      const appDb = new DataStore({
-        filename: appDbFile,
-        autoload: true,
-      });
-      appDb.persistence.compactDatafile();
-      appDb.find({}).exec(async (err, docs) => {
-        await AppModel.bulkCreate(docs, { ignoreDuplicates: true });
-      });
-    }
-
-    if (authDbExist && authCount === 0) {
-      const authDb = new DataStore({
-        filename: authDbFile,
-        autoload: true,
-      });
-      authDb.persistence.compactDatafile();
-      authDb.find({}).exec(async (err, docs) => {
-        await AuthModel.bulkCreate(docs, { ignoreDuplicates: true });
-      });
-    }
-
-    console.log('✌️ DB loaded');
     Logger.info('✌️ DB loaded');
   } catch (error) {
-    console.error('✌️ DB load failed');
+    Logger.error('✌️ DB load failed', error);
-    Logger.error(error);
   }
 };

back/loaders/deps.ts

@@ -1,20 +1,19 @@
 import path from 'path';
-import fs from 'fs';
+import fs from 'fs/promises';
 import chokidar from 'chokidar';
 import config from '../config/index';
-import { promiseExec } from '../config/util';
+import { fileExist, promiseExec, rmPath } from '../config/util';
 
-function linkToNodeModule(src: string, dst?: string) {
+async function linkToNodeModule(src: string, dst?: string) {
   const target = path.join(config.rootPath, 'node_modules', dst || src);
   const source = path.join(config.rootPath, src);
 
-  fs.lstat(target, (err, stat) => {
+  try {
-    if (!stat) {
+    const stats = await fs.lstat(target);
-      fs.symlink(source, target, 'dir', (err) => {
+    if (!stats) {
-        if (err) throw err;
+      await fs.symlink(source, target, 'dir');
-      });
     }
-  });
+  } catch (error) {}
 }
 
 async function linkCommand() {
@@ -24,26 +23,27 @@ async function linkCommand() {
     {
       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);
-    if (fs.existsSync(target)) {
+    const tmpTarget = path.join(commandDir, link.tmp);
-      fs.unlinkSync(target);
+    await fs.symlink(source, tmpTarget);
-    }
+    await fs.rename(tmpTarget, target);
-    fs.symlink(source, target, (err) => { });
   }
 }
 
 export default async (src: string = 'deps') => {
   await linkCommand();
-  linkToNodeModule(src);
+  await linkToNodeModule(src);
 
   const source = path.join(config.rootPath, src);
   const watcher = chokidar.watch(source, {

back/loaders/express.ts

@@ -3,42 +3,25 @@ import bodyParser from 'body-parser';
 import cors from 'cors';
 import routes from '../api';
 import config from '../config';
-import jwt, { UnauthorizedError } from 'express-jwt';
+import { UnauthorizedError, expressjwt } from 'express-jwt';
-import fs from 'fs';
+import { getPlatform, getToken } from '../config/util';
-import { getPlatform, getToken, safeJSONParse } from '../config/util';
-import Container from 'typedi';
-import OpenService from '../services/open';
 import rewrite from 'express-urlrewrite';
-import UserService from '../services/user';
-import * as Sentry from '@sentry/node';
-import { EnvModel } from '../data/env';
 import { errors } from 'celebrate';
-import { createProxyMiddleware } from 'http-proxy-middleware';
 import { serveEnv } from '../config/serverEnv';
-import Logger from './logger';
+import { IKeyvStore, shareStore } from '../shared/store';
 
 export default ({ app }: { app: Application }) => {
-  app.enable('trust proxy');
+  app.set('trust proxy', 'loopback');
   app.use(cors());
   app.get(`${config.api.prefix}/env.js`, serveEnv);
   app.use(`${config.api.prefix}/static`, express.static(config.uploadPath));
 
-  app.use(
-    '/api/public',
-    createProxyMiddleware({
-      target: `http://0.0.0.0:${config.publicPort}/api`,
-      changeOrigin: true,
-      pathRewrite: { '/api/public': '' },
-      logProvider: () => Logger
-    }),
-  );
-
   app.use(bodyParser.json({ limit: '50mb' }));
   app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));
 
   app.use(
-    jwt({
+    expressjwt({
-      secret: config.secret,
+      secret: config.jwt.secret,
       algorithms: ['HS384'],
     }).unless({
       path: [...config.apiWhiteList, /^\/open\//],
@@ -55,11 +38,13 @@ export default ({ app }: { app: Application }) => {
     return next();
   });
 
-  app.use(async (req, res, next) => {
+  app.use(async (req: Request, res, next) => {
     const headerToken = getToken(req);
     if (req.path.startsWith('/open/')) {
-      const openService = Container.get(OpenService);
+      const apps = await shareStore.getApps();
-      const doc = await openService.findTokenByValue(headerToken);
+      const doc = apps?.filter((x) =>
+        x.tokens?.find((y) => y.value === headerToken),
+      )?.[0];
       if (doc && doc.tokens && doc.tokens.length > 0) {
         const currentToken = doc.tokens.find((x) => x.value === headerToken);
         const keyMatch = req.path.match(/\/open\/([a-z]+)\/*/);
@@ -83,9 +68,9 @@ export default ({ app }: { app: Application }) => {
       return next();
     }
 
-    const data = fs.readFileSync(config.authConfigFile, 'utf8');
+    const authInfo = await shareStore.getAuthInfo();
-    if (data && headerToken) {
+    if (authInfo && headerToken) {
-      const { token = '', tokens = {} } = safeJSONParse(data);
+      const { token = '', tokens = {} } = authInfo;
       if (headerToken === token || tokens[req.platform] === headerToken) {
         return next();
       }
@@ -103,9 +88,8 @@ export default ({ app }: { app: Application }) => {
     if (!['/api/user/init', '/api/user/notification/init'].includes(req.path)) {
       return next();
     }
-    const userService = Container.get(UserService);
+    const authInfo =
-    const authInfo = await userService.getUserInfo();
+      (await shareStore.getAuthInfo()) || ({} as IKeyvStore['authInfo']);
-    const envCount = await EnvModel.count();
 
     let isInitialized = true;
     if (
@@ -163,8 +147,8 @@ export default ({ app }: { app: Application }) => {
           .status(500)
           .send({
             code: 400,
-            message: `${err.name} ${err.message}`,
+            message: `${err.message}`,
-            validation: err.errors,
+            errors: err.errors,
           })
           .end();
       }
@@ -179,8 +163,6 @@ 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

@@ -9,11 +9,112 @@ 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';
 
 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);
+
+      require('./bootAfter').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({
@@ -32,22 +133,6 @@ export default async () => {
   // 初始化更新所有任务状态为空闲
   await CrontabModel.update({ status: CrontabStatus.idle }, { where: {} });
 
-  // 初始化时安装所有处于安装中，安装成功，安装失败的依赖
-  DependenceModel.findAll({
-    where: {},
-    order: [
-      ['type', 'DESC'],
-      ['createdAt', 'DESC'],
-    ],
-    raw: true,
-  }).then(async (docs) => {
-    await DependenceModel.update(
-      { status: DependenceStatus.queued, log: [] },
-      { where: { id: docs.map((x) => x.id!) } },
-    );
-    dependenceService.installDependenceOneByOne(docs);
-  });
-
   // 初始化时执行一次所有的 ql repo 任务
   CrontabModel.findAll({
     where: {
@@ -90,7 +175,7 @@ export default async () => {
         if (doc.command.includes(`${config.rootPath}/log/`)) {
           await CrontabModel.update(
             {
-              command: `${config.rootPath}/data/log/${doc.command.replace(
+              command: `${config.dataPath}/log/${doc.command.replace(
                 `${config.rootPath}/log/`,
                 '',
               )}`,
@@ -101,7 +186,7 @@ export default async () => {
         if (doc.command.includes(`${config.rootPath}/config/`)) {
           await CrontabModel.update(
             {
-              command: `${config.rootPath}/data/config/${doc.command.replace(
+              command: `${config.dataPath}/config/${doc.command.replace(
                 `${config.rootPath}/config/`,
                 '',
               )}`,
@@ -112,7 +197,7 @@ export default async () => {
         if (doc.command.includes(`${config.rootPath}/db/`)) {
           await CrontabModel.update(
             {
-              command: `${config.rootPath}/data/db/${doc.command.replace(
+              command: `${config.dataPath}/db/${doc.command.replace(
                 `${config.rootPath}/db/`,
                 '',
               )}`,
@@ -127,4 +212,11 @@ export default async () => {
   // 初始化保存一次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);
+  }
 };

back/loaders/initFile.ts

@@ -1,12 +1,18 @@
-import fs from 'fs';
+import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
-import dotenv from 'dotenv';
 import Logger from './logger';
 import { fileExist } from '../config/util';
+import { writeFileWithLock } from '../shared/utils';
 
 const rootPath = process.env.QL_DIR as string;
-const dataPath = path.join(rootPath, 'data/');
+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/');
@@ -15,101 +21,107 @@ 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 authConfigFile = path.join(configPath, 'auth.json');
 const sampleConfigFile = path.join(samplePath, 'config.sample.sh');
-const sampleAuthFile = path.join(samplePath, 'auth.sample.json');
 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 () => {
-  const authFileExist = await fileExist(authConfigFile);
+  for (const dirPath of directories) {
-  const confFileExist = await fileExist(confFile);
+    if (!(await fileExist(dirPath))) {
-  const scriptDirExist = await fileExist(scriptPath);
+      await fs.mkdir(dirPath);
-  const logDirExist = await fileExist(logPath);
+    }
-  const configDirExist = await fileExist(configPath);
-  const uploadDirExist = await fileExist(uploadPath);
-  const sshDirExist = await fileExist(sshPath);
-  const bakDirExist = await fileExist(bakPath);
-  const sshdDirExist = await fileExist(sshdPath);
-  const systemLogDirExist = await fileExist(systemLogPath);
-  const tmpDirExist = await fileExist(tmpPath);
-  const scriptNotifyJsFileExist = await fileExist(scriptNotifyJsFile);
-  const scriptNotifyPyFileExist = await fileExist(scriptNotifyPyFile);
-  const TaskBeforeFileExist = await fileExist(TaskBeforeFile);
-  const TaskAfterFileExist = await fileExist(TaskAfterFile);
-
-  if (!configDirExist) {
-    fs.mkdirSync(configPath);
   }
 
-  if (!scriptDirExist) {
+  for (const item of files) {
-    fs.mkdirSync(scriptPath);
+    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);
+    }
   }
 
-  if (!logDirExist) {
-    fs.mkdirSync(logPath);
-  }
-
-  if (!tmpDirExist) {
-    fs.mkdirSync(tmpPath);
-  }
-
-  if (!uploadDirExist) {
-    fs.mkdirSync(uploadPath);
-  }
-
-  if (!sshDirExist) {
-    fs.mkdirSync(sshPath);
-  }
-
-  if (!bakDirExist) {
-    fs.mkdirSync(bakPath);
-  }
-
-  if (!sshdDirExist) {
-    fs.mkdirSync(sshdPath);
-  }
-
-  if (!systemLogDirExist) {
-    fs.mkdirSync(systemLogPath);
-  }
-
-  // 初始化文件
-  if (!authFileExist) {
-    fs.writeFileSync(authConfigFile, fs.readFileSync(sampleAuthFile));
-  }
-
-  if (!confFileExist) {
-    fs.writeFileSync(confFile, fs.readFileSync(sampleConfigFile));
-  }
-
-  if (!scriptNotifyJsFileExist) {
-    fs.writeFileSync(scriptNotifyJsFile, fs.readFileSync(sampleNotifyJsFile));
-  }
-
-  if (!scriptNotifyPyFileExist) {
-    fs.writeFileSync(scriptNotifyPyFile, fs.readFileSync(sampleNotifyPyFile));
-  }
-
-  if (!TaskBeforeFileExist) {
-    fs.writeFileSync(TaskBeforeFile, fs.readFileSync(sampleTaskShellFile));
-  }
-
-  if (!TaskAfterFileExist) {
-    fs.writeFileSync(TaskAfterFile, fs.readFileSync(sampleTaskShellFile));
-  }
-
-  dotenv.config({ path: confFile });
-
   Logger.info('✌️ Init file down');
-  console.log('✌️ Init file down');
 };

back/loaders/initTask.ts

@@ -1,6 +1,6 @@
 import { Container } from 'typedi';
 import SystemService from '../services/system';
-import ScheduleService from '../services/schedule';
+import ScheduleService, { ScheduleTaskType } from '../services/schedule';
 import SubscriptionService from '../services/subscription';
 import config from '../config';
 import { fileExist } from '../config/util';
@@ -12,7 +12,10 @@ export default async () => {
   const subscriptionService = Container.get(SubscriptionService);
 
   // 生成内置token
-  let tokenCommand = `tsx ${join(config.rootPath, 'back/token.ts')}`;
+  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)) {
@@ -22,30 +25,43 @@ export default async () => {
     id: NaN,
     name: '生成token',
     command: tokenCommand,
-  };
+    runOrigin: 'system',
+  } as ScheduleTaskType;
   await scheduleService.cancelIntervalTask(cron);
-  scheduleService.createIntervalTask(cron, {
+  scheduleService.createIntervalTask(
-    days: 28,
+    cron,
-  });
+    {
+      days: 28,
+    },
+    true,
+  );
 
   // 运行删除日志任务
   const data = await systemService.getSystemConfig();
-  if (data && data.info && data.info.logRemoveFrequency) {
+  if (data && data.info) {
-    const rmlogCron = {
+    if (data.info.logRemoveFrequency) {
-      id: data.id as number,
+      const rmlogCron = {
-      name: '删除日志',
+        id: data.id as number,
-      command: `ql rmlog ${data.info.logRemoveFrequency}`,
+        name: '删除日志',
-    };
+        command: `ql rmlog ${data.info.logRemoveFrequency}`,
-    await scheduleService.cancelIntervalTask(rmlogCron);
+        runOrigin: 'system' as const,
-    scheduleService.createIntervalTask(rmlogCron, {
+      };
-      days: data.info.logRemoveFrequency,
+      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, !sub.is_disabled, !sub.is_disabled);
+    subscriptionService.handleTask(sub.get({ plain: true }), !sub.is_disabled);
   }
 };

back/loaders/logger.ts

@@ -4,35 +4,60 @@ import config from '../config';
 import path from 'path';
 
 const levelMap: Record<string, string> = {
-  info: '🔵',
+  info: 'ℹ️', // info图标
-  warn: '🟡',
+  warn: '⚠️', // 警告图标
-  error: '🔴',
+  error: '❌', // 错误图标
-  debug: '🔶'
+  debug: '🐛', // debug调试图标
-}
-
-const customFormat = winston.format.combine(
-  winston.format.splat(),
-  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-  winston.format.align(),
-  winston.format.printf((i) => `[${levelMap[i.level]}${i.level}] [${[i.timestamp]}]: ${i.message}`),
-);
-
-const defaultOptions = {
-  format: customFormat,
-  datePattern: "YYYY-MM-DD",
-  maxSize: "20m",
-  maxFiles: "7d",
 };
 
+const baseFormat = [
+  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: config.logs.level,
+  level: 'debug',
   levels: winston.config.npm.levels,
-  transports: [
+  transports: [consoleTransport, fileTransport],
-    new winston.transports.DailyRotateFile({
+  exceptionHandlers: [consoleTransport, fileTransport],
-      filename: path.join(config.systemLogPath, '%DATE%.log'),
+  rejectionHandlers: [consoleTransport, fileTransport],
-      ...defaultOptions,
+});
-    })
+
-  ],
+LoggerInstance.on('error', (error) => {
+  console.error('Logger error:', error);
 });
 
 export default LoggerInstance;

back/loaders/sentry.ts

@@ -1,33 +0,0 @@
-import { Application } from 'express';
-import * as Sentry from '@sentry/node';
-import * as Tracing from '@sentry/tracing';
-import Logger from './logger';
-import config from '../config';
-import fs from 'fs';
-import { parseVersion } from '../config/util';
-
-export default async ({ expressApp }: { expressApp: Application }) => {
-  const { version } = await parseVersion(config.versionFile);
-
-  Sentry.init({
-    ignoreErrors: [
-      /SequelizeUniqueConstraintError/i,
-      /Validation error/i,
-      /UnauthorizedError/i,
-      /celebrate request validation failed/i,
-    ],
-    dsn: 'https://f4b5b55fb3c645b29a5dc2d70a1a4ef4@o1098464.ingest.sentry.io/6122819',
-    integrations: [
-      new Sentry.Integrations.Http({ tracing: true }),
-      new Tracing.Integrations.Express({ app: expressApp }),
-    ],
-    tracesSampleRate: 0.8,
-    release: version,
-  });
-
-  expressApp.use(Sentry.Handlers.requestHandler());
-  expressApp.use(Sentry.Handlers.tracingHandler());
-
-  Logger.info('✌️ Sentry loaded');
-  console.log('✌️ Sentry loaded');
-};

back/loaders/server.ts

@@ -5,38 +5,12 @@ import Sock from './sock';
 export default async ({ server }: { server: Server }) => {
   await Sock({ server });
   Logger.info('✌️ Sock loaded');
-  let exitTime = 0;
-  let timer: NodeJS.Timeout;
-
-  process.on('SIGINT', (singal) => {
-    Logger.warn(`Server need close, singal ${singal}`);
-    console.warn(`Server need close, singal ${singal}`);
-    exitTime++;
-    if (exitTime >= 3) {
-      Logger.warn('Forcing server close');
-      console.warn('Forcing server close');
-      clearTimeout(timer);
-      process.exit(1);
-    }
-    server.close(() => {
-      if (timer) {
-        clearTimeout(timer);
-      }
-      timer = setTimeout(() => {
-        process.exit();
-      }, 15000);
-    });
-  });
 
   process.on('uncaughtException', (error) => {
     Logger.error('Uncaught exception:', error);
-    console.error('Uncaught exception:', error);
-    process.exit(1);
   });
 
   process.on('unhandledRejection', (reason, promise) => {
     Logger.error('Unhandled rejection:', reason, promise);
-    console.error('Unhandled rejection:', reason, promise);
-    process.exit(1);
   });
 };

back/loaders/sock.ts

@@ -1,28 +1,25 @@
 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 { getPlatform } from '../config/util';
-import fs from 'fs';
+import { shareStore } from '../shared/store';
-import { getPlatform, safeJSONParse } from '../config/util';
 
 export default async ({ server }: { server: Server }) => {
   const echo = sockJs.createServer({ prefix: '/api/ws', log: () => {} });
   const sockService = Container.get(SockService);
 
-  echo.on('connection', (conn) => {
+  echo.on('connection', async (conn) => {
     if (!conn.headers || !conn.url || !conn.pathname) {
       conn.close('404');
     }
 
-    const data = fs.readFileSync(config.authConfigFile, 'utf8');
+    const authInfo = await shareStore.getAuthInfo();
     const platform = getPlatform(conn.headers['user-agent'] || '') || 'desktop';
     const headerToken = conn.url.replace(`${conn.pathname}?token=`, '');
-    if (data) {
+    if (authInfo) {
-      const { token = '', tokens = {} } = safeJSONParse(data);
+      const { token = '', tokens = {} } = authInfo;
       if (headerToken === token || tokens[platform] === headerToken) {
-        conn.write(JSON.stringify({ type: 'ping', message: 'hanhh' }));
         sockService.addClient(conn);
 
         conn.on('data', (message) => {
@@ -34,8 +31,6 @@ export default async ({ server }: { server: Server }) => {
         });
 
         return;
-      } else {
-        conn.write(JSON.stringify({ type: 'ping', message: 'whyour' }));
       }
     }
 

back/middlewares/monitoring.ts

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,142 @@
+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 SystemNotifyRequest {
+  string title = 1;
+  string content = 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;
+}
+
+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

@@ -7,10 +7,14 @@ service Cron {
   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; }

back/protos/cron.ts

@@ -1,119 +1,232 @@
+// 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 {
-  CallOptions,
+  type CallOptions,
   ChannelCredentials,
   Client,
-  ClientOptions,
+  type ClientOptions,
-  ClientUnaryCall,
+  type ClientUnaryCall,
-  handleUnaryCall,
+  type handleUnaryCall,
   makeGenericClientConstructor,
   Metadata,
-  ServiceError,
+  type ServiceError,
-  UntypedServiceImplementation,
+  type UntypedServiceImplementation,
-} from '@grpc/grpc-js';
+} from "@grpc/grpc-js";
-import _m0 from 'protobufjs/minimal';
 
-export const protobufPackage = 'com.ql.cron';
+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 AddCronResponse {
+}
 
 export interface DeleteCronRequest {
   ids: string[];
 }
 
-export interface DeleteCronResponse {}
+export interface DeleteCronResponse {
-
-function createBaseICron(): ICron {
-  return { id: '', schedule: '', command: '' };
 }
 
-export const ICron = {
+function createBaseISchedule(): ISchedule {
-  encode(message: ICron, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+  return { schedule: "" };
-    if (message.id !== '') {
+}
-      writer.uint32(10).string(message.id);
+
-    }
+export const ISchedule: MessageFns<ISchedule> = {
-    if (message.schedule !== '') {
+  encode(message: ISchedule, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-      writer.uint32(18).string(message.schedule);
+    if (message.schedule !== "") {
-    }
+      writer.uint32(10).string(message.schedule);
-    if (message.command !== '') {
-      writer.uint32(26).string(message.command);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ICron {
+  decode(input: BinaryReader | Uint8Array, length?: number): ISchedule {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(input);
     let end = length === undefined ? reader.len : reader.pos + length;
-    const message = createBaseICron();
+    const message = createBaseISchedule();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
-          if (tag != 10) {
+          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) {
+      }
+      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) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
 
   fromJSON(object: any): ICron {
     return {
-      id: isSet(object.id) ? String(object.id) : '',
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
-      schedule: isSet(object.schedule) ? String(object.schedule) : '',
+      schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "",
-      command: isSet(object.command) ? String(object.command) : '',
+      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 = {};
-    message.id !== undefined && (obj.id = message.id);
+    if (message.id !== "") {
-    message.schedule !== undefined && (obj.schedule = message.schedule);
+      obj.id = message.id;
-    message.command !== undefined && (obj.command = message.command);
+    }
+    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 ?? {});
+    return ICron.fromPartial(base ?? ({} as any));
   },
-
   fromPartial<I extends Exact<DeepPartial<ICron>, I>>(object: I): ICron {
     const message = createBaseICron();
-    message.id = object.id ?? '';
+    message.id = object.id ?? "";
-    message.schedule = object.schedule ?? '';
+    message.schedule = object.schedule ?? "";
-    message.command = object.command ?? '';
+    message.command = object.command ?? "";
+    message.extra_schedules = object.extra_schedules?.map((e) => ISchedule.fromPartial(e)) || [];
+    message.name = object.name ?? "";
     return message;
   },
 };
@@ -122,68 +235,54 @@ function createBaseAddCronRequest(): AddCronRequest {
   return { crons: [] };
 }
 
-export const AddCronRequest = {
+export const AddCronRequest: MessageFns<AddCronRequest> = {
-  encode(
+  encode(message: AddCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    message: AddCronRequest,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
     for (const v of message.crons) {
-      ICron.encode(v!, writer.uint32(10).fork()).ldelim();
+      ICron.encode(v!, writer.uint32(10).fork()).join();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): AddCronRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): AddCronRequest {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+        case 1: {
-          if (tag != 10) {
+          if (tag !== 10) {
             break;
           }
 
           message.crons.push(ICron.decode(reader, reader.uint32()));
           continue;
+        }
       }
-      if ((tag & 7) == 4 || tag == 0) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
 
   fromJSON(object: any): AddCronRequest {
-    return {
+    return { crons: globalThis.Array.isArray(object?.crons) ? object.crons.map((e: any) => ICron.fromJSON(e)) : [] };
-      crons: Array.isArray(object?.crons)
-        ? object.crons.map((e: any) => ICron.fromJSON(e))
-        : [],
-    };
   },
 
   toJSON(message: AddCronRequest): unknown {
     const obj: any = {};
-    if (message.crons) {
+    if (message.crons?.length) {
-      obj.crons = message.crons.map((e) => (e ? ICron.toJSON(e) : undefined));
+      obj.crons = message.crons.map((e) => ICron.toJSON(e));
-    } else {
-      obj.crons = [];
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<AddCronRequest>, I>>(
+  create<I extends Exact<DeepPartial<AddCronRequest>, I>>(base?: I): AddCronRequest {
-    base?: I,
+    return AddCronRequest.fromPartial(base ?? ({} as any));
-  ): AddCronRequest {
-    return AddCronRequest.fromPartial(base ?? {});
   },
-
+  fromPartial<I extends Exact<DeepPartial<AddCronRequest>, I>>(object: I): AddCronRequest {
-  fromPartial<I extends Exact<DeepPartial<AddCronRequest>, I>>(
-    object: I,
-  ): AddCronRequest {
     const message = createBaseAddCronRequest();
     message.crons = object.crons?.map((e) => ICron.fromPartial(e)) || [];
     return message;
@@ -194,27 +293,23 @@ function createBaseAddCronResponse(): AddCronResponse {
   return {};
 }
 
-export const AddCronResponse = {
+export const AddCronResponse: MessageFns<AddCronResponse> = {
-  encode(
+  encode(_: AddCronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    _: AddCronResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): AddCronResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): AddCronResponse {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(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) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -228,15 +323,10 @@ export const AddCronResponse = {
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<AddCronResponse>, I>>(
+  create<I extends Exact<DeepPartial<AddCronResponse>, I>>(base?: I): AddCronResponse {
-    base?: I,
+    return AddCronResponse.fromPartial(base ?? ({} as any));
-  ): AddCronResponse {
-    return AddCronResponse.fromPartial(base ?? {});
   },
-
+  fromPartial<I extends Exact<DeepPartial<AddCronResponse>, I>>(_: I): AddCronResponse {
-  fromPartial<I extends Exact<DeepPartial<AddCronResponse>, I>>(
-    _: I,
-  ): AddCronResponse {
     const message = createBaseAddCronResponse();
     return message;
   },
@@ -246,68 +336,54 @@ function createBaseDeleteCronRequest(): DeleteCronRequest {
   return { ids: [] };
 }
 
-export const DeleteCronRequest = {
+export const DeleteCronRequest: MessageFns<DeleteCronRequest> = {
-  encode(
+  encode(message: DeleteCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    message: DeleteCronRequest,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
     for (const v of message.ids) {
       writer.uint32(10).string(v!);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): DeleteCronRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronRequest {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+        case 1: {
-          if (tag != 10) {
+          if (tag !== 10) {
             break;
           }
 
           message.ids.push(reader.string());
           continue;
+        }
       }
-      if ((tag & 7) == 4 || tag == 0) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
 
   fromJSON(object: any): DeleteCronRequest {
-    return {
+    return { ids: globalThis.Array.isArray(object?.ids) ? object.ids.map((e: any) => globalThis.String(e)) : [] };
-      ids: Array.isArray(object?.ids)
-        ? object.ids.map((e: any) => String(e))
-        : [],
-    };
   },
 
   toJSON(message: DeleteCronRequest): unknown {
     const obj: any = {};
-    if (message.ids) {
+    if (message.ids?.length) {
-      obj.ids = message.ids.map((e) => e);
+      obj.ids = message.ids;
-    } else {
-      obj.ids = [];
     }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(
+  create<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(base?: I): DeleteCronRequest {
-    base?: I,
+    return DeleteCronRequest.fromPartial(base ?? ({} as any));
-  ): DeleteCronRequest {
-    return DeleteCronRequest.fromPartial(base ?? {});
   },
-
+  fromPartial<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(object: I): DeleteCronRequest {
-  fromPartial<I extends Exact<DeepPartial<DeleteCronRequest>, I>>(
-    object: I,
-  ): DeleteCronRequest {
     const message = createBaseDeleteCronRequest();
     message.ids = object.ids?.map((e) => e) || [];
     return message;
@@ -318,27 +394,23 @@ function createBaseDeleteCronResponse(): DeleteCronResponse {
   return {};
 }
 
-export const DeleteCronResponse = {
+export const DeleteCronResponse: MessageFns<DeleteCronResponse> = {
-  encode(
+  encode(_: DeleteCronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    _: DeleteCronResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): DeleteCronResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronResponse {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(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) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -352,15 +424,10 @@ export const DeleteCronResponse = {
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(
+  create<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(base?: I): DeleteCronResponse {
-    base?: I,
+    return DeleteCronResponse.fromPartial(base ?? ({} as any));
-  ): DeleteCronResponse {
-    return DeleteCronResponse.fromPartial(base ?? {});
   },
-
+  fromPartial<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(_: I): DeleteCronResponse {
-  fromPartial<I extends Exact<DeepPartial<DeleteCronResponse>, I>>(
-    _: I,
-  ): DeleteCronResponse {
     const message = createBaseDeleteCronResponse();
     return message;
   },
@@ -369,25 +436,21 @@ export const DeleteCronResponse = {
 export type CronService = typeof CronService;
 export const CronService = {
   addCron: {
-    path: '/com.ql.cron.Cron/addCron',
+    path: "/com.ql.cron.Cron/addCron",
     requestStream: false,
     responseStream: false,
-    requestSerialize: (value: AddCronRequest) =>
+    requestSerialize: (value: AddCronRequest) => Buffer.from(AddCronRequest.encode(value).finish()),
-      Buffer.from(AddCronRequest.encode(value).finish()),
     requestDeserialize: (value: Buffer) => AddCronRequest.decode(value),
-    responseSerialize: (value: AddCronResponse) =>
+    responseSerialize: (value: AddCronResponse) => Buffer.from(AddCronResponse.encode(value).finish()),
-      Buffer.from(AddCronResponse.encode(value).finish()),
     responseDeserialize: (value: Buffer) => AddCronResponse.decode(value),
   },
   delCron: {
-    path: '/com.ql.cron.Cron/delCron',
+    path: "/com.ql.cron.Cron/delCron",
     requestStream: false,
     responseStream: false,
-    requestSerialize: (value: DeleteCronRequest) =>
+    requestSerialize: (value: DeleteCronRequest) => Buffer.from(DeleteCronRequest.encode(value).finish()),
-      Buffer.from(DeleteCronRequest.encode(value).finish()),
     requestDeserialize: (value: Buffer) => DeleteCronRequest.decode(value),
-    responseSerialize: (value: DeleteCronResponse) =>
+    responseSerialize: (value: DeleteCronResponse) => Buffer.from(DeleteCronResponse.encode(value).finish()),
-      Buffer.from(DeleteCronResponse.encode(value).finish()),
     responseDeserialize: (value: Buffer) => DeleteCronResponse.decode(value),
   },
 } as const;
@@ -415,68 +478,48 @@ export interface CronClient extends Client {
   ): ClientUnaryCall;
   delCron(
     request: DeleteCronRequest,
-    callback: (
+    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
-      error: ServiceError | null,
-      response: DeleteCronResponse,
-    ) => void,
   ): ClientUnaryCall;
   delCron(
     request: DeleteCronRequest,
     metadata: Metadata,
-    callback: (
+    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
-      error: ServiceError | null,
-      response: DeleteCronResponse,
-    ) => void,
   ): ClientUnaryCall;
   delCron(
     request: DeleteCronRequest,
     metadata: Metadata,
     options: Partial<CallOptions>,
-    callback: (
+    callback: (error: ServiceError | null, response: DeleteCronResponse) => void,
-      error: ServiceError | null,
-      response: DeleteCronResponse,
-    ) => void,
   ): ClientUnaryCall;
 }
 
-export const CronClient = makeGenericClientConstructor(
+export const CronClient = makeGenericClientConstructor(CronService, "com.ql.cron.Cron") as unknown as {
-  CronService,
+  new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): CronClient;
-  'com.ql.cron.Cron',
-) as unknown as {
-  new (
-    address: string,
-    credentials: ChannelCredentials,
-    options?: Partial<ClientOptions>,
-  ): CronClient;
   service: typeof CronService;
+  serviceName: string;
 };
 
-type Builtin =
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined;
 
-export type DeepPartial<T> = T extends Builtin
+export type DeepPartial<T> = T extends Builtin ? T
-  ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
-  : T extends Array<infer U>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
-  ? Array<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : 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
+export type Exact<P, I extends P> = P extends Builtin ? P
-  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
-  : 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.ts

@@ -1,21 +1,27 @@
+// 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 {
-  CallOptions,
+  type CallOptions,
   ChannelCredentials,
   Client,
-  ClientOptions,
+  type ClientOptions,
-  ClientReadableStream,
+  type ClientReadableStream,
-  ClientUnaryCall,
+  type ClientUnaryCall,
-  handleServerStreamingCall,
+  type handleServerStreamingCall,
-  handleUnaryCall,
+  type handleUnaryCall,
   makeGenericClientConstructor,
   Metadata,
-  ServiceError,
+  type ServiceError,
-  UntypedServiceImplementation,
+  type UntypedServiceImplementation,
-} from '@grpc/grpc-js';
+} from "@grpc/grpc-js";
-import _m0 from 'protobufjs/minimal';
 
-export const protobufPackage = 'com.ql.health';
+export const protobufPackage = "com.ql.health";
 
 export interface HealthCheckRequest {
   service: string;
@@ -33,107 +39,97 @@ export enum HealthCheckResponse_ServingStatus {
   UNRECOGNIZED = -1,
 }
 
-export function healthCheckResponse_ServingStatusFromJSON(
+export function healthCheckResponse_ServingStatusFromJSON(object: any): HealthCheckResponse_ServingStatus {
-  object: any,
-): HealthCheckResponse_ServingStatus {
   switch (object) {
     case 0:
-    case 'UNKNOWN':
+    case "UNKNOWN":
       return HealthCheckResponse_ServingStatus.UNKNOWN;
     case 1:
-    case 'SERVING':
+    case "SERVING":
       return HealthCheckResponse_ServingStatus.SERVING;
     case 2:
-    case 'NOT_SERVING':
+    case "NOT_SERVING":
       return HealthCheckResponse_ServingStatus.NOT_SERVING;
     case 3:
-    case 'SERVICE_UNKNOWN':
+    case "SERVICE_UNKNOWN":
       return HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN;
     case -1:
-    case 'UNRECOGNIZED':
+    case "UNRECOGNIZED":
     default:
       return HealthCheckResponse_ServingStatus.UNRECOGNIZED;
   }
 }
 
-export function healthCheckResponse_ServingStatusToJSON(
+export function healthCheckResponse_ServingStatusToJSON(object: HealthCheckResponse_ServingStatus): string {
-  object: HealthCheckResponse_ServingStatus,
-): string {
   switch (object) {
     case HealthCheckResponse_ServingStatus.UNKNOWN:
-      return 'UNKNOWN';
+      return "UNKNOWN";
     case HealthCheckResponse_ServingStatus.SERVING:
-      return 'SERVING';
+      return "SERVING";
     case HealthCheckResponse_ServingStatus.NOT_SERVING:
-      return 'NOT_SERVING';
+      return "NOT_SERVING";
     case HealthCheckResponse_ServingStatus.SERVICE_UNKNOWN:
-      return 'SERVICE_UNKNOWN';
+      return "SERVICE_UNKNOWN";
     case HealthCheckResponse_ServingStatus.UNRECOGNIZED:
     default:
-      return 'UNRECOGNIZED';
+      return "UNRECOGNIZED";
   }
 }
 
 function createBaseHealthCheckRequest(): HealthCheckRequest {
-  return { service: '' };
+  return { service: "" };
 }
 
-export const HealthCheckRequest = {
+export const HealthCheckRequest: MessageFns<HealthCheckRequest> = {
-  encode(
+  encode(message: HealthCheckRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    message: HealthCheckRequest,
+    if (message.service !== "") {
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
-    if (message.service !== '') {
       writer.uint32(10).string(message.service);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HealthCheckRequest {
+  decode(input: BinaryReader | Uint8Array, length?: number): HealthCheckRequest {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+        case 1: {
-          if (tag != 10) {
+          if (tag !== 10) {
             break;
           }
 
           message.service = reader.string();
           continue;
+        }
       }
-      if ((tag & 7) == 4 || tag == 0) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
 
   fromJSON(object: any): HealthCheckRequest {
-    return { service: isSet(object.service) ? String(object.service) : '' };
+    return { service: isSet(object.service) ? globalThis.String(object.service) : "" };
   },
 
   toJSON(message: HealthCheckRequest): unknown {
     const obj: any = {};
-    message.service !== undefined && (obj.service = message.service);
+    if (message.service !== "") {
+      obj.service = message.service;
+    }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(
+  create<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(base?: I): HealthCheckRequest {
-    base?: I,
+    return HealthCheckRequest.fromPartial(base ?? ({} as any));
-  ): HealthCheckRequest {
-    return HealthCheckRequest.fromPartial(base ?? {});
   },
-
+  fromPartial<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(object: I): HealthCheckRequest {
-  fromPartial<I extends Exact<DeepPartial<HealthCheckRequest>, I>>(
-    object: I,
-  ): HealthCheckRequest {
     const message = createBaseHealthCheckRequest();
-    message.service = object.service ?? '';
+    message.service = object.service ?? "";
     return message;
   },
 };
@@ -142,65 +138,54 @@ function createBaseHealthCheckResponse(): HealthCheckResponse {
   return { status: 0 };
 }
 
-export const HealthCheckResponse = {
+export const HealthCheckResponse: MessageFns<HealthCheckResponse> = {
-  encode(
+  encode(message: HealthCheckResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
-    message: HealthCheckResponse,
-    writer: _m0.Writer = _m0.Writer.create(),
-  ): _m0.Writer {
     if (message.status !== 0) {
       writer.uint32(8).int32(message.status);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HealthCheckResponse {
+  decode(input: BinaryReader | Uint8Array, length?: number): HealthCheckResponse {
-    const reader =
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-      input instanceof _m0.Reader ? input : _m0.Reader.create(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:
+        case 1: {
-          if (tag != 8) {
+          if (tag !== 8) {
             break;
           }
 
           message.status = reader.int32() as any;
           continue;
+        }
       }
-      if ((tag & 7) == 4 || tag == 0) {
+      if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
 
   fromJSON(object: any): HealthCheckResponse {
-    return {
+    return { status: isSet(object.status) ? healthCheckResponse_ServingStatusFromJSON(object.status) : 0 };
-      status: isSet(object.status)
-        ? healthCheckResponse_ServingStatusFromJSON(object.status)
-        : 0,
-    };
   },
 
   toJSON(message: HealthCheckResponse): unknown {
     const obj: any = {};
-    message.status !== undefined &&
+    if (message.status !== 0) {
-      (obj.status = healthCheckResponse_ServingStatusToJSON(message.status));
+      obj.status = healthCheckResponse_ServingStatusToJSON(message.status);
+    }
     return obj;
   },
 
-  create<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(
+  create<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(base?: I): HealthCheckResponse {
-    base?: I,
+    return HealthCheckResponse.fromPartial(base ?? ({} as any));
-  ): HealthCheckResponse {
-    return HealthCheckResponse.fromPartial(base ?? {});
   },
-
+  fromPartial<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(object: I): HealthCheckResponse {
-  fromPartial<I extends Exact<DeepPartial<HealthCheckResponse>, I>>(
-    object: I,
-  ): HealthCheckResponse {
     const message = createBaseHealthCheckResponse();
     message.status = object.status ?? 0;
     return message;
@@ -210,25 +195,21 @@ export const HealthCheckResponse = {
 export type HealthService = typeof HealthService;
 export const HealthService = {
   check: {
-    path: '/com.ql.health.Health/Check',
+    path: "/com.ql.health.Health/Check",
     requestStream: false,
     responseStream: false,
-    requestSerialize: (value: HealthCheckRequest) =>
+    requestSerialize: (value: HealthCheckRequest) => Buffer.from(HealthCheckRequest.encode(value).finish()),
-      Buffer.from(HealthCheckRequest.encode(value).finish()),
     requestDeserialize: (value: Buffer) => HealthCheckRequest.decode(value),
-    responseSerialize: (value: HealthCheckResponse) =>
+    responseSerialize: (value: HealthCheckResponse) => Buffer.from(HealthCheckResponse.encode(value).finish()),
-      Buffer.from(HealthCheckResponse.encode(value).finish()),
     responseDeserialize: (value: Buffer) => HealthCheckResponse.decode(value),
   },
   watch: {
-    path: '/com.ql.health.Health/Watch',
+    path: "/com.ql.health.Health/Watch",
     requestStream: false,
     responseStream: true,
-    requestSerialize: (value: HealthCheckRequest) =>
+    requestSerialize: (value: HealthCheckRequest) => Buffer.from(HealthCheckRequest.encode(value).finish()),
-      Buffer.from(HealthCheckRequest.encode(value).finish()),
     requestDeserialize: (value: Buffer) => HealthCheckRequest.decode(value),
-    responseSerialize: (value: HealthCheckResponse) =>
+    responseSerialize: (value: HealthCheckResponse) => Buffer.from(HealthCheckResponse.encode(value).finish()),
-      Buffer.from(HealthCheckResponse.encode(value).finish()),
     responseDeserialize: (value: Buffer) => HealthCheckResponse.decode(value),
   },
 } as const;
@@ -241,32 +222,20 @@ export interface HealthServer extends UntypedServiceImplementation {
 export interface HealthClient extends Client {
   check(
     request: HealthCheckRequest,
-    callback: (
+    callback: (error: ServiceError | null, response: HealthCheckResponse) => void,
-      error: ServiceError | null,
-      response: HealthCheckResponse,
-    ) => void,
   ): ClientUnaryCall;
   check(
     request: HealthCheckRequest,
     metadata: Metadata,
-    callback: (
+    callback: (error: ServiceError | null, response: HealthCheckResponse) => void,
-      error: ServiceError | null,
-      response: HealthCheckResponse,
-    ) => void,
   ): ClientUnaryCall;
   check(
     request: HealthCheckRequest,
     metadata: Metadata,
     options: Partial<CallOptions>,
-    callback: (
+    callback: (error: ServiceError | null, response: HealthCheckResponse) => void,
-      error: ServiceError | null,
-      response: HealthCheckResponse,
-    ) => void,
   ): ClientUnaryCall;
-  watch(
+  watch(request: HealthCheckRequest, options?: Partial<CallOptions>): ClientReadableStream<HealthCheckResponse>;
-    request: HealthCheckRequest,
-    options?: Partial<CallOptions>,
-  ): ClientReadableStream<HealthCheckResponse>;
   watch(
     request: HealthCheckRequest,
     metadata?: Metadata,
@@ -274,44 +243,33 @@ export interface HealthClient extends Client {
   ): ClientReadableStream<HealthCheckResponse>;
 }
 
-export const HealthClient = makeGenericClientConstructor(
+export const HealthClient = makeGenericClientConstructor(HealthService, "com.ql.health.Health") as unknown as {
-  HealthService,
+  new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): HealthClient;
-  'com.ql.health.Health',
-) as unknown as {
-  new (
-    address: string,
-    credentials: ChannelCredentials,
-    options?: Partial<ClientOptions>,
-  ): HealthClient;
   service: typeof HealthService;
+  serviceName: string;
 };
 
-type Builtin =
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
-  | Date
-  | Function
-  | Uint8Array
-  | string
-  | number
-  | boolean
-  | undefined;
 
-export type DeepPartial<T> = T extends Builtin
+export type DeepPartial<T> = T extends Builtin ? T
-  ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
-  : T extends Array<infer U>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
-  ? Array<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
-  : 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
+export type Exact<P, I extends P> = P extends Builtin ? P
-  ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
-  : 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/public.ts

@@ -1,35 +0,0 @@
-import express from 'express';
-import Logger from './loaders/logger';
-import config from './config';
-import { HealthClient } from './protos/health';
-import { credentials } from '@grpc/grpc-js';
-
-const app = express();
-const client = new HealthClient(
-  `0.0.0.0:${config.cronPort}`,
-  credentials.createInsecure(),
-);
-
-app.get('/api/health', (req, res) => {
-  client.check({ service: 'cron' }, (err, response) => {
-    if (err) {
-      return res.status(200).send({ code: 500, error: err });
-    }
-    return res.status(200).send({ code: 200, data: response });
-  });
-});
-
-app
-  .listen(config.publicPort, async () => {
-    await require('./loaders/sentry').default({ expressApp: app });
-    await require('./loaders/db').default();
-
-    Logger.debug(`✌️ 公共服务启动成功！`);
-    console.debug(`✌️ 公共服务启动成功！`);
-    process.send?.('ready');
-  })
-  .on('error', (err) => {
-    Logger.error(err);
-    console.error(err);
-    process.exit(1);
-  });

back/schedule/addCron.ts

@@ -3,41 +3,52 @@ import { AddCronRequest, AddCronResponse } from '../protos/cron';
 import nodeSchedule from 'node-schedule';
 import { scheduleStacks } from './data';
 import { runCron } from '../shared/runCron';
-import { QL_PREFIX, TASK_PREFIX } from '../config/const';
 import Logger from '../loaders/logger';
-import dayjs from 'dayjs';
 
 const addCron = (
   call: ServerUnaryCall<AddCronRequest, AddCronResponse>,
   callback: sendUnaryData<AddCronResponse>,
 ) => {
   for (const item of call.request.crons) {
-    const { id, schedule, command } = item;
+    const { id, schedule, command, extra_schedules, name } = item;
     if (scheduleStacks.has(id)) {
-      scheduleStacks.get(id)?.cancel();
+      scheduleStacks.get(id)?.forEach((x) => x.cancel());
-    }
-
-    let cmdStr = command.trim();
-    if (!cmdStr.startsWith(TASK_PREFIX) && !cmdStr.startsWith(QL_PREFIX)) {
-      cmdStr = `${TASK_PREFIX}${cmdStr}`;
     }
 
     Logger.info(
-      '[schedule][创建定时任务], 任务ID: %s, cron: %s, 执行命令: %s',
+      '[schedule][创建定时任务], 任务ID: %s, 名称: %s, cron: %s, 执行命令: %s',
       id,
+      name,
       schedule,
       command,
     );
 
-    scheduleStacks.set(
+    if (extra_schedules?.length) {
-      id,
+      extra_schedules.forEach((x) => {
-      nodeSchedule.scheduleJob(id, schedule, async () => {
         Logger.info(
-          `[schedule][准备运行任务] 命令: ${cmdStr}`,
+          '[schedule][创建定时任务], 任务ID: %s, 名称: %s, cron: %s, 执行命令: %s',
+          id,
+          name,
+          x.schedule,
+          command,
         );
-        runCron(`ID=${id} ${cmdStr}`);
+      });
+    }
+
+    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);

back/schedule/api.ts

@@ -0,0 +1,320 @@
+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';
+
+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(call.request);
+    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

@@ -10,8 +10,9 @@ import config from '../config';
 
 class Client {
   private client = new CronClient(
-    `0.0.0.0:${config.cronPort}`,
+    `0.0.0.0:${config.grpcPort}`,
     credentials.createInsecure(),
+    { 'grpc.enable_http_proxy': 0 },
   );
 
   addCron(request: AddCronRequest['crons']): Promise<AddCronResponse> {

back/schedule/data.ts

@@ -1,6 +1,6 @@
 import nodeSchedule from 'node-schedule';
 import { ToadScheduler } from 'toad-scheduler';
 
-export const scheduleStacks = new Map<string, nodeSchedule.Job>();
+export const scheduleStacks = new Map<string, nodeSchedule.Job[]>();
 
 export const intervalSchedule = new ToadScheduler();

back/schedule/delCron.ts

@@ -13,7 +13,7 @@ const delCron = (
         '[schedule][取消定时任务], 任务ID: %s',
         id,
       );
-      scheduleStacks.get(id)?.cancel();
+      scheduleStacks.get(id)?.forEach(x => x.cancel());
       scheduleStacks.delete(id);
     }
   }

back/schedule/health.ts

@@ -10,7 +10,7 @@ const check = async (
   switch (call.request.service) {
     case 'cron':
       const res = await promiseExec(
-        `curl -s http://0.0.0.0:${config.port}/api/system`,
+        `curl -s --noproxy '*' http://0.0.0.0:${config.port}/api/system`,
       );
 
       if (res.includes('200')) {

back/schedule/index.ts

@@ -1,25 +0,0 @@
-import { Server, ServerCredentials } from '@grpc/grpc-js';
-import { CronService } from '../protos/cron';
-import { addCron } from './addCron';
-import { delCron } from './delCron';
-import { HealthService } from '../protos/health';
-import { check } from './health';
-import config from '../config';
-import Logger from '../loaders/logger';
-
-const server = new Server();
-server.addService(HealthService, { check });
-server.addService(CronService, { addCron, delCron });
-server.bindAsync(
-  `0.0.0.0:${config.cronPort}`,
-  ServerCredentials.createInsecure(),
-  (err, port) => {
-    if (err) {
-      throw err;
-    }
-    server.start();
-    Logger.debug(`✌️ 定时服务启动成功！`);
-    console.debug(`✌️ 定时服务启动成功！`);
-    process.send?.('ready');
-  },
-);

back/services/config.ts

@@ -0,0 +1,42 @@
+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/cron.ts

@@ -3,40 +3,74 @@ import winston from 'winston';
 import config from '../config';
 import { Crontab, CrontabModel, CrontabStatus } from '../data/cron';
 import { exec, execSync } from 'child_process';
-import fs from 'fs';
+import fs from 'fs/promises';
 import cron_parser from 'cron-parser';
-import { getFileContentByName, fileExist, killTask, getUniqPath, safeJSONParse } from '../config/util';
+import {
-import { promises, existsSync } from 'fs';
+  getFileContentByName,
-import { Op, where, col as colFn, FindOptions, fn } from 'sequelize';
+  fileExist,
+  killTask,
+  getUniqPath,
+  safeJSONParse,
+  isDemoEnv,
+} from '../config/util';
+import { Op, where, col as colFn, FindOptions, fn, Order } from 'sequelize';
 import path from 'path';
 import { TASK_PREFIX, QL_PREFIX } from '../config/const';
 import cronClient from '../schedule/client';
 import taskLimit from '../shared/pLimit';
 import { spawn } from 'cross-spawn';
 import dayjs from 'dayjs';
+import pickBy from 'lodash/pickBy';
+import omit from 'lodash/omit';
+import { writeFileWithLock } from '../shared/utils';
+import { ScheduleType } from '../interface/schedule';
 
 @Service()
 export default class CronService {
-  constructor(@Inject('logger') private logger: winston.Logger) { }
+  constructor(@Inject('logger') private logger: winston.Logger) {}
 
-  private isSixCron(cron: Crontab) {
+  private isNodeCron(cron: Crontab) {
-    const { schedule } = cron;
+    const { schedule, extra_schedules } = cron;
-    if (Number(schedule?.split(/ +/).length) > 5) {
+    if (Number(schedule?.split(/ +/).length) > 5 || extra_schedules?.length) {
       return true;
     }
     return false;
   }
 
+  private isOnceSchedule(schedule?: string) {
+    return schedule?.startsWith(ScheduleType.ONCE);
+  }
+
+  private isBootSchedule(schedule?: string) {
+    return schedule?.startsWith(ScheduleType.BOOT);
+  }
+
+  private isSpecialSchedule(schedule?: string) {
+    return this.isOnceSchedule(schedule) || this.isBootSchedule(schedule);
+  }
+
   public async create(payload: Crontab): Promise<Crontab> {
     const tab = new Crontab(payload);
     tab.saved = false;
     const doc = await this.insert(tab);
-    if (this.isSixCron(doc)) {
+
+    if (isDemoEnv()) {
+      return doc;
+    }
+
+    if (this.isNodeCron(doc) && !this.isSpecialSchedule(doc.schedule)) {
       await cronClient.addCron([
-        { id: String(doc.id), schedule: doc.schedule!, command: doc.command },
+        {
+          name: doc.name || '',
+          id: String(doc.id),
+          schedule: doc.schedule!,
+          command: this.makeCommand(doc),
+          extra_schedules: doc.extra_schedules || [],
+        },
       ]);
     }
-    await this.set_crontab();
+
+    await this.setCrontab();
     return doc;
   }
 
@@ -44,27 +78,33 @@ export default class CronService {
     return await CrontabModel.create(payload, { returning: true });
   }
 
-  public async update(payload: Crontab): Promise<Crontab> {
+  public async update(payload: Partial<Crontab>): Promise<Crontab> {
     const doc = await this.getDb({ id: payload.id });
     const tab = new Crontab({ ...doc, ...payload });
     tab.saved = false;
     const newDoc = await this.updateDb(tab);
-    if (doc.isDisabled === 1) {
+
+    if (doc.isDisabled === 1 || isDemoEnv()) {
       return newDoc;
     }
-    if (this.isSixCron(doc)) {
+
-      await cronClient.delCron([String(newDoc.id)]);
+    if (this.isNodeCron(doc)) {
+      await cronClient.delCron([String(doc.id)]);
     }
-    if (this.isSixCron(newDoc)) {
+
+    if (this.isNodeCron(newDoc) && !this.isSpecialSchedule(newDoc.schedule)) {
       await cronClient.addCron([
         {
+          name: doc.name || '',
           id: String(newDoc.id),
           schedule: newDoc.schedule!,
-          command: newDoc.command,
+          command: this.makeCommand(newDoc),
+          extra_schedules: newDoc.extra_schedules || [],
         },
       ]);
     }
-    await this.set_crontab();
+
+    await this.setCrontab();
     return newDoc;
   }
 
@@ -88,7 +128,7 @@ export default class CronService {
     last_running_time: number;
     last_execution_time: number;
   }) {
-    const options: any = {
+    let options: any = {
       status,
       pid,
       log_path,
@@ -98,13 +138,28 @@ export default class CronService {
       options.last_running_time = last_running_time;
     }
 
-    return await CrontabModel.update({ ...options }, { where: { id: ids } });
+    for (const id of ids) {
+      let cron;
+      try {
+        cron = await this.getDb({ id });
+      } catch (err) {}
+      if (!cron) {
+        continue;
+      }
+      if (status === CrontabStatus.idle && log_path !== cron.log_path) {
+        options = omit(options, ['status', 'log_path', 'pid']);
+      }
+      await CrontabModel.update(
+        { ...pickBy(options, (v) => v === 0 || !!v) },
+        { where: { id } },
+      );
+    }
   }
 
   public async remove(ids: number[]) {
     await CrontabModel.destroy({ where: { id: ids } });
     await cronClient.delCron(ids.map(String));
-    await this.set_crontab();
+    await this.setCrontab();
   }
 
   public async pin(ids: number[]) {
@@ -148,8 +203,8 @@ export default class CronService {
       for (const col of viewQuery.filters) {
         const { property, value, operation } = col;
         let q: any = {};
-        let operate2 = null;
+        let operate2: any = null;
-        let operate = null;
+        let operate: any = null;
         switch (operation) {
           case 'Reg':
             operate = Op.like;
@@ -160,21 +215,38 @@ export default class CronService {
             operate2 = Op.and;
             break;
           case 'In':
-            q[Op.or] = [
+            if (
-              {
+              property === 'status' &&
-                [property]: Array.isArray(value) ? value : [value],
+              !value.includes(CrontabStatus.disabled)
-              },
+            ) {
-              property === 'status' && value.includes(2)
+              q[Op.and] = [
-                ? { isDisabled: 1 }
+                { [property]: Array.isArray(value) ? value : [value] },
-                : {},
+                { isDisabled: 0 },
-            ];
+              ];
+            } else {
+              q[Op.or] = [
+                {
+                  [property]: Array.isArray(value) ? value : [value],
+                },
+                property === 'status' && value.includes(CrontabStatus.disabled)
+                  ? { isDisabled: 1 }
+                  : {},
+              ];
+            }
             break;
           case 'Nin':
             q[Op.and] = [
               {
-                [property]: {
+                [Op.or]: [
-                  [Op.notIn]: Array.isArray(value) ? value : [value],
+                  {
-                },
+                    [property]: {
+                      [Op.notIn]: Array.isArray(value) ? value : [value],
+                    },
+                  },
+                  {
+                    [property]: { [Op.is]: null },
+                  },
+                ],
               },
               property === 'status' && value.includes(2)
                 ? { isDisabled: { [Op.ne]: 1 } }
@@ -289,10 +361,10 @@ export default class CronService {
     log_path,
   }: {
     log_path: string;
-  }): Promise<Crontab | null> {
+  }): Promise<Crontab | undefined> {
     try {
       const result = await CrontabModel.findOne({ where: { log_path } });
-      return result;
+      return result?.get({ plain: true });
     } catch (error) {
       throw error;
     }
@@ -332,9 +404,9 @@ export default class CronService {
         order.unshift([field, type]);
       }
     }
-    let condition: any = {
+    let condition: FindOptions<Crontab> = {
       where: query,
-      order: order,
+      order: order as Order,
     };
     if (page && size) {
       condition.offset = (page - 1) * size;
@@ -343,7 +415,7 @@ export default class CronService {
     try {
       const result = await CrontabModel.findAll(condition);
       const count = await CrontabModel.count({ where: query });
-      return { data: result, total: count };
+      return { data: result.map((x) => x.get({ plain: true })), total: count };
     } catch (error) {
       throw error;
     }
@@ -351,7 +423,10 @@ export default class CronService {
 
   public async getDb(query: FindOptions<Crontab>['where']): Promise<Crontab> {
     const doc: any = await CrontabModel.findOne({ where: { ...query } });
-    return doc && (doc.get({ plain: true }) as Crontab);
+    if (!doc) {
+      throw new Error(`Cron ${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
   public async run(ids: number[]) {
@@ -382,67 +457,77 @@ export default class CronService {
     );
   }
 
-  private async runSingle(cronId: number): Promise<number> {
+  private async runSingle(cronId: number): Promise<number | void> {
-    return taskLimit.runWithCpuLimit(() => {
+    return taskLimit.manualRunWithCronLimit(() => {
       return new Promise(async (resolve: any) => {
         const cron = await this.getDb({ id: cronId });
+        const params = {
+          name: cron.name,
+          command: cron.command,
+          schedule: cron.schedule,
+          extra_schedules: cron.extra_schedules,
+        };
         if (cron.status !== CrontabStatus.queued) {
-          resolve();
+          resolve(params);
           return;
         }
 
+        this.logger.info(
+          `[panel][开始执行任务] 参数: ${JSON.stringify(params)}`,
+        );
+
         let { id, command, log_path } = cron;
         const uniqPath = await getUniqPath(command, `${id}`);
         const logTime = dayjs().format('YYYY-MM-DD-HH-mm-ss-SSS');
         const logDirPath = path.resolve(config.logPath, `${uniqPath}`);
-        if (log_path?.split('/')?.every(x => x !== uniqPath)) {
+        if (log_path?.split('/')?.every((x) => x !== uniqPath)) {
-          fs.mkdirSync(logDirPath, { recursive: true });
+          await fs.mkdir(logDirPath, { recursive: true });
         }
         const logPath = `${uniqPath}/${logTime}.log`;
         const absolutePath = path.resolve(config.logPath, `${logPath}`);
-
+        const cp = spawn(
-        this.logger.silly('Running job');
+          `real_log_path=${logPath} no_delay=true ${this.makeCommand(
-        this.logger.silly('ID: ' + id);
+            cron,
-        this.logger.silly('Original command: ' + command);
+            true,
-
+          )}`,
-        let cmdStr = command;
+          { shell: '/bin/bash' },
-        if (!cmdStr.startsWith(TASK_PREFIX) && !cmdStr.startsWith(QL_PREFIX)) {
+        );
-          cmdStr = `${TASK_PREFIX}${cmdStr}`;
-        }
-        if (
-          cmdStr.endsWith('.js') ||
-          cmdStr.endsWith('.py') ||
-          cmdStr.endsWith('.pyc') ||
-          cmdStr.endsWith('.sh') ||
-          cmdStr.endsWith('.ts')
-        ) {
-          cmdStr = `${cmdStr} now`;
-        }
-
-        const cp = spawn(`real_log_path=${logPath} ID=${id} ${cmdStr}`, { shell: '/bin/bash' });
 
         await CrontabModel.update(
           { status: CrontabStatus.running, pid: cp.pid, log_path: logPath },
           { where: { id } },
         );
-        cp.stderr.on('data', (data) => {
+        cp.stdout.on('data', async (data) => {
-          fs.appendFileSync(`${absolutePath}`, `${data.toString()}`);
+          await fs.appendFile(absolutePath, data.toString());
         });
-        cp.on('error', (err) => {
+        cp.stderr.on('data', async (data) => {
-          fs.appendFileSync(`${absolutePath}`, `${JSON.stringify(err)}`);
+          this.logger.info(
+            '[panel][执行任务失败] 命令: %s, 错误信息: %j',
+            command,
+            data.toString(),
+          );
+          await fs.appendFile(absolutePath, data.toString());
+        });
+        cp.on('error', async (err) => {
+          this.logger.error(
+            '[panel][创建任务失败] 命令: %s, 错误信息: %j',
+            command,
+            err,
+          );
+          await fs.appendFile(absolutePath, JSON.stringify(err));
         });
 
-        cp.on('exit', async (code, signal) => {
+        cp.on('exit', async (code) => {
           this.logger.info(
-            `[panel][任务退出] 任务 ${command} 进程id: ${cp.pid}, 退出码 ${code}`,
+            '[panel][执行任务结束] 参数: %s, 退出码: %j',
+            JSON.stringify(params),
+            code,
           );
-        });
-        cp.on('close', async (code) => {
           await CrontabModel.update(
             { status: CrontabStatus.idle, pid: undefined },
             { where: { id } },
           );
-          resolve();
+          resolve({ ...params, pid: cp.pid, code });
         });
       });
     });
@@ -451,21 +536,27 @@ export default class CronService {
   public async disabled(ids: number[]) {
     await CrontabModel.update({ isDisabled: 1 }, { where: { id: ids } });
     await cronClient.delCron(ids.map(String));
-    await this.set_crontab();
+    await this.setCrontab();
   }
 
   public async enabled(ids: number[]) {
     await CrontabModel.update({ isDisabled: 0 }, { where: { id: ids } });
     const docs = await CrontabModel.findAll({ where: { id: ids } });
     const sixCron = docs
-      .filter((x) => this.isSixCron(x))
+      .filter((x) => this.isNodeCron(x) && !this.isSpecialSchedule(x.schedule))
       .map((doc) => ({
+        name: doc.name || '',
         id: String(doc.id),
         schedule: doc.schedule!,
-        command: doc.command,
+        command: this.makeCommand(doc),
+        extra_schedules: doc.extra_schedules || [],
       }));
+
+    if (isDemoEnv()) {
+      return;
+    }
     await cronClient.addCron(sixCron);
-    await this.set_crontab();
+    await this.setCrontab();
   }
 
   public async log(id: number) {
@@ -477,9 +568,12 @@ export default class CronService {
     const absolutePath = path.resolve(config.logPath, `${doc.log_path}`);
     const logFileExist = doc.log_path && (await fileExist(absolutePath));
     if (logFileExist) {
-      return getFileContentByName(`${absolutePath}`);
+      return await getFileContentByName(`${absolutePath}`);
     } else {
-      return '任务未运行';
+      return typeof doc.status === 'number' &&
+        [CrontabStatus.queued, CrontabStatus.running].includes(doc.status)
+        ? '运行中...'
+        : '任务空闲中';
     }
   }
 
@@ -491,55 +585,77 @@ export default class CronService {
 
     const relativeDir = path.dirname(`${doc.log_path}`);
     const dir = path.resolve(config.logPath, relativeDir);
-    if (existsSync(dir)) {
+    const dirExist = await fileExist(dir);
-      let files = await promises.readdir(dir);
+    if (dirExist) {
-      return files
+      let files = await fs.readdir(dir);
-        .map((x) => ({
+      return (
-          filename: x,
+        await Promise.all(
-          directory: relativeDir.replace(config.logPath, ''),
+          files.map(async (x) => ({
-          time: fs.statSync(`${dir}/${x}`).mtime.getTime(),
+            filename: x,
-        }))
+            directory: relativeDir.replace(config.logPath, ''),
-        .sort((a, b) => b.time - a.time);
+            time: (await fs.lstat(`${dir}/${x}`)).mtime.getTime(),
+          })),
+        )
+      ).sort((a, b) => b.time - a.time);
     } else {
       return [];
     }
   }
 
-  private make_command(tab: Crontab) {
+  private makeCommand(tab: Crontab, realTime?: boolean) {
     let command = tab.command.trim();
     if (!command.startsWith(TASK_PREFIX) && !command.startsWith(QL_PREFIX)) {
       command = `${TASK_PREFIX}${tab.command}`;
     }
-    const crontab_job_string = `ID=${tab.id} ${command}`;
+    let commandVariable = `real_time=${Boolean(realTime)} no_tee=true ID=${
+      tab.id
+    } `;
+    if (tab.task_before) {
+      commandVariable += `task_before='${tab.task_before
+        .replace(/'/g, "'\\''")
+        .replace(/;? *\n/g, ';')
+        .trim()}' `;
+    }
+    if (tab.task_after) {
+      commandVariable += `task_after='${tab.task_after
+        .replace(/'/g, "'\\''")
+        .replace(/;? *\n/g, ';')
+        .trim()}' `;
+    }
+
+    const crontab_job_string = `${commandVariable}${command}`;
     return crontab_job_string;
   }
 
-  private async set_crontab(data?: { data: Crontab[]; total: number }) {
+  private async setCrontab(data?: { data: Crontab[]; total: number }) {
     const tabs = data ?? (await this.crontabs());
     var crontab_string = '';
     tabs.data.forEach((tab) => {
-      const _schedule = tab.schedule && tab.schedule.split(/ +/);
+      if (
-      if (tab.isDisabled === 1 || _schedule!.length !== 5) {
+        tab.isDisabled === 1 ||
+        this.isNodeCron(tab) ||
+        this.isSpecialSchedule(tab.schedule)
+      ) {
         crontab_string += '# ';
         crontab_string += tab.schedule;
         crontab_string += ' ';
-        crontab_string += this.make_command(tab);
+        crontab_string += this.makeCommand(tab);
         crontab_string += '\n';
       } else {
         crontab_string += tab.schedule;
         crontab_string += ' ';
-        crontab_string += this.make_command(tab);
+        crontab_string += this.makeCommand(tab);
         crontab_string += '\n';
       }
     });
 
-    fs.writeFileSync(config.crontabFile, crontab_string);
+    await writeFileWithLock(config.crontabFile, crontab_string);
 
     execSync(`crontab ${config.crontabFile}`);
     await CrontabModel.update({ saved: true }, { where: {} });
   }
 
-  public import_crontab() {
+  public importCrontab() {
     exec('crontab -l', (error, stdout, stderr) => {
       const lines = stdout.split('\n');
       const namePrefix = new Date().getTime();
@@ -575,15 +691,42 @@ export default class CronService {
 
   public async autosave_crontab() {
     const tabs = await this.crontabs();
-    this.set_crontab(tabs);
+    const regularCrons = tabs.data
-
+      .filter(
-    const sixCron = tabs.data
+        (x) =>
-      .filter((x) => this.isSixCron(x) && x.isDisabled !== 1)
+          x.isDisabled !== 1 &&
+          this.isNodeCron(x) &&
+          !this.isSpecialSchedule(x.schedule),
+      )
       .map((doc) => ({
+        name: doc.name || '',
         id: String(doc.id),
         schedule: doc.schedule!,
-        command: doc.command,
+        command: this.makeCommand(doc),
+        extra_schedules: doc.extra_schedules || [],
       }));
-    await cronClient.addCron(sixCron);
+
+    if (isDemoEnv()) {
+      await writeFileWithLock(config.crontabFile, '');
+      return;
+    }
+    await cronClient.addCron(regularCrons);
+    this.setCrontab(tabs);
+  }
+
+  public async bootTask() {
+    const tabs = await this.crontabs();
+    const bootTasks = tabs.data.filter(
+      (x) => !x.isDisabled && this.isBootSchedule(x.schedule),
+    );
+    if (bootTasks.length > 0) {
+      await CrontabModel.update(
+        { status: CrontabStatus.queued },
+        { where: { id: bootTasks.map((t) => t.id!) } },
+      );
+      for (const task of bootTasks) {
+        await this.runSingle(task.id!);
+      }
+    }
   }
 }

back/services/cronView.ts

@@ -63,7 +63,10 @@ export default class CronViewService {
     query: FindOptions<CrontabView>['where'],
   ): Promise<CrontabView> {
     const doc: any = await CrontabViewModel.findOne({ where: { ...query } });
-    return doc && (doc.get({ plain: true }) as CrontabView);
+    if (!doc) {
+      throw new Error(`CronView ${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
   public async disabled(ids: number[]) {

back/services/dependence.ts

@@ -3,18 +3,23 @@ import winston from 'winston';
 import config from '../config';
 import {
   Dependence,
-  InstallDependenceCommandTypes,
   DependenceStatus,
   DependenceTypes,
-  unInstallDependenceCommandTypes,
   DependenceModel,
-  GetDependenceCommandTypes,
   versionDependenceCommandTypes,
 } from '../data/dependence';
 import { spawn } from 'cross-spawn';
 import SockService from './sock';
 import { FindOptions, Op } from 'sequelize';
-import { promiseExecSuccess } from '../config/util';
+import {
+  fileExist,
+  getPid,
+  killTask,
+  promiseExecSuccess,
+  getInstallCommand,
+  getUninstallCommand,
+  getGetCommand,
+} from '../config/util';
 import dayjs from 'dayjs';
 import taskLimit from '../shared/pLimit';
 
@@ -61,12 +66,26 @@ export default class DependenceService {
   }
 
   public async remove(ids: number[], force = false): Promise<Dependence[]> {
-    await DependenceModel.update(
-      { status: DependenceStatus.queued, log: [] },
-      { where: { id: ids } },
-    );
     const docs = await DependenceModel.findAll({ where: { id: ids } });
-    this.installDependenceOneByOne(docs, false, force);
+    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;
   }
 
@@ -75,11 +94,21 @@ export default class DependenceService {
   }
 
   public async dependencies(
-    { searchValue, type }: { searchValue: string; type: string },
+    {
-    sort: any = { position: -1 },
+      searchValue,
+      type,
+      status,
+    }: { searchValue: string; type: string; status: string },
+    sort: any = [],
     query: any = {},
   ): Promise<Dependence[]> {
-    let condition = { ...query, type: DependenceTypes[type as any] };
+    let condition = {
+      ...query,
+      type: DependenceTypes[type as any],
+    };
+    if (status) {
+      condition.status = status.split(',').map(Number);
+    }
     if (searchValue) {
       const encodeText = encodeURI(searchValue);
       const reg = {
@@ -95,7 +124,7 @@ export default class DependenceService {
       };
     }
     try {
-      const result = await this.find(condition);
+      const result = await this.find(condition, sort);
       return result as any;
     } catch (error) {
       throw error;
@@ -106,10 +135,12 @@ export default class DependenceService {
     docs: 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[]> {
@@ -119,10 +150,35 @@ export default class DependenceService {
     );
 
     const docs = await DependenceModel.findAll({ where: { id: ids } });
-    this.installDependenceOneByOne(docs);
+    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 installCmd = `${depInstallCommand} ${doc.name.trim()}`;
+      const unInstallCmd = `${depUnInstallCommand} ${doc.name.trim()}`;
+      const pids = await Promise.all([
+        getPid(installCmd),
+        getPid(unInstallCmd),
+      ]);
+      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 },
@@ -135,7 +191,10 @@ export default class DependenceService {
     query: FindOptions<Dependence>['where'],
   ): Promise<Dependence> {
     const doc: any = await DependenceModel.findOne({ where: { ...query } });
-    return doc && (doc.get({ plain: true }) as Dependence);
+    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> {
@@ -157,8 +216,14 @@ export default class DependenceService {
     isInstall: boolean = true,
     force: boolean = false,
   ) {
-    return taskLimit.runOneByOne(() => {
+    return taskLimit.runDependeny(dependency, () => {
       return new Promise(async (resolve) => {
+        if (taskLimit.firstDependencyId !== dependency.id) {
+          return resolve(null);
+        }
+
+        taskLimit.removeQueuedDependency(dependency);
+
         const depIds = [dependency.id!];
         const status = isInstall
           ? DependenceStatus.installing
@@ -169,11 +234,9 @@ export default class DependenceService {
           ? 'installDependence'
           : 'uninstallDependence';
         let depName = dependency.name.trim();
-        const depRunCommand = (
+        const command = isInstall
-          isInstall
+          ? getInstallCommand(dependency.type, depName)
-            ? InstallDependenceCommandTypes
+          : getUninstallCommand(dependency.type, depName);
-            : unInstallDependenceCommandTypes
-        )[dependency.type];
         const actionText = isInstall ? '安装' : '删除';
         const startTime = dayjs();
 
@@ -188,8 +251,8 @@ export default class DependenceService {
         this.updateLog(depIds, message);
 
         // 判断是否已经安装过依赖
-        if (isInstall) {
+        if (isInstall && !force) {
-          const getCommandPrefix = GetDependenceCommandTypes[dependency.type];
+          const getCommand = getGetCommand(dependency.type, depName);
           const depVersionStr = versionDependenceCommandTypes[dependency.type];
           let depVersion = '';
           if (depName.includes(depVersionStr)) {
@@ -206,13 +269,7 @@ export default class DependenceService {
           const isLinuxDependence = dependency.type === DependenceTypes.linux;
           const isPythonDependence =
             dependency.type === DependenceTypes.python3;
-          const depInfo = (
+          const depInfo = (await promiseExecSuccess(getCommand))
-            await promiseExecSuccess(
-              isNodeDependence
-                ? `${getCommandPrefix} | grep "${depName}" | head -1`
-                : `${getCommandPrefix} ${depName}`,
-            )
-          )
             .replace(/\s{2,}/, ' ')
             .replace(/\s+$/, '');
 
@@ -241,8 +298,13 @@ export default class DependenceService {
             return resolve(null);
           }
         }
-
+        const dependenceProxyFileExist = await fileExist(
-        const cp = spawn(`${depRunCommand} ${dependency.name.trim()}`, {
+          config.dependenceProxyFile,
+        );
+        const proxyStr = dependenceProxyFileExist
+          ? `source ${config.dependenceProxyFile} &&`
+          : '';
+        const cp = spawn(`${proxyStr} ${command}`, {
           shell: '/bin/bash',
         });
 
@@ -273,7 +335,7 @@ export default class DependenceService {
           this.updateLog(depIds, JSON.stringify(err));
         });
 
-        cp.on('close', async (code) => {
+        cp.on('exit', async (code) => {
           const endTime = dayjs();
           const isSucceed = code === 0;
           const resultText = isSucceed ? '成功' : '失败';
@@ -288,7 +350,7 @@ export default class DependenceService {
           });
           this.updateLog(depIds, message);
 
-          let status = null;
+          let status: number;
           if (isSucceed) {
             status = isInstall
               ? DependenceStatus.installed
@@ -298,7 +360,17 @@ export default class DependenceService {
               ? DependenceStatus.installFailed
               : DependenceStatus.removeFailed;
           }
-          await DependenceModel.update({ status }, { where: { id: depIds } });
+          const docs = await DependenceModel.findAll({ where: { id: depIds } });
+          const _docIds = docs
+            .filter((x) => x.status !== DependenceStatus.cancelled)
+            .map((x) => x.id!);
+
+          if (_docIds.length > 0) {
+            await DependenceModel.update(
+              { status },
+              { where: { id: _docIds } },
+            );
+          }
 
           // 如果删除依赖成功或者强制删除
           if ((isSucceed || force) && !isInstall) {

back/services/env.ts

@@ -1,7 +1,7 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import config from '../config';
-import * as fs from 'fs';
+import * as fs from 'fs/promises';
 import {
   Env,
   EnvModel,
@@ -13,6 +13,7 @@ import {
 } from '../data/env';
 import groupBy from 'lodash/groupBy';
 import { FindOptions, Op } from 'sequelize';
+import { writeFileWithLock } from '../shared/utils';
 
 @Service()
 export default class EnvService {
@@ -40,7 +41,7 @@ export default class EnvService {
   }
 
   public async insert(payloads: Env[]): Promise<Env[]> {
-    const result = [];
+    const result: Env[] = [];
     for (const env of payloads) {
       const doc = await EnvModel.create(env, { returning: true });
       result.push(doc);
@@ -61,7 +62,7 @@ export default class EnvService {
     return await this.getDb({ id: payload.id });
   }
 
-  public async remove(ids: string[]) {
+  public async remove(ids: number[]) {
     await EnvModel.destroy({ where: { id: ids } });
     await this.set_envs();
   }
@@ -149,7 +150,7 @@ export default class EnvService {
         ['position', 'DESC'],
         ['createdAt', 'ASC'],
       ]);
-      return result as any;
+      return result;
     } catch (error) {
       throw error;
     }
@@ -160,15 +161,18 @@ export default class EnvService {
       where: { ...query },
       order: [...sort],
     });
-    return 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 } });
-    return doc && (doc.get({ plain: true }) as Env);
+    if (!doc) {
+      throw new Error(`Env ${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
-  public async disabled(ids: string[]) {
+  public async disabled(ids: number[]) {
     await EnvModel.update(
       { status: EnvStatus.disabled },
       { where: { id: ids } },
@@ -176,12 +180,12 @@ export default class EnvService {
     await this.set_envs();
   }
 
-  public async enabled(ids: string[]) {
+  public async enabled(ids: number[]) {
     await EnvModel.update({ status: EnvStatus.normal }, { where: { id: ids } });
     await this.set_envs();
   }
 
-  public async updateNames({ ids, name }: { ids: string[]; name: string }) {
+  public async updateNames({ ids, name }: { ids: number[]; name: string }) {
     await EnvModel.update({ name }, { where: { id: ids } });
     await this.set_envs();
   }
@@ -193,6 +197,8 @@ export default class EnvService {
     });
     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];
@@ -205,9 +211,23 @@ export default class EnvService {
             .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`;
         }
       }
     }
-    fs.writeFileSync(config.envFile, env_string);
+    await writeFileWithLock(config.envFile, env_string);
+    await writeFileWithLock(config.jsEnvFile, js_env_string);
+    await writeFileWithLock(config.pyEnvFile, py_env_string);
   }
 }

back/services/grpc.ts

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,92 @@
+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(); 

back/services/notify.ts

@@ -1,12 +1,11 @@
-import { NotificationInfo } from '../data/notify';
-import { Service, Inject } from 'typedi';
-import winston from 'winston';
-import UserService from './user';
-import got from 'got';
-import nodemailer from 'nodemailer';
 import crypto from 'crypto';
-import { HttpProxyAgent, HttpsProxyAgent } from 'hpagent';
+import nodemailer from 'nodemailer';
+import { Inject, Service } from 'typedi';
 import { parseBody, parseHeaders } from '../config/util';
+import { NotificationInfo } from '../data/notify';
+import UserService from './user';
+import { httpClient } from '../config/http';
+import { ProxyAgent } from 'undici';
 
 @Service()
 export default class NotificationService {
@@ -27,10 +26,14 @@ export default class NotificationService {
     ['aibotk', this.aibotk],
     ['iGot', this.iGot],
     ['pushPlus', this.pushPlus],
+    ['wePlusBot', this.wePlusBot],
     ['email', this.email],
     ['pushMe', this.pushMe],
     ['webhook', this.webhook],
     ['lark', this.lark],
+    ['chronocat', this.chronocat],
+    ['ntfy', this.ntfy],
+    ['wxPusherBot', this.wxPusherBot],
   ]);
 
   private title = '';
@@ -41,7 +44,7 @@ export default class NotificationService {
     retry: 1,
   };
 
-  constructor(@Inject('logger') private logger: winston.Logger) {}
+  constructor() {}
 
   public async notify(
     title: string,
@@ -56,7 +59,7 @@ export default class NotificationService {
       try {
         return await notificationModeAction?.call(this);
       } catch (error: any) {
-        return false;
+        console.error(error);
       }
     }
     return false;
@@ -81,8 +84,9 @@ export default class NotificationService {
   private async gotify() {
     const { gotifyUrl, gotifyToken, gotifyPriority = 1 } = this.params;
     try {
-      const res: any = await got
+      const res = await httpClient.post(
-        .post(`${gotifyUrl}/message?token=${gotifyToken}`, {
+        `${gotifyUrl}/message?token=${gotifyToken}`,
+        {
           ...this.gotOption,
           body: `title=${encodeURIComponent(
             this.title,
@@ -92,8 +96,8 @@ export default class NotificationService {
           headers: {
             'Content-Type': 'application/x-www-form-urlencoded',
           },
-        })
+        },
-        .json();
+      );
       if (typeof res.id === 'number') {
         return true;
       } else {
@@ -107,13 +111,11 @@ export default class NotificationService {
   private async goCqHttpBot() {
     const { goCqHttpBotQq, goCqHttpBotToken, goCqHttpBotUrl } = this.params;
     try {
-      const res: any = await got
+      const res = await httpClient.post(`${goCqHttpBotUrl}?${goCqHttpBotQq}`, {
-        .post(`${goCqHttpBotUrl}?${goCqHttpBotQq}`, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: { message: `${this.title}\n${this.content}` },
-          json: { message: `${this.title}\n${this.content}` },
+        headers: { Authorization: 'Bearer ' + goCqHttpBotToken },
-          headers: { Authorization: 'Bearer ' + goCqHttpBotToken },
+      });
-        })
-        .json();
       if (res.retcode === 0) {
         return true;
       } else {
@@ -126,17 +128,20 @@ export default class NotificationService {
 
   private async serverChan() {
     const { serverChanKey } = this.params;
-    const url = serverChanKey.startsWith('SCT')
+    const matchResult = serverChanKey.match(/^sctp(\d+)t/i);
-      ? `https://sctapi.ftqq.com/${serverChanKey}.send`
+    const url =
-      : `https://sc.ftqq.com/${serverChanKey}.send`;
+      matchResult && matchResult[1]
+        ? `https://${matchResult[1]}.push.ft07.com/send/${serverChanKey}.send`
+        : `https://sctapi.ftqq.com/${serverChanKey}.send`;
+
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        body: `title=${encodeURIComponent(
-          body: `title=${this.title}&desp=${this.content}`,
+          this.title,
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        )}&desp=${encodeURIComponent(this.content)}`,
-        })
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-        .json();
+      });
       if (res.errno === 0 || res.data.errno === 0) {
         return true;
       } else {
@@ -151,15 +156,13 @@ export default class NotificationService {
     const { pushDeerKey, pushDeerUrl } = this.params;
     const url = pushDeerUrl || `https://api2.pushdeer.com/message/push`;
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        body: `pushkey=${pushDeerKey}&text=${encodeURIComponent(
-          body: `pushkey=${pushDeerKey}&text=${encodeURIComponent(
+          this.title,
-            this.title,
+        )}&desp=${encodeURIComponent(this.content)}&type=markdown`,
-          )}&desp=${encodeURIComponent(this.content)}&type=markdown`,
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      });
-        })
-        .json();
       if (
         res.content.result.length !== undefined &&
         res.content.result.length > 0
@@ -174,16 +177,13 @@ export default class NotificationService {
   }
 
   private async chat() {
-    const { chatUrl, chatToken } = this.params;
+    const { synologyChatUrl } = this.params;
-    const url = `${chatUrl}${chatToken}`;
     try {
-      const res: any = await got
+      const res = await httpClient.post(synologyChatUrl, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        body: `payload={"text":"${this.title}\n${this.content}"}`,
-          body: `payload={"text":"${this.title}\n${this.content}"}`,
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      });
-        })
-        .json();
       if (res.success) {
         return true;
       } else {
@@ -195,23 +195,35 @@ export default class NotificationService {
   }
 
   private async bark() {
-    let { barkPush, barkIcon, barkSound, barkGroup } = this.params;
+    let {
+      barkPush,
+      barkIcon = '',
+      barkSound = '',
+      barkGroup = '',
+      barkLevel = '',
+      barkUrl = '',
+      barkArchive = '',
+    } = this.params;
     if (!barkPush.startsWith('http')) {
       barkPush = `https://api.day.app/${barkPush}`;
     }
-    const url = `${barkPush}/${encodeURIComponent(
+    const url = `${barkPush}`;
-      this.title,
+    const body = {
-    )}/${encodeURIComponent(
+      title: this.title,
-      this.content,
+      body: this.content,
-    )}?icon=${barkIcon}&sound=${barkSound}&group=${barkGroup}`;
+      icon: barkIcon,
-
+      sound: barkSound,
+      group: barkGroup,
+      isArchive: barkArchive,
+      level: barkLevel,
+      url: barkUrl,
+    };
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .get(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: body,
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        headers: { 'Content-Type': 'application/json' },
-        })
+      });
-        .json();
       if (res.code === 200) {
         return true;
       } else {
@@ -232,34 +244,22 @@ export default class NotificationService {
       telegramBotUserId,
     } = this.params;
     const authStr = telegramBotProxyAuth ? `${telegramBotProxyAuth}@` : '';
-    const url = `https://${
+    const url = `${
-      telegramBotApiHost ? telegramBotApiHost : 'api.telegram.org'
+      telegramBotApiHost ? telegramBotApiHost : 'https://api.telegram.org'
     }/bot${telegramBotToken}/sendMessage`;
     let agent;
     if (telegramBotProxyHost && telegramBotProxyPort) {
-      const options: any = {
+      agent = new ProxyAgent({
-        keepAlive: true,
+        uri: `http://${authStr}${telegramBotProxyHost}:${telegramBotProxyPort}`,
-        keepAliveMsecs: 1000,
+      });
-        maxSockets: 256,
-        maxFreeSockets: 256,
-        proxy: `http://${authStr}${telegramBotProxyHost}:${telegramBotProxyPort}`,
-      };
-      const httpAgent = new HttpProxyAgent(options);
-      const httpsAgent = new HttpsProxyAgent(options);
-      agent = {
-        http: httpAgent,
-        https: httpsAgent,
-      };
     }
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        body: `chat_id=${telegramBotUserId}&text=${this.title}\n\n${this.content}&disable_web_page_preview=true`,
-          body: `chat_id=${telegramBotUserId}&text=${this.title}\n\n${this.content}&disable_web_page_preview=true`,
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        dispatcher: agent,
-          agent,
+      });
-        })
-        .json();
       if (res.ok) {
         return true;
       } else {
@@ -282,17 +282,15 @@ export default class NotificationService {
     }
     const url = `https://oapi.dingtalk.com/robot/send?access_token=${dingtalkBotToken}${secretParam}`;
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: {
-          json: {
+          msgtype: 'text',
-            msgtype: 'text',
+          text: {
-            text: {
+            content: ` ${this.title}\n\n${this.content}`,
-              content: ` ${this.title}\n\n${this.content}`,
-            },
           },
-        })
+        },
-        .json();
+      });
       if (res.errcode === 0) {
         return true;
       } else {
@@ -308,17 +306,15 @@ export default class NotificationService {
       this.params;
     const url = `${weWorkOrigin}/cgi-bin/webhook/send?key=${weWorkBotKey}`;
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: {
-          json: {
+          msgtype: 'text',
-            msgtype: 'text',
+          text: {
-            text: {
+            content: ` ${this.title}\n\n${this.content}`,
-              content: ` ${this.title}\n\n${this.content}`,
-            },
           },
-        })
+        },
-        .json();
+      });
       if (res.errcode === 0) {
         return true;
       } else {
@@ -335,15 +331,13 @@ export default class NotificationService {
     const [corpid, corpsecret, touser, agentid, thumb_media_id = '1'] =
       weWorkAppKey.split(',');
     const url = `${weWorkOrigin}/cgi-bin/gettoken`;
-    const tokenRes: any = await got
+    const tokenRes = await httpClient.post(url, {
-      .post(url, {
+      ...this.gotOption,
-        ...this.gotOption,
+      json: {
-        json: {
+        corpid,
-          corpid,
+        corpsecret,
-          corpsecret,
+      },
-        },
+    });
-      })
-      .json();
 
     let options: any = {
       msgtype: 'mpnews',
@@ -384,20 +378,18 @@ export default class NotificationService {
     }
 
     try {
-      const res: any = await got
+      const res = await httpClient.post(
-        .post(
+        `${weWorkOrigin}/cgi-bin/message/send?access_token=${tokenRes.access_token}`,
-          `${weWorkOrigin}/cgi-bin/message/send?access_token=${tokenRes.access_token}`,
+        {
-          {
+          ...this.gotOption,
-            ...this.gotOption,
+          json: {
-            json: {
+            touser,
-              touser,
+            agentid,
-              agentid,
+            safe: '0',
-              safe: '0',
+            ...options,
-              ...options,
-            },
           },
-        )
+        },
-        .json();
+      );
 
       if (res.errcode === 0) {
         return true;
@@ -439,14 +431,12 @@ export default class NotificationService {
     }
 
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: {
-          json: {
+          ...json,
-            ...json,
+        },
-          },
+      });
-        })
-        .json();
       if (res.code === 0) {
         return true;
       } else {
@@ -461,13 +451,11 @@ export default class NotificationService {
     const { iGotPushKey } = this.params;
     const url = `https://push.hellyw.com/${iGotPushKey.toLowerCase()}`;
     try {
-      const res: any = await got
+      const res = await httpClient.post(url, {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        body: `title=${this.title}&content=${this.content}`,
-          body: `title=${this.title}&content=${this.content}`,
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      });
-        })
-        .json();
 
       if (res.ret === 0) {
         return true;
@@ -480,20 +468,67 @@ export default class NotificationService {
   }
 
   private async pushPlus() {
-    const { pushPlusToken, pushPlusUser } = this.params;
+    const {
+      pushPlusToken,
+      pushPlusUser,
+      pushplusWebhook,
+      pushPlusTemplate,
+      pushplusChannel,
+      pushplusCallbackUrl,
+      pushplusTo,
+    } = this.params;
     const url = `https://www.pushplus.plus/send`;
     try {
-      const res: any = await got
+      let body = {
-        .post(url, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: {
-          json: {
+          token: `${pushPlusToken}`,
-            token: `${pushPlusToken}`,
+          title: `${this.title}`,
-            title: `${this.title}`,
+          content: `${this.content.replace(/[\n\r]/g, '<br>')}`,
-            content: `${this.content.replace(/[\n\r]/g, '<br>')}`,
+          topic: `${pushPlusUser || ''}`,
-            topic: `${pushPlusUser || ''}`,
+          template: `${pushPlusTemplate || 'html'}`,
-          },
+          channel: `${pushplusChannel || 'wechat'}`,
-        })
+          webhook: `${pushplusWebhook || ''}`,
-        .json();
+          callbackUrl: `${pushplusCallbackUrl || ''}`,
+          to: `${pushplusTo || ''}`,
+        },
+      };
+
+      const res = await httpClient.post(url, body);
+
+      if (res.code === 200) {
+        return true;
+      } else {
+        throw new Error(JSON.stringify(res));
+      }
+    } catch (error: any) {
+      throw new Error(error.response ? error.response.body : error);
+    }
+  }
+
+  private async wePlusBot() {
+    const { wePlusBotToken, wePlusBotReceiver, wePlusBotVersion } = this.params;
+
+    let content = this.content;
+    let template = 'txt';
+    if (this.content.length > 800) {
+      template = 'html';
+      content = content.replace(/[\n\r]/g, '<br>');
+    }
+
+    const url = `https://www.weplusbot.com/send`;
+    try {
+      const res = await httpClient.post(url, {
+        ...this.gotOption,
+        json: {
+          token: `${wePlusBotToken}`,
+          title: `${this.title}`,
+          template: `${template}`,
+          content: `${content}`,
+          receiver: `${wePlusBotReceiver || ''}`,
+          version: `${wePlusBotVersion || 'pro'}`,
+        },
+      });
 
       if (res.code === 200) {
         return true;
@@ -513,17 +548,15 @@ export default class NotificationService {
     }
 
     try {
-      const res: any = await got
+      const res = await httpClient.post(larkKey, {
-        .post(larkKey, {
+        ...this.gotOption,
-          ...this.gotOption,
+        json: {
-          json: {
+          msg_type: 'text',
-            msg_type: 'text',
+          content: { text: `${this.title}\n\n${this.content}` },
-            content: { text: `${this.title}\n\n${this.content}` },
+        },
-          },
+        headers: { 'Content-Type': 'application/json' },
-          headers: { 'Content-Type': 'application/json' },
+      });
-        })
+      if (res.StatusCode === 0 || res.code === 0) {
-        .json();
-      if (res.StatusCode === 0) {
         return true;
       } else {
         throw new Error(JSON.stringify(res));
@@ -534,7 +567,7 @@ export default class NotificationService {
   }
 
   private async email() {
-    const { emailPass, emailService, emailUser } = this.params;
+    const { emailPass, emailService, emailUser, emailTo } = this.params;
 
     try {
       const transporter = nodemailer.createTransport({
@@ -547,7 +580,7 @@ export default class NotificationService {
 
       const info = await transporter.sendMail({
         from: `"青龙快讯" <${emailUser}>`,
-        to: `${emailUser}`,
+        to: emailTo ? emailTo.split(';') : emailUser,
         subject: `${this.title}`,
         html: `${this.content.replace(/\n/g, '<br/>')}`,
       });
@@ -560,34 +593,171 @@ export default class NotificationService {
         throw new Error(JSON.stringify(info));
       }
     } catch (error: any) {
-      throw new Error(error.response ? error.response.body : error);
+      throw error;
     }
   }
 
   private async pushMe() {
-    const { pushMeKey } = this.params;
+    const { pushMeKey, pushMeUrl } = this.params;
     try {
-      const res: any = await got.post(
+      const res = await httpClient.post<'text'>(
-        `https://push.i-i.me/?push_key=${pushMeKey}`,
+        pushMeUrl || 'https://push.i-i.me/',
         {
           ...this.gotOption,
           json: {
+            push_key: pushMeKey,
             title: this.title,
             content: this.content,
           },
           headers: { 'Content-Type': 'application/json' },
         },
       );
-      if (res.body === 'success') {
+      if (res === 'success') {
         return true;
       } else {
-        throw new Error(res.body);
+        throw new Error(res);
       }
     } catch (error: any) {
       throw new Error(error.response ? error.response.body : error);
     }
   }
 
+  private async ntfy() {
+    const { ntfyUrl, ntfyTopic, ntfyPriority } = this.params;
+    // 编码函数
+    const encodeRfc2047 = (text: string, charset: string = 'UTF-8'): string => {
+      const encodedText = Buffer.from(text).toString('base64');
+      return `=?${charset}?B?${encodedText}?=`;
+    };
+    try {
+      const encodedTitle = encodeRfc2047(this.title);
+      const res = await httpClient.request(
+        `${ntfyUrl || 'https://ntfy.sh'}/${ntfyTopic}`,
+        {
+          ...this.gotOption,
+          body: `${this.content}`,
+          headers: { Title: encodedTitle, Priority: `${ntfyPriority || '3'}` },
+          method: 'POST',
+        },
+      );
+      if (res.statusCode === 200) {
+        return true;
+      } else {
+        throw new Error(await res.body.text());
+      }
+    } catch (error: any) {
+      throw new Error(error.response ? error.response.body : error);
+    }
+  }
+
+  private async wxPusherBot() {
+    const { wxPusherBotAppToken, wxPusherBotTopicIds, wxPusherBotUids } =
+      this.params;
+    // 处理 topicIds，将分号分隔的字符串转为数组
+    const topicIds = wxPusherBotTopicIds
+      ? wxPusherBotTopicIds
+          .split(';')
+          .map((id) => id.trim())
+          .filter((id) => id)
+          .map((id) => parseInt(id))
+      : [];
+
+    // 处理 uids，将分号分隔的字符串转为数组
+    const uids = wxPusherBotUids
+      ? wxPusherBotUids
+          .split(';')
+          .map((uid) => uid.trim())
+          .filter((uid) => uid)
+      : [];
+
+    // topic_ids 和 uids 至少要有一个
+    if (!topicIds.length && !uids.length) {
+      throw new Error('wxPusher 服务的 TopicIds 和 Uids 至少配置一个才行');
+    }
+
+    const url = `https://wxpusher.zjiecode.com/api/send/message`;
+    try {
+      const res = await httpClient.post(url, {
+        ...this.gotOption,
+        json: {
+          appToken: wxPusherBotAppToken,
+          content: `<h1>${this.title}</h1><br/><div style='white-space: pre-wrap;'>${this.content}</div>`,
+          summary: this.title,
+          contentType: 2,
+          topicIds: topicIds,
+          uids: uids,
+          verifyPayType: 0,
+        },
+      });
+
+      if (res.code === 1000) {
+        return true;
+      } else {
+        throw new Error(JSON.stringify(res));
+      }
+    } catch (error: any) {
+      throw new Error(error.response ? error.response.body : error);
+    }
+  }
+
+  private async chronocat() {
+    const { chronocatURL, chronocatQQ, chronocatToken } = this.params;
+    try {
+      const user_ids = chronocatQQ
+        .match(/user_id=(\d+)/g)
+        ?.map((match: any) => match.split('=')[1]);
+      const group_ids = chronocatQQ
+        .match(/group_id=(\d+)/g)
+        ?.map((match: any) => match.split('=')[1]);
+
+      const url = `${chronocatURL}/api/message/send`;
+      const headers = {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${chronocatToken}`,
+      };
+
+      for (const [chat_type, ids] of [
+        [1, user_ids],
+        [2, group_ids],
+      ]) {
+        if (!ids) {
+          continue;
+        }
+        let _ids: any = ids;
+        for (const chat_id of _ids) {
+          const data = {
+            peer: {
+              chatType: chat_type,
+              peerUin: chat_id,
+            },
+            elements: [
+              {
+                elementType: 1,
+                textElement: {
+                  content: `${this.title}\n\n${this.content}`,
+                },
+              },
+            ],
+          };
+          const res = await httpClient.request(url, {
+            ...this.gotOption,
+            json: data,
+            headers,
+            method: 'POST',
+          });
+          if (res.statusCode === 200) {
+            return true;
+          } else {
+            throw new Error(await res.body.text());
+          }
+        }
+      }
+      return false;
+    } catch (error: any) {
+      throw new Error(error.response ? error.response.body : error);
+    }
+  }
+
   private async webhook() {
     const {
       webhookUrl,
@@ -597,15 +767,14 @@ export default class NotificationService {
       webhookContentType,
     } = this.params;
 
-    const { formatBody, formatUrl } = this.formatNotifyContent(
+    if (!webhookUrl?.includes('$title') && !webhookBody?.includes('$title')) {
-      webhookUrl,
+      throw new Error('Url 或者 Body 中必须包含 $title');
-      webhookBody,
-    );
-    if (!formatUrl && !formatBody) {
-      return false;
     }
+
     const headers = parseHeaders(webhookHeaders);
-    const body = parseBody(formatBody, webhookContentType);
+    const body = parseBody(webhookBody, webhookContentType, (v) =>
+      v?.replaceAll('$title', this.title)?.replaceAll('$content', this.content),
+    );
     const bodyParam = this.formatBody(webhookContentType, body);
     const options = {
       method: webhookMethod,
@@ -614,12 +783,17 @@ export default class NotificationService {
       allowGetBody: true,
       ...bodyParam,
     };
+
     try {
-      const res = await got(formatUrl, options);
+      const formatUrl = webhookUrl
+        ?.replaceAll('$title', encodeURIComponent(this.title))
+        ?.replaceAll('$content', encodeURIComponent(this.content));
+      const res = await httpClient.request(formatUrl, options);
+      const text = await res.body.text();
       if (String(res.statusCode).startsWith('20')) {
         return true;
       } else {
-        throw new Error(JSON.stringify(res));
+        throw new Error(await res.body.text());
       }
     } catch (error: any) {
       throw new Error(error.response ? error.response.body : error);
@@ -634,23 +808,9 @@ export default class NotificationService {
       case 'multipart/form-data':
         return { form: body };
       case 'application/x-www-form-urlencoded':
+      case 'text/plain':
         return { body };
     }
     return {};
   }
-
-  private formatNotifyContent(url: string, body: string) {
-    if (!url.includes('$title') && !body.includes('$title')) {
-      return {};
-    }
-
-    return {
-      formatUrl: url
-        ?.replaceAll('$title', encodeURIComponent(this.title))
-        ?.replaceAll('$content', encodeURIComponent(this.content)),
-      formatBody: body
-        ?.replaceAll('$title', this.title)
-        ?.replaceAll('$content', this.content),
-    };
-  }
 }

back/services/open.ts

@@ -1,19 +1,18 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
 import { createRandomString } from '../config/util';
-import config from '../config';
 import { App, AppModel } from '../data/open';
 import { v4 as uuidV4 } from 'uuid';
 import sequelize, { Op } from 'sequelize';
+import { shareStore } from '../shared/store';
 
 @Service()
 export default class OpenService {
   constructor(@Inject('logger') private logger: winston.Logger) {}
 
-  public async findTokenByValue(token: string): Promise<App | null> {
+  public async findApps(): Promise<App[] | null> {
     const docs = await this.find({});
-    const doc = docs.filter((x) => x.tokens?.find((y) => y.value === token));
+    return docs;
-    return doc[0];
   }
 
   public async create(payload: App): Promise<App> {
@@ -21,12 +20,14 @@ export default class OpenService {
     tab.client_id = createRandomString(12, 12);
     tab.client_secret = createRandomString(24, 24);
     const doc = await this.insert(tab);
+    const apps = await this.find({});
+    await shareStore.updateApps(apps);
     return { ...doc, tokens: [] };
   }
 
   public async insert(payload: App): Promise<App> {
     const doc = await AppModel.create(payload, { returning: true });
-    return doc.get({ plain: true }) as App;
+    return doc.get({ plain: true });
   }
 
   public async update(payload: App): Promise<App> {
@@ -34,26 +35,33 @@ export default class OpenService {
       name: payload.name,
       scopes: payload.scopes,
       id: payload.id,
-    } as any);
+    } as App);
     return { ...newDoc, tokens: [] };
   }
 
-  private async updateDb(payload: App): Promise<App> {
+  private async updateDb(payload: Partial<App>): Promise<App> {
     await AppModel.update(payload, { where: { id: payload.id } });
-    return await this.getDb({ id: payload.id });
+    const apps = await this.find({});
+    await shareStore.updateApps(apps);
+    return apps?.find((x) => x.id === payload.id) as App;
   }
 
-  public async getDb(query: any): Promise<App> {
+  public async getDb(query: Record<string, any>): Promise<App> {
-    const doc: any = await AppModel.findOne({ where: query });
+    const doc = await AppModel.findOne({ where: query });
-    return doc && (doc.get({ plain: true }) as App);
+    if (!doc) {
+      throw new Error(`App ${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
   public async remove(ids: number[]) {
     await AppModel.destroy({ where: { id: ids } });
+    const apps = await this.find({});
+    await shareStore.updateApps(apps);
   }
 
   public async resetSecret(id: number): Promise<App> {
-    const tab: any = {
+    const tab: Partial<App> = {
       client_secret: createRandomString(24, 24),
       tokens: [],
       id,
@@ -71,7 +79,7 @@ export default class OpenService {
   public async list(
     searchText: string = '',
     sort: any = {},
-    query: any = {},
+    query: Record<string, any> = {},
   ): Promise<App[]> {
     let condition = { ...query };
     if (searchText) {
@@ -98,7 +106,7 @@ export default class OpenService {
     }
   }
 
-  private async find(query: any, sort?: any): Promise<App[]> {
+  private async find(query: Record<string, any>, sort?: any): Promise<App[]> {
     const docs = await AppModel.findAll({ where: { ...query } });
     return docs.map((x) => x.get({ plain: true }));
   }
@@ -132,6 +140,8 @@ export default class OpenService {
         { tokens },
         { where: { client_id, client_secret } },
       );
+      const apps = await this.find({});
+      await shareStore.updateApps(apps);
       return {
         code: 200,
         data: {
@@ -141,7 +151,7 @@ export default class OpenService {
         },
       };
     } else {
-      return { code: 400, message: 'client_id或client_seret有误' };
+      return { code: 400, message: 'client_id 或 client_seret 有误' };
     }
   }
 
@@ -149,14 +159,15 @@ export default class OpenService {
     value: string;
     expiration: number;
   }> {
-    let systemApp = (await AppModel.findOne({
+    const apps = await shareStore.getApps();
-      where: { name: 'system' },
+    const systemApp = apps?.find((x) => x.name === 'system');
-    })) as App;
     if (!systemApp) {
-      systemApp = await this.create({
+      throw new Error('system app not found');
-        name: 'system',
+    }
-        scopes: ['crons', 'system'],
+    const now = Math.round(Date.now() / 1000);
-      } as App);
+    const currentToken = systemApp.tokens?.find((x) => x.expiration > now);
+    if (currentToken) {
+      return currentToken;
     }
     const { data } = await this.authToken({
       client_id: systemApp.client_id,

back/services/schedule.ts

@@ -12,11 +12,12 @@ import dayjs from 'dayjs';
 import taskLimit from '../shared/pLimit';
 import { spawn } from 'cross-spawn';
 
-interface ScheduleTaskType {
+export interface ScheduleTaskType {
-  id: number;
+  id?: number;
   command: string;
   name?: string;
   schedule?: string;
+  runOrigin: 'subscription' | 'system' | 'script';
 }
 
 export interface TaskCallbacks {
@@ -40,17 +41,37 @@ export default class ScheduleService {
 
   private intervalSchedule = new ToadScheduler();
 
-  private maxBuffer = 200 * 1024 * 1024;
+  private taskLimitMap = {
+    system: 'runWithSystemLimit' as const,
+    script: 'runWithScriptLimit' as const,
+    subscription: 'runWithSubscriptionLimit' as const,
+  };
 
   constructor(@Inject('logger') private logger: winston.Logger) {}
 
   async runTask(
     command: string,
     callbacks: TaskCallbacks = {},
+    params: {
+      schedule?: string;
+      name?: string;
+      command?: string;
+      id: string;
+      runOrigin: 'subscription' | 'system' | 'script';
+    },
     completionTime: 'start' | 'end' = 'end',
   ) {
-    return taskLimit.runWithCpuLimit(() => {
+    const { runOrigin, ...others } = params;
+
+    return taskLimit[this.taskLimitMap[runOrigin]](others, () => {
       return new Promise(async (resolve, reject) => {
+        this.logger.info(
+          `[panel][开始执行任务] 参数: ${JSON.stringify({
+            ...others,
+            command,
+          })}`,
+        );
+
         try {
           const startTime = dayjs();
           await callbacks.onBefore?.(startTime);
@@ -82,20 +103,22 @@ export default class ScheduleService {
             await callbacks.onError?.(JSON.stringify(err));
           });
 
-          cp.on('exit', async (code, signal) => {
+          cp.on('exit', async (code) => {
             this.logger.info(
-              `[panel][任务退出] ${command} 进程id: ${cp.pid}, 退出码 ${code}`,
+              '[panel][执行任务结束] 参数: %s, 退出码: %j',
+              JSON.stringify({
+                ...others,
+                command,
+              }),
+              code,
             );
-          });
-
-          cp.on('close', async (code) => {
             const endTime = dayjs();
             await callbacks.onEnd?.(
               cp,
               endTime,
               endTime.diff(startTime, 'seconds'),
             );
-            resolve(null);
+            resolve({ ...others, pid: cp.pid, code });
           });
         } catch (error) {
           this.logger.error(
@@ -110,7 +133,7 @@ export default class ScheduleService {
   }
 
   async createCronTask(
-    { id = 0, command, name, schedule = '' }: ScheduleTaskType,
+    { id = 0, command, name, schedule = '', runOrigin }: ScheduleTaskType,
     callbacks?: TaskCallbacks,
     runImmediately = false,
   ) {
@@ -126,12 +149,24 @@ export default class ScheduleService {
     this.scheduleStacks.set(
       _id,
       nodeSchedule.scheduleJob(_id, schedule, async () => {
-        this.runTask(command, callbacks);
+        this.runTask(command, callbacks, {
+          name,
+          schedule,
+          command,
+          id: _id,
+          runOrigin,
+        });
       }),
     );
 
     if (runImmediately) {
-      this.runTask(command, callbacks);
+      this.runTask(command, callbacks, {
+        name,
+        schedule,
+        command,
+        id: _id,
+        runOrigin,
+      });
     }
   }
 
@@ -145,7 +180,7 @@ export default class ScheduleService {
   }
 
   async createIntervalTask(
-    { id = 0, command, name = '' }: ScheduleTaskType,
+    { id = 0, command, name = '', runOrigin }: ScheduleTaskType,
     schedule: SimpleIntervalSchedule,
     runImmediately = true,
     callbacks?: TaskCallbacks,
@@ -160,11 +195,16 @@ export default class ScheduleService {
     const task = new Task(
       name,
       () => {
-        this.runTask(command, callbacks);
+        this.runTask(command, callbacks, {
+          name,
+          command,
+          id: _id,
+          runOrigin,
+        });
       },
       (err) => {
         this.logger.error(
-          '[执行任务失败] 命令: %s, 错误信息: %j',
+          '[panel][执行任务失败] 命令: %s, 错误信息: %j',
           command,
           err,
         );
@@ -174,19 +214,28 @@ export default class ScheduleService {
     const job = new LongIntervalJob(
       { runImmediately: false, ...schedule },
       task,
-      _id,
+      { id: _id },
     );
 
     this.intervalSchedule.addIntervalJob(job);
 
     if (runImmediately) {
-      this.runTask(command, callbacks);
+      this.runTask(command, callbacks, {
+        name,
+        command,
+        id: _id,
+        runOrigin,
+      });
     }
   }
 
   async cancelIntervalTask({ id = 0, name }: ScheduleTaskType) {
     const _id = this.formatId(id);
-    this.logger.info('[取消interval任务], 任务ID: %s, 任务名: %s', _id, name);
+    this.logger.info(
+      '[panel][取消interval任务], 任务ID: %s, 任务名: %s',
+      _id,
+      name,
+    );
     this.intervalSchedule.removeById(_id);
   }
 

back/services/script.ts

@@ -1,13 +1,13 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
-import fs from 'fs';
+import path, { join } from 'path';
-import path from 'path';
 import SockService from './sock';
 import CronService from './cron';
 import ScheduleService, { TaskCallbacks } from './schedule';
 import config from '../config';
 import { TASK_COMMAND } from '../config/const';
-import { getPid, killTask } from '../config/util';
+import { getFileContentByName, getPid, killTask, rmPath } from '../config/util';
+import taskLimit from '../shared/pLimit';
 
 @Service()
 export default class ScriptService {
@@ -21,9 +21,7 @@ export default class ScriptService {
   private taskCallbacks(filePath: string): TaskCallbacks {
     return {
       onEnd: async (cp, endTime, diff) => {
-        try {
+        await rmPath(filePath);
-          fs.unlinkSync(filePath);
-        } catch (error) {}
       },
       onError: async (message: string) => {
         this.sockService.sendMessage({
@@ -42,10 +40,11 @@ export default class ScriptService {
 
   public async runScript(filePath: string) {
     const relativePath = path.relative(config.scriptPath, filePath);
-    const command = `${TASK_COMMAND} -l ${relativePath} now`;
+    const command = `${TASK_COMMAND} ${relativePath} now`;
     const pid = await this.scheduleService.runTask(
-      command,
+      `real_time=true ${command}`,
       this.taskCallbacks(filePath),
+      { command, id: relativePath.replace(/ /g, '-'), runOrigin: 'script' },
       'start',
     );
 
@@ -55,7 +54,8 @@ export default class ScriptService {
   public async stopScript(filePath: string, pid: number) {
     if (!pid) {
       const relativePath = path.relative(config.scriptPath, filePath);
-      pid = await getPid(`${TASK_COMMAND} -l ${relativePath} now`) as number;
+      taskLimit.removeQueuedCron(relativePath.replace(/ /g, '-'));
+      pid = (await getPid(`${TASK_COMMAND} ${relativePath} now`)) as number;
     }
     try {
       await killTask(pid);
@@ -63,4 +63,20 @@ export default class ScriptService {
 
     return { code: 200 };
   }
+
+  public checkFilePath(filePath: string, fileName: string) {
+    const finalPath = path.resolve(config.scriptPath, filePath, fileName);
+    return finalPath.startsWith(config.scriptPath) ? finalPath : '';
+  }
+
+  public async getFile(filePath: string, fileName: string) {
+    const finalPath = this.checkFilePath(filePath, fileName);
+
+    if (!finalPath) {
+      return '';
+    }
+
+    const content = await getFileContentByName(finalPath);
+    return content;
+  }
 }

back/services/sock.ts

@@ -7,7 +7,7 @@ import { SockMessage } from '../data/sock';
 export default class SockService {
   private clients: Connection[] = [];
 
-  constructor(@Inject('logger') private logger: winston.Logger) {}
+  constructor(@Inject('logger') private logger: winston.Logger) { }
 
   public getClients() {
     return this.clients;

back/services/sshKey.ts

@@ -1,11 +1,13 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
-import fs, { existsSync } from 'fs';
+import fs from 'fs/promises';
 import os from 'os';
 import path from 'path';
 import { Subscription } from '../data/subscription';
 import { formatUrl } from '../config/subscription';
 import config from '../config';
+import { fileExist, rmPath } from '../config/util';
+import { writeFileWithLock } from '../shared/utils';
 
 @Service()
 export default class SshKeyService {
@@ -18,45 +20,54 @@ export default class SshKeyService {
     this.initSshConfigFile();
   }
 
-  private initSshConfigFile() {
+  private async initSshConfigFile() {
     let config = '';
-    if (existsSync(this.sshConfigFilePath)) {
+    const _exist = await fileExist(this.sshConfigFilePath);
-      config = fs.readFileSync(this.sshConfigFilePath, { encoding: 'utf-8' });
+    if (_exist) {
+      config = await fs.readFile(this.sshConfigFilePath, { encoding: 'utf-8' });
     } else {
-      fs.writeFileSync(this.sshConfigFilePath, '');
+      await writeFileWithLock(this.sshConfigFilePath, '');
     }
     if (!config.includes(this.sshConfigHeader)) {
-      fs.writeFileSync(
+      await writeFileWithLock(
         this.sshConfigFilePath,
         `${this.sshConfigHeader}\n\n${config}`,
-        { encoding: 'utf-8' },
       );
     }
   }
 
-  private generatePrivateKeyFile(alias: string, key: string): void {
+  private async generatePrivateKeyFile(
+    alias: string,
+    key: string,
+  ): Promise<void> {
     try {
-      fs.writeFileSync(path.join(this.sshPath, alias), `${key}${os.EOL}`, {
+      await writeFileWithLock(
-        encoding: 'utf8',
+        path.join(this.sshPath, alias),
-        mode: '400',
+        `${key}${os.EOL}`,
-      });
+        {
+          encoding: 'utf8',
+          mode: '400',
+        },
+      );
     } catch (error) {
       this.logger.error('生成私钥文件失败', error);
     }
   }
 
-  private removePrivateKeyFile(alias: string): void {
+  private async removePrivateKeyFile(alias: string): Promise<void> {
     try {
       const filePath = path.join(this.sshPath, alias);
-      if (existsSync(filePath)) {
+      await rmPath(filePath);
-        fs.unlinkSync(filePath);
-      }
     } catch (error) {
       this.logger.error('删除私钥文件失败', error);
     }
   }
 
-  private generateSingleSshConfig(alias: string, host: string, proxy?: string) {
+  private async generateSingleSshConfig(
+    alias: string,
+    host: string,
+    proxy?: string,
+  ) {
     if (host === 'github.com') {
       host = `ssh.github.com\n    Port 443\n    HostkeyAlgorithms +ssh-rsa`;
     }
@@ -67,49 +78,52 @@ export default class SshKeyService {
       this.sshPath,
       alias,
     )}\n    StrictHostKeyChecking no\n${proxyStr}`;
-    fs.writeFileSync(`${path.join(this.sshPath, `${alias}.config`)}`, config, {
+    await writeFileWithLock(
-      encoding: 'utf8',
+      `${path.join(this.sshPath, `${alias}.config`)}`,
-    });
+      config,
+    );
   }
 
-  private removeSshConfig(alias: string) {
+  private async removeSshConfig(alias: string) {
     try {
       const filePath = path.join(this.sshPath, `${alias}.config`);
-      if (existsSync(filePath)) {
+      await rmPath(filePath);
-        fs.unlinkSync(filePath);
-      }
     } catch (error) {
       this.logger.error(`删除ssh配置文件${alias}失败`, error);
     }
   }
 
-  public addSSHKey(
+  public async addSSHKey(
     key: string,
     alias: string,
     host: string,
     proxy?: string,
-  ): void {
+  ): Promise<void> {
-    this.generatePrivateKeyFile(alias, key);
+    await this.generatePrivateKeyFile(alias, key);
-    this.generateSingleSshConfig(alias, host, proxy);
+    await this.generateSingleSshConfig(alias, host, proxy);
   }
 
-  public removeSSHKey(alias: string, host: string, proxy?: string): void {
+  public async removeSSHKey(
-    this.removePrivateKeyFile(alias);
+    alias: string,
-    this.removeSshConfig(alias);
+    host: string,
+    proxy?: string,
+  ): Promise<void> {
+    await this.removePrivateKeyFile(alias);
+    await this.removeSshConfig(alias);
   }
 
-  public setSshConfig(docs: Subscription[]) {
+  public async setSshConfig(docs: Subscription[]) {
     for (const doc of docs) {
       if (doc.type === 'private-repo' && doc.pull_type === 'ssh-key') {
         const { alias, proxy } = doc;
         const { host } = formatUrl(doc);
-        this.removePrivateKeyFile(alias);
+        await this.removePrivateKeyFile(alias);
-        this.removeSshConfig(alias);
+        await this.removeSshConfig(alias);
-        this.generatePrivateKeyFile(
+        await this.generatePrivateKeyFile(
           alias,
           (doc.pull_option as any).private_key,
         );
-        this.generateSingleSshConfig(alias, host, proxy);
+        await this.generateSingleSshConfig(alias, host, proxy);
       }
     }
   }

back/services/subscription.ts

@@ -3,11 +3,11 @@ import winston from 'winston';
 import config from '../config';
 import {
   Subscription,
+  SubscriptionInstance,
   SubscriptionModel,
   SubscriptionStatus,
 } from '../data/subscription';
 import { ChildProcessWithoutNullStreams } from 'child_process';
-import fs from 'fs';
 import {
   getFileContentByName,
   concurrentRun,
@@ -16,9 +16,9 @@ import {
   killTask,
   handleLogPath,
   promiseExec,
-  emptyDir,
+  rmPath,
 } from '../config/util';
-import { promises, existsSync } from 'fs';
+import fs from 'fs/promises';
 import { FindOptions, Op } from 'sequelize';
 import path, { join } from 'path';
 import ScheduleService, { TaskCallbacks } from './schedule';
@@ -30,6 +30,7 @@ import { LOG_END_SYMBOL } from '../config/const';
 import { formatCommand, formatUrl } from '../config/subscription';
 import { CrontabModel } from '../data/cron';
 import CrontabService from './cron';
+import taskLimit from '../shared/pLimit';
 
 @Service()
 export default class SubscriptionService {
@@ -39,10 +40,14 @@ export default class SubscriptionService {
     private sockService: SockService,
     private sshKeyService: SshKeyService,
     private crontabService: CrontabService,
-  ) { }
+  ) {}
 
-  public async list(searchText?: string): Promise<Subscription[]> {
+  public async list(
+    searchText?: string,
+    ids?: string,
+  ): Promise<SubscriptionInstance[]> {
     let query = {};
+    const subIds = JSON.parse(ids || '[]');
     if (searchText) {
       const reg = {
         [Op.or]: [
@@ -63,7 +68,7 @@ export default class SubscriptionService {
     }
     try {
       const result = await SubscriptionModel.findAll({
-        where: query,
+        where: { ...query, ...(ids ? { id: subIds } : undefined) },
         order: [
           ['is_disabled', 'ASC'],
           ['createdAt', 'DESC'],
@@ -88,16 +93,16 @@ export default class SubscriptionService {
       this.scheduleService.cancelCronTask(doc as any);
       needCreate &&
         (await this.scheduleService.createCronTask(
-          doc as any,
+          { ...doc, runOrigin: 'subscription' } as any,
           this.taskCallbacks(doc),
           runImmediately,
         ));
-    } else {
+    } else if (doc.interval_schedule) {
       this.scheduleService.cancelIntervalTask(doc as any);
-      const { type, value } = doc.interval_schedule as any;
+      const { type, value } = doc.interval_schedule;
       needCreate &&
         (await this.scheduleService.createIntervalTask(
-          doc as any,
+          { ...doc, runOrigin: 'subscription' } as any,
           { [type]: value } as SimpleIntervalSchedule,
           runImmediately,
           this.taskCallbacks(doc),
@@ -107,7 +112,7 @@ export default class SubscriptionService {
 
   public async setSshConfig() {
     const docs = await SubscriptionModel.findAll();
-    this.sshKeyService.setSshConfig(docs);
+    await this.sshKeyService.setSshConfig(docs);
   }
 
   private taskCallbacks(doc: Subscription): TaskCallbacks {
@@ -131,7 +136,7 @@ export default class SubscriptionService {
         let beforeStr = '';
         try {
           if (doc.sub_before) {
-            fs.appendFileSync(absolutePath, `\n## 执行before命令...\n\n`);
+            await fs.appendFile(absolutePath, `\n## 执行before命令...\n\n`);
             beforeStr = await promiseExec(doc.sub_before);
           }
         } catch (error: any) {
@@ -139,7 +144,7 @@ export default class SubscriptionService {
             (error.stderr && error.stderr.toString()) || JSON.stringify(error);
         }
         if (beforeStr) {
-          fs.appendFileSync(absolutePath, `${beforeStr}\n`);
+          await fs.appendFile(absolutePath, `${beforeStr}\n`);
         }
       },
       onStart: async (cp: ChildProcessWithoutNullStreams, startTime) => {
@@ -158,7 +163,7 @@ export default class SubscriptionService {
         let afterStr = '';
         try {
           if (sub.sub_after) {
-            fs.appendFileSync(absolutePath, `\n\n## 执行after命令...\n\n`);
+            await fs.appendFile(absolutePath, `\n\n## 执行after命令...\n\n`);
             afterStr = await promiseExec(sub.sub_after);
           }
         } catch (error: any) {
@@ -166,10 +171,10 @@ export default class SubscriptionService {
             (error.stderr && error.stderr.toString()) || JSON.stringify(error);
         }
         if (afterStr) {
-          fs.appendFileSync(absolutePath, `${afterStr}\n`);
+          await fs.appendFile(absolutePath, `${afterStr}\n`);
         }
 
-        fs.appendFileSync(
+        await fs.appendFile(
           absolutePath,
           `\n## 执行结束... ${endTime.format(
             'YYYY-MM-DD HH:mm:ss',
@@ -190,12 +195,12 @@ export default class SubscriptionService {
       onError: async (message: string) => {
         const sub = await this.getDb({ id: doc.id });
         const absolutePath = await handleLogPath(sub.log_path as string);
-        fs.appendFileSync(absolutePath, `\n${message}`);
+        await fs.appendFile(absolutePath, `\n${message}`);
       },
       onLog: async (message: string) => {
         const sub = await this.getDb({ id: doc.id });
         const absolutePath = await handleLogPath(sub.log_path as string);
-        fs.appendFileSync(absolutePath, `\n${message}`);
+        await fs.appendFile(absolutePath, `\n${message}`);
       },
     };
   }
@@ -203,12 +208,12 @@ export default class SubscriptionService {
   public async create(payload: Subscription): Promise<Subscription> {
     const tab = new Subscription(payload);
     const doc = await this.insert(tab);
-    await this.handleTask(doc);
+    await this.handleTask(doc.get({ plain: true }));
     await this.setSshConfig();
     return doc;
   }
 
-  public async insert(payload: Subscription): Promise<Subscription> {
+  public async insert(payload: Subscription): Promise<SubscriptionInstance> {
     return await SubscriptionModel.create(payload, { returning: true });
   }
 
@@ -257,10 +262,10 @@ export default class SubscriptionService {
     );
   }
 
-  public async remove(ids: number[], query: any) {
+  public async remove(ids: number[], query: { force?: boolean }) {
     const docs = await SubscriptionModel.findAll({ where: { id: ids } });
     for (const doc of docs) {
-      await this.handleTask(doc, false);
+      await this.handleTask(doc.get({ plain: true }), false);
     }
     await SubscriptionModel.destroy({ where: { id: ids } });
     await this.setSshConfig();
@@ -268,11 +273,13 @@ export default class SubscriptionService {
     if (query?.force === true) {
       const crons = await CrontabModel.findAll({ where: { sub_id: ids } });
       if (crons?.length) {
-        await this.crontabService.remove(crons.map(x => x.id!))
+        await this.crontabService.remove(crons.map((x) => x.id!));
       }
       for (const doc of docs) {
         const filePath = join(config.scriptPath, doc.alias);
-        emptyDir(filePath);
+        const repoPath = join(config.repoPath, doc.alias);
+        await rmPath(filePath);
+        await rmPath(repoPath);
       }
     }
   }
@@ -280,8 +287,11 @@ export default class SubscriptionService {
   public async getDb(
     query: FindOptions<Subscription>['where'],
   ): Promise<Subscription> {
-    const doc: any = await SubscriptionModel.findOne({ where: { ...query } });
+    const doc = await SubscriptionModel.findOne({ where: { ...query } });
-    return doc && (doc.get({ plain: true }) as Subscription);
+    if (!doc) {
+      throw new Error(`Subscription ${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
   public async run(ids: number[]) {
@@ -320,7 +330,13 @@ export default class SubscriptionService {
 
     const command = formatCommand(subscription);
 
-    this.scheduleService.runTask(command, this.taskCallbacks(subscription));
+    this.scheduleService.runTask(command, this.taskCallbacks(subscription), {
+      name: subscription.name,
+      schedule: subscription.schedule,
+      command,
+      id: String(subscription.id),
+      runOrigin: 'subscription',
+    });
   }
 
   public async disabled(ids: number[]) {
@@ -328,7 +344,7 @@ export default class SubscriptionService {
     const docs = await SubscriptionModel.findAll({ where: { id: ids } });
     await this.setSshConfig();
     for (const doc of docs) {
-      await this.handleTask(doc, false);
+      await this.handleTask(doc.get({ plain: true }), false);
     }
   }
 
@@ -337,7 +353,7 @@ export default class SubscriptionService {
     const docs = await SubscriptionModel.findAll({ where: { id: ids } });
     await this.setSshConfig();
     for (const doc of docs) {
-      await this.handleTask(doc);
+      await this.handleTask(doc.get({ plain: true }));
     }
   }
 
@@ -348,7 +364,7 @@ export default class SubscriptionService {
     }
 
     const absolutePath = await handleLogPath(doc.log_path as string);
-    return getFileContentByName(absolutePath);
+    return await getFileContentByName(absolutePath);
   }
 
   public async logs(id: number) {
@@ -360,15 +376,18 @@ export default class SubscriptionService {
     if (doc.log_path) {
       const relativeDir = path.dirname(`${doc.log_path}`);
       const dir = path.resolve(config.logPath, relativeDir);
-      if (existsSync(dir)) {
+      const _exist = await fileExist(dir);
-        let files = await promises.readdir(dir);
+      if (_exist) {
-        return files
+        let files = await fs.readdir(dir);
-          .map((x) => ({
+        return (
-            filename: x,
+          await Promise.all(
-            directory: relativeDir.replace(config.logPath, ''),
+            files.map(async (x) => ({
-            time: fs.statSync(`${dir}/${x}`).mtime.getTime(),
+              filename: x,
-          }))
+              directory: relativeDir.replace(config.logPath, ''),
-          .sort((a, b) => b.time - a.time);
+              time: (await fs.lstat(`${dir}/${x}`)).mtime.getTime(),
+            })),
+          )
+        ).sort((a, b) => b.time - a.time);
       }
     }
   }

back/services/system.ts

@@ -1,20 +1,13 @@
+import { spawn } from 'cross-spawn';
 import { Response } from 'express';
-import { Service, Inject } from 'typedi';
+import fs from 'fs';
+import { Agent, request } from 'undici';
+import sum from 'lodash/sum';
+import path from 'path';
+import { Inject, Service } from 'typedi';
 import winston from 'winston';
 import config from '../config';
-import {
+import { TASK_COMMAND } from '../config/const';
-  AuthDataType,
-  AuthInfo,
-  AuthInstance,
-  AuthModel,
-  AuthModelInfo,
-} from '../data/auth';
-import { NotificationInfo } from '../data/notify';
-import NotificationService from './notify';
-import ScheduleService, { TaskCallbacks } from './schedule';
-import { spawn } from 'cross-spawn';
-import SockService from './sock';
-import got from 'got';
 import {
   getPid,
   killTask,
@@ -22,13 +15,28 @@ import {
   parseVersion,
   promiseExec,
   readDirs,
+  rmPath,
+  setSystemTimezone,
 } from '../config/util';
-import { TASK_COMMAND } from '../config/const';
+import {
+  DependenceModel,
+  DependenceStatus,
+  DependenceTypes,
+} from '../data/dependence';
+import { NotificationInfo } from '../data/notify';
+import {
+  AuthDataType,
+  SystemInfo,
+  SystemInstance,
+  SystemModel,
+  SystemModelInfo,
+} from '../data/system';
 import taskLimit from '../shared/pLimit';
-import tar from 'tar';
+import NotificationService from './notify';
-import path from 'path';
+import ScheduleService, { TaskCallbacks } from './schedule';
-import fs from 'fs';
+import SockService from './sock';
-import { sum } from 'lodash';
+import os from 'os';
+import dayjs from 'dayjs';
 
 @Service()
 export default class SystemService {
@@ -43,18 +51,25 @@ export default class SystemService {
 
   public async getSystemConfig() {
     const doc = await this.getDb({ type: AuthDataType.systemConfig });
-    return doc || ({} as AuthInstance);
+    return {
+      ...doc,
+      info: { ...doc.info, timezone: doc.info?.timezone || 'Asia/Shanghai' },
+    };
   }
 
-  private async updateAuthDb(payload: AuthInfo): Promise<AuthInstance> {
+  private async updateAuthDb(payload: SystemInfo): Promise<SystemInfo> {
-    await AuthModel.upsert({ ...payload });
+    const { id, ...others } = payload;
-    const doc = await this.getDb({ type: payload.type });
+    await SystemModel.update(others, { where: { id } });
+    const doc = await this.getDb({ id });
     return doc;
   }
 
-  public async getDb(query: any): Promise<AuthInstance> {
+  public async getDb(query: any): Promise<SystemInfo> {
-    const doc: any = await AuthModel.findOne({ where: { ...query } });
+    const doc = await SystemModel.findOne({ where: query });
-    return doc && doc.get({ plain: true });
+    if (!doc) {
+      throw new Error(`System ${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
   public async updateNotificationMode(notificationInfo: NotificationInfo) {
@@ -75,45 +90,203 @@ export default class SystemService {
     }
   }
 
-  public async updateSystemConfig(info: AuthModelInfo) {
+  public async updateLogRemoveFrequency(info: SystemModelInfo) {
     const oDoc = await this.getSystemConfig();
     const result = await this.updateAuthDb({
       ...oDoc,
-      type: AuthDataType.systemConfig,
+      info: { ...oDoc.info, ...info },
-      info,
     });
-    if (info.logRemoveFrequency) {
+    const cron = {
-      const cron = {
+      id: result.id as number,
-        id: result.id,
+      name: '删除日志',
-        name: '删除日志',
+      command: `ql rmlog ${info.logRemoveFrequency}`,
-        command: `ql rmlog ${info.logRemoveFrequency}`,
+      runOrigin: 'system' as const,
-      };
+    };
+    if (oDoc.info?.logRemoveFrequency) {
       await this.scheduleService.cancelIntervalTask(cron);
-      if (info.logRemoveFrequency > 0) {
-        this.scheduleService.createIntervalTask(cron, {
-          days: info.logRemoveFrequency,
-        });
-      }
     }
+    if (info.logRemoveFrequency && info.logRemoveFrequency > 0) {
+      this.scheduleService.createIntervalTask(
+        cron,
+        {
+          days: info.logRemoveFrequency,
+        },
+        true,
+      );
+    }
+    return { code: 200, data: info };
+  }
+
+  public async updateCronConcurrency(info: SystemModelInfo) {
+    const oDoc = await this.getSystemConfig();
+    await this.updateAuthDb({
+      ...oDoc,
+      info: { ...oDoc.info, ...info },
+    });
     if (info.cronConcurrency) {
       await taskLimit.setCustomLimit(info.cronConcurrency);
     }
     return { code: 200, data: info };
   }
 
+  public async updateDependenceProxy(info: SystemModelInfo) {
+    const oDoc = await this.getSystemConfig();
+    await this.updateAuthDb({
+      ...oDoc,
+      info: { ...oDoc.info, ...info },
+    });
+    if (info.dependenceProxy) {
+      await fs.promises.writeFile(
+        config.dependenceProxyFile,
+        `export http_proxy="${info.dependenceProxy}"\nexport https_proxy="${info.dependenceProxy}"`,
+      );
+    } else {
+      await fs.promises.rm(config.dependenceProxyFile);
+    }
+    return { code: 200, data: info };
+  }
+
+  public async updateNodeMirror(info: SystemModelInfo, res?: Response) {
+    const oDoc = await this.getSystemConfig();
+    await this.updateAuthDb({
+      ...oDoc,
+      info: { ...oDoc.info, ...info },
+    });
+    let cmd = 'pnpm config delete registry';
+    if (info.nodeMirror) {
+      cmd = `pnpm config set registry ${info.nodeMirror}`;
+    }
+    let command = `cd && ${cmd}`;
+    const docs = await DependenceModel.findAll({
+      where: {
+        type: DependenceTypes.nodejs,
+        status: DependenceStatus.installed,
+      },
+    });
+    if (docs.length > 0) {
+      command += ` && pnpm i -g`;
+    }
+    this.scheduleService.runTask(
+      command,
+      {
+        onStart: async (cp) => {
+          res?.setHeader('QL-Task-Pid', `${cp.pid}`);
+          res?.end();
+        },
+        onEnd: async () => {
+          this.sockService.sendMessage({
+            type: 'updateNodeMirror',
+            message: 'update node mirror end',
+          });
+        },
+        onError: async (message: string) => {
+          this.sockService.sendMessage({ type: 'updateNodeMirror', message });
+        },
+        onLog: async (message: string) => {
+          this.sockService.sendMessage({ type: 'updateNodeMirror', message });
+        },
+      },
+      {
+        command,
+        id: 'update-node-mirror',
+        runOrigin: 'system',
+      },
+    );
+  }
+
+  public async updatePythonMirror(info: SystemModelInfo) {
+    const oDoc = await this.getSystemConfig();
+    await this.updateAuthDb({
+      ...oDoc,
+      info: { ...oDoc.info, ...info },
+    });
+    let cmd = 'pip config unset global.index-url';
+    if (info.pythonMirror) {
+      cmd = `pip3 config set global.index-url ${info.pythonMirror}`;
+    }
+    await promiseExec(cmd);
+    return { code: 200, data: info };
+  }
+
+  public async updateLinuxMirror(
+    info: SystemModelInfo,
+    res?: Response,
+    onEnd?: () => void,
+  ) {
+    const oDoc = await this.getSystemConfig();
+    await this.updateAuthDb({
+      ...oDoc,
+      info: { ...oDoc.info, ...info },
+    });
+    let defaultDomain = 'https://dl-cdn.alpinelinux.org';
+    let targetDomain = 'https://dl-cdn.alpinelinux.org';
+    if (os.platform() !== 'linux') {
+      return;
+    }
+    const content = await fs.promises.readFile('/etc/apk/repositories', {
+      encoding: 'utf-8',
+    });
+    const domainMatch = content.match(/(http.*)\/alpine\/.*/);
+    if (domainMatch) {
+      defaultDomain = domainMatch[1];
+    }
+    if (info.linuxMirror) {
+      targetDomain = info.linuxMirror;
+    }
+    const command = `sed -i 's/${defaultDomain.replace(
+      /\//g,
+      '\\/',
+    )}/${targetDomain.replace(
+      /\//g,
+      '\\/',
+    )}/g' /etc/apk/repositories && apk update -f`;
+
+    this.scheduleService.runTask(
+      command,
+      {
+        onStart: async (cp) => {
+          res?.setHeader('QL-Task-Pid', `${cp.pid}`);
+          res?.end();
+        },
+        onEnd: async () => {
+          this.sockService.sendMessage({
+            type: 'updateLinuxMirror',
+            message: 'update linux mirror end',
+          });
+          onEnd?.();
+        },
+        onError: async (message: string) => {
+          this.sockService.sendMessage({ type: 'updateLinuxMirror', message });
+        },
+        onLog: async (message: string) => {
+          this.sockService.sendMessage({ type: 'updateLinuxMirror', message });
+        },
+      },
+      {
+        command,
+        id: 'update-linux-mirror',
+        runOrigin: 'system',
+      },
+    );
+  }
+
   public async checkUpdate() {
     try {
       const currentVersionContent = await parseVersion(config.versionFile);
 
       let lastVersionContent;
       try {
-        const result = await got.get(
+        const { body } = await request(
           `${config.lastVersionFile}?t=${Date.now()}`,
           {
-            timeout: 30000,
+            dispatcher: new Agent({
+              keepAliveTimeout: 30000,
+              keepAliveMaxTimeout: 30000,
+            }),
           },
         );
-        lastVersionContent = await parseContentVersion(result.body);
+        const text = await body.text();
+        lastVersionContent = parseContentVersion(text);
       } catch (error) {}
 
       if (!lastVersionContent) {
@@ -160,7 +333,7 @@ export default class SystemService {
   }
 
   public async updateSystem() {
-    const cp = spawn('ql -l update false', { shell: '/bin/bash' });
+    const cp = spawn('real_time=true ql update false', { shell: '/bin/bash' });
 
     cp.stdout.on('data', (data) => {
       this.sockService.sendMessage({
@@ -186,30 +359,17 @@ export default class SystemService {
     return { code: 200 };
   }
 
-  public async reloadSystem(target: 'system' | 'data') {
+  public async reloadSystem(target?: 'system' | 'data') {
-    const cp = spawn(`ql -l reload ${target || ''}`, { shell: '/bin/bash' });
+    const cmd = `real_time=true ql reload ${target || ''}`;
-
+    const cp = spawn(cmd, {
-    cp.stdout.on('data', (data) => {
+      shell: '/bin/bash',
-      this.sockService.sendMessage({
+      detached: true,
-        type: 'reloadSystem',
+      stdio: 'ignore',
-        message: data.toString(),
-      });
     });
-
+    cp.unref();
-    cp.stderr.on('data', (data) => {
+    setTimeout(() => {
-      this.sockService.sendMessage({
+      process.exit(0);
-        type: 'reloadSystem',
-        message: data.toString(),
-      });
     });
-
-    cp.on('error', (err) => {
-      this.sockService.sendMessage({
-        type: 'reloadSystem',
-        message: JSON.stringify(err),
-      });
-    });
-
     return { code: 200 };
   }
 
@@ -222,17 +382,15 @@ export default class SystemService {
     }
   }
 
-  public async run(
+  public async run({ command }: { command: string }, callback: TaskCallbacks) {
-    { command, logPath }: { command: string; logPath: string },
-    callback: TaskCallbacks,
-  ) {
     if (!command.startsWith(TASK_COMMAND)) {
       command = `${TASK_COMMAND} ${command}`;
     }
-    this.scheduleService.runTask(
+    this.scheduleService.runTask(`real_time=true ${command}`, callback, {
-      `real_log_path=${logPath} real_time=true ${command}`,
+      command,
-      callback,
+      id: command.replace(/ /g, '-'),
-    );
+      runOrigin: 'system',
+    });
   }
 
   public async stop({ command, pid }: { command: string; pid: number }) {
@@ -259,9 +417,8 @@ export default class SystemService {
 
   public async exportData(res: Response) {
     try {
-      await tar.create(
+      await promiseExec(
-        { gzip: true, file: config.dataTgzFile, cwd: config.rootPath },
+        `cd ${config.dataPath} && cd ../ && tar -zcvf ${config.dataTgzFile} data/`,
-        ['data'],
       );
       res.download(config.dataTgzFile);
     } catch (error: any) {
@@ -272,16 +429,34 @@ export default class SystemService {
   public async importData() {
     try {
       await promiseExec(`rm -rf ${path.join(config.tmpPath, 'data')}`);
-      await tar.x({ file: config.dataTgzFile, cwd: config.tmpPath });
+      const res = await promiseExec(
-      return { code: 200 };
+        `cd ${config.tmpPath} && tar -zxvf ${config.dataTgzFile}`,
+      );
+      return { code: 200, data: res };
     } catch (error: any) {
       return { code: 400, message: error.message };
     }
   }
 
-  public async getSystemLog(res: Response) {
+  public async getSystemLog(
-    const result = readDirs(config.systemLogPath, config.systemLogPath);
+    res: Response,
-    const logs = result.reverse().filter((x) => x.title.endsWith('.log'));
+    query: {
+      startTime?: string;
+      endTime?: string;
+    },
+  ) {
+    const startTime = dayjs(query.startTime || undefined)
+      .startOf('d')
+      .valueOf();
+    const endTime = dayjs(query.endTime || undefined)
+      .endOf('d')
+      .valueOf();
+    const result = await readDirs(config.systemLogPath, config.systemLogPath);
+    const logs = result
+      .reverse()
+      .filter((x) => x.title.endsWith('.log'))
+      .filter((x) => x.createTime >= startTime && x.createTime <= endTime);
+
     res.set({
       'Content-Length': sum(logs.map((x) => x.size)),
     });
@@ -303,4 +478,29 @@ export default class SystemService {
       }
     })(res, logs);
   }
+
+  public async deleteSystemLog() {
+    const result = await readDirs(config.systemLogPath, config.systemLogPath);
+    const logs = result.reverse().filter((x) => x.title.endsWith('.log'));
+    for (const log of logs) {
+      await rmPath(path.join(config.systemLogPath, log.title));
+    }
+  }
+
+  public async updateTimezone(info: SystemModelInfo) {
+    if (!info.timezone) {
+      info.timezone = 'Asia/Shanghai';
+    }
+    const oDoc = await this.getSystemConfig();
+    await this.updateAuthDb({
+      ...oDoc,
+      info: { ...oDoc.info, ...info },
+    });
+    const success = await setSystemTimezone(info.timezone);
+    if (success) {
+      return { code: 200, data: info };
+    } else {
+      return { code: 400, message: '设置时区失败' };
+    }
+  }
 }

back/services/user.ts

@@ -1,29 +1,29 @@
 import { Service, Inject } from 'typedi';
 import winston from 'winston';
-import {
+import { createRandomString } from '../config/util';
-  createRandomString,
-  fileExist,
-  getNetIp,
-  getPlatform,
-  safeJSONParse,
-} from '../config/util';
 import config from '../config';
-import * as fs from 'fs';
 import jwt from 'jsonwebtoken';
 import { authenticator } from '@otplib/preset-default';
 import {
   AuthDataType,
-  AuthInfo,
+  SystemInfo,
-  AuthModel,
+  SystemModel,
-  AuthModelInfo,
+  SystemModelInfo,
   LoginStatus,
-} from '../data/auth';
+  AuthInfo,
+} from '../data/system';
 import { NotificationInfo } from '../data/notify';
 import NotificationService from './notify';
 import { Request } from 'express';
 import ScheduleService from './schedule';
 import SockService from './sock';
 import dayjs from 'dayjs';
+import IP2Region from 'ip2region';
+import requestIp from 'request-ip';
+import uniq from 'lodash/uniq';
+import pickBy from 'lodash/pickBy';
+import isNil from 'lodash/isNil';
+import { shareStore } from '../shared/store';
 
 @Service()
 export default class UserService {
@@ -44,158 +44,152 @@ export default class UserService {
     req: Request,
     needTwoFactor = true,
   ): Promise<any> {
-    if (!fs.existsSync(config.authConfigFile)) {
+    let { username, password } = payloads;
-      return this.initAuthInfo();
+    const content = await this.getAuthInfo();
+    const timestamp = Date.now();
+    let {
+      username: cUsername,
+      password: cPassword,
+      retries = 0,
+      lastlogon,
+      lastip,
+      lastaddr,
+      twoFactorActivated,
+      tokens = {},
+      platform,
+    } = content;
+    const retriesTime = Math.pow(3, retries) * 1000;
+    if (retries > 2 && timestamp - lastlogon < retriesTime) {
+      const waitTime = Math.ceil(
+        (retriesTime - (timestamp - lastlogon)) / 1000,
+      );
+      return {
+        code: 410,
+        message: `失败次数过多，请${waitTime}秒后重试`,
+        data: waitTime,
+      };
     }
 
-    let { username, password } = payloads;
+    if (
-    const content = this.getAuthInfo();
+      username === cUsername &&
-    const timestamp = Date.now();
+      password === cPassword &&
-    if (content) {
+      twoFactorActivated &&
-      let {
+      needTwoFactor
-        username: cUsername,
+    ) {
-        password: cPassword,
+      await this.updateAuthInfo(content, {
-        retries = 0,
+        isTwoFactorChecking: true,
-        lastlogon,
+      });
-        lastip,
+      return {
-        lastaddr,
+        code: 420,
-        twoFactorActivated,
+        message: '',
-        twoFactorActived,
+      };
-        tokens = {},
+    }
-        platform,
-      } = content;
-      // patch old field
-      twoFactorActivated = twoFactorActivated || twoFactorActived;
 
-      if (
+    const ip = requestIp.getClientIp(req) || '';
-        (cUsername === 'admin' && cPassword === 'admin') ||
+    const query = new IP2Region();
-        !cUsername ||
+    const ipAddress = query.search(ip);
-        !cPassword
+    let address = '';
-      ) {
+    if (ipAddress) {
-        return this.initAuthInfo();
+      const { country, province, city, isp } = ipAddress;
-      }
+      address = uniq([country, province, city, isp]).filter(Boolean).join(' ');
+    }
+    if (username === cUsername && password === cPassword) {
+      const data = createRandomString(50, 100);
+      const expiration = twoFactorActivated ? '60d' : '20d';
+      let token = jwt.sign({ data }, config.jwt.secret, {
+        expiresIn: config.jwt.expiresIn || expiration,
+        algorithm: 'HS384',
+      });
 
-      const retriesTime = Math.pow(3, retries) * 1000;
+      await this.updateAuthInfo(content, {
-      if (retries > 2 && timestamp - lastlogon < retriesTime) {
+        token,
-        const waitTime = Math.ceil(
+        tokens: {
-          (retriesTime - (timestamp - lastlogon)) / 1000,
+          ...tokens,
-        );
+          [req.platform]: token,
+        },
+        lastlogon: timestamp,
+        retries: 0,
+        lastip: ip,
+        lastaddr: address,
+        platform: req.platform,
+        isTwoFactorChecking: false,
+      });
+      this.notificationService.notify(
+        '登录通知',
+        `你于${dayjs(timestamp).format('YYYY-MM-DD HH:mm:ss')}在 ${address} ${
+          req.platform
+        }端 登录成功，ip地址 ${ip}`,
+      );
+      await this.insertDb({
+        type: AuthDataType.loginLog,
+        info: {
+          timestamp,
+          address,
+          ip,
+          platform: req.platform,
+          status: LoginStatus.success,
+        },
+      });
+      this.getLoginLog();
+      return {
+        code: 200,
+        data: {
+          token,
+          lastip,
+          lastaddr,
+          lastlogon,
+          retries,
+          platform,
+        },
+      };
+    } else {
+      await this.updateAuthInfo(content, {
+        retries: retries + 1,
+        lastlogon: timestamp,
+        lastip: ip,
+        lastaddr: address,
+        platform: req.platform,
+      });
+      this.notificationService.notify(
+        '登录通知',
+        `你于${dayjs(timestamp).format('YYYY-MM-DD HH:mm:ss')}在 ${address} ${
+          req.platform
+        }端 登录失败，ip地址 ${ip}`,
+      );
+      await this.insertDb({
+        type: AuthDataType.loginLog,
+        info: {
+          timestamp,
+          address,
+          ip,
+          platform: req.platform,
+          status: LoginStatus.fail,
+        },
+      });
+      this.getLoginLog();
+      if (retries > 2) {
+        const waitTime = Math.round(Math.pow(3, retries + 1));
         return {
           code: 410,
           message: `失败次数过多，请${waitTime}秒后重试`,
           data: waitTime,
         };
-      }
-
-      if (
-        username === cUsername &&
-        password === cPassword &&
-        twoFactorActivated &&
-        needTwoFactor
-      ) {
-        this.updateAuthInfo(content, {
-          isTwoFactorChecking: true,
-        });
-        return {
-          code: 420,
-          message: '',
-        };
-      }
-
-      const { ip, address } = await getNetIp(req);
-      if (username === cUsername && password === cPassword) {
-        const data = createRandomString(50, 100);
-        const expiration = twoFactorActivated ? 60 : 20;
-        let token = jwt.sign({ data }, config.secret as any, {
-          expiresIn: 60 * 60 * 24 * expiration,
-          algorithm: 'HS384',
-        });
-
-        this.updateAuthInfo(content, {
-          token,
-          tokens: {
-            ...tokens,
-            [req.platform]: token,
-          },
-          lastlogon: timestamp,
-          retries: 0,
-          lastip: ip,
-          lastaddr: address,
-          platform: req.platform,
-          isTwoFactorChecking: false,
-        });
-        await this.notificationService.notify(
-          '登录通知',
-          `你于${dayjs(timestamp).format('YYYY-MM-DD HH:mm:ss')}在 ${address} ${
-            req.platform
-          }端 登录成功，ip地址 ${ip}`,
-        );
-        await this.getLoginLog();
-        await this.insertDb({
-          type: AuthDataType.loginLog,
-          info: {
-            timestamp,
-            address,
-            ip,
-            platform: req.platform,
-            status: LoginStatus.success,
-          },
-        });
-        return {
-          code: 200,
-          data: { token, lastip, lastaddr, lastlogon, retries, platform },
-        };
       } else {
-        this.updateAuthInfo(content, {
+        return { code: 400, message: config.authError };
-          retries: retries + 1,
-          lastlogon: timestamp,
-          lastip: ip,
-          lastaddr: address,
-          platform: req.platform,
-        });
-        await this.notificationService.notify(
-          '登录通知',
-          `你于${dayjs(timestamp).format('YYYY-MM-DD HH:mm:ss')}在 ${address} ${
-            req.platform
-          }端 登录失败，ip地址 ${ip}`,
-        );
-        await this.getLoginLog();
-        await this.insertDb({
-          type: AuthDataType.loginLog,
-          info: {
-            timestamp,
-            address,
-            ip,
-            platform: req.platform,
-            status: LoginStatus.fail,
-          },
-        });
-        if (retries > 2) {
-          const waitTime = Math.round(Math.pow(3, retries + 1));
-          return {
-            code: 410,
-            message: `失败次数过多，请${waitTime}秒后重试`,
-            data: waitTime,
-          };
-        } else {
-          return { code: 400, message: config.authError };
-        }
       }
-    } else {
-      return this.initAuthInfo();
     }
   }
 
   public async logout(platform: string): Promise<any> {
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
-    this.updateAuthInfo(authInfo, {
+    await this.updateAuthInfo(authInfo, {
       token: '',
       tokens: { ...authInfo.tokens, [platform]: '' },
     });
   }
 
-  public async getLoginLog(): Promise<Array<AuthModelInfo | undefined>> {
+  public async getLoginLog(): Promise<Array<SystemModelInfo | undefined>> {
-    const docs = await AuthModel.findAll({
+    const docs = await SystemModel.findAll({
       where: { type: AuthDataType.loginLog },
     });
     if (docs && docs.length > 0) {
@@ -203,8 +197,9 @@ export default class UserService {
         (a, b) => b.info!.timestamp! - a.info!.timestamp!,
       );
       if (result.length > 100) {
-        await AuthModel.destroy({
+        const ids = result.slice(100).map((x) => x.id!);
-          where: { id: result[result.length - 1].id },
+        await SystemModel.destroy({
+          where: { id: ids },
         });
       }
       return result.map((x) => x.info);
@@ -212,25 +207,11 @@ export default class UserService {
     return [];
   }
 
-  private async insertDb(payload: AuthInfo): Promise<AuthInfo> {
+  private async insertDb(payload: SystemInfo): Promise<SystemInfo> {
-    const doc = await AuthModel.create({ ...payload }, { returning: true });
+    const doc = await SystemModel.create({ ...payload }, { returning: true });
     return doc;
   }
 
-  private initAuthInfo() {
-    fs.writeFileSync(
-      config.authConfigFile,
-      JSON.stringify({
-        username: 'admin',
-        password: 'admin',
-      }),
-    );
-    return {
-      code: 100,
-      message: '未找到认证文件，重新初始化',
-    };
-  }
-
   public async updateUsernameAndPassword({
     username,
     password,
@@ -241,47 +222,33 @@ export default class UserService {
     if (password === 'admin') {
       return { code: 400, message: '密码不能设置为admin' };
     }
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
-    this.updateAuthInfo(authInfo, { username, password });
+    await this.updateAuthInfo(authInfo, { username, password });
     return { code: 200, message: '更新成功' };
   }
 
   public async updateAvatar(avatar: string) {
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
-    this.updateAuthInfo(authInfo, { avatar });
+    await this.updateAuthInfo(authInfo, { avatar });
     return { code: 200, data: avatar, message: '更新成功' };
   }
 
-  public async getUserInfo(): Promise<any> {
+  public async initTwoFactor() {
-    const authFileExist = await fileExist(config.authConfigFile);
-    if (!authFileExist) {
-      fs.writeFileSync(
-        config.authConfigFile,
-        JSON.stringify({
-          username: 'admin',
-          password: 'admin',
-        }),
-      );
-    }
-    return this.getAuthInfo();
-  }
-
-  public initTwoFactor() {
     const secret = authenticator.generateSecret();
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
     const otpauth = authenticator.keyuri(authInfo.username, 'qinglong', secret);
-    this.updateAuthInfo(authInfo, { twoFactorSecret: secret });
+    await this.updateAuthInfo(authInfo, { twoFactorSecret: secret });
     return { secret, url: otpauth };
   }
 
-  public activeTwoFactor(code: string) {
+  public async activeTwoFactor(code: string) {
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
     const isValid = authenticator.verify({
       token: code,
       secret: authInfo.twoFactorSecret,
     });
     if (isValid) {
-      this.updateAuthInfo(authInfo, { twoFactorActivated: true });
+      await this.updateAuthInfo(authInfo, { twoFactorActivated: true });
     }
     return isValid;
   }
@@ -294,7 +261,7 @@ export default class UserService {
     }: { username: string; password: string; code: string },
     req: any,
   ) {
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
     const { isTwoFactorChecking, twoFactorSecret } = authInfo;
     if (!isTwoFactorChecking) {
       return { code: 450, message: '未知错误' };
@@ -306,8 +273,17 @@ export default class UserService {
     if (isValid) {
       return this.login({ username, password }, req, false);
     } else {
-      const { ip, address } = await getNetIp(req);
+      const ip = requestIp.getClientIp(req) || '';
-      this.updateAuthInfo(authInfo, {
+      const query = new IP2Region();
+      const ipAddress = query.search(ip);
+      let address = '';
+      if (ipAddress) {
+        const { country, province, city, isp } = ipAddress;
+        address = uniq([country, province, city, isp])
+          .filter(Boolean)
+          .join(' ');
+      }
+      await this.updateAuthInfo(authInfo, {
         lastip: ip,
         lastaddr: address,
         platform: req.platform,
@@ -316,50 +292,58 @@ export default class UserService {
     }
   }
 
-  public deactiveTwoFactor() {
+  public async deactiveTwoFactor() {
-    const authInfo = this.getAuthInfo();
+    const authInfo = await this.getAuthInfo();
-    this.updateAuthInfo(authInfo, {
+    await this.updateAuthInfo(authInfo, {
       twoFactorActivated: false,
-      twoFactorActived: false,
       twoFactorSecret: '',
     });
     return true;
   }
 
-  private getAuthInfo() {
+  public async getAuthInfo() {
-    const content = fs.readFileSync(config.authConfigFile, 'utf8');
+    const authInfo = await shareStore.getAuthInfo();
-    return safeJSONParse(content);
+    if (authInfo) {
+      return authInfo;
+    }
+    const doc = await this.getDb({ type: AuthDataType.authConfig });
+    return (doc.info || {}) as AuthInfo;
   }
 
-  private updateAuthInfo(authInfo: any, info: any) {
+  private async updateAuthInfo(authInfo: AuthInfo, info: Partial<AuthInfo>) {
-    fs.writeFileSync(
+    const result = { ...authInfo, ...info };
-      config.authConfigFile,
+    await shareStore.updateAuthInfo(result);
-      JSON.stringify({ ...authInfo, ...info }),
+    await this.updateAuthDb({
-    );
+      type: AuthDataType.authConfig,
+      info: result,
+    });
   }
 
   public async getNotificationMode(): Promise<NotificationInfo> {
     const doc = await this.getDb({ type: AuthDataType.notification });
-    return (doc && doc.info) || {};
+    return (doc.info || {}) as NotificationInfo;
   }
 
-  private async updateAuthDb(payload: AuthInfo): Promise<any> {
+  private async updateAuthDb(payload: SystemInfo): Promise<any> {
-    let doc = await AuthModel.findOne({ type: payload.type });
+    let doc = await SystemModel.findOne({ where: { type: payload.type } });
     if (doc) {
-      const updateResult = await AuthModel.update(payload, {
+      const updateResult = await SystemModel.update(payload, {
         where: { id: doc.id },
         returning: true,
       });
       doc = updateResult[1][0];
     } else {
-      doc = await AuthModel.create(payload, { returning: true });
+      doc = await SystemModel.create(payload, { returning: true });
     }
     return doc;
   }
 
-  public async getDb(query: any): Promise<any> {
+  public async getDb(query: any): Promise<SystemInfo> {
-    const doc: any = await AuthModel.findOne({ where: { ...query } });
+    const doc = await SystemModel.findOne({ where: { ...query } });
-    return doc && (doc.get({ plain: true }) as any);
+    if (!doc) {
+      throw new Error(`${JSON.stringify(query)} not found`);
+    }
+    return doc.get({ plain: true });
   }
 
   public async updateNotificationMode(notificationInfo: NotificationInfo) {
@@ -379,4 +363,20 @@ export default class UserService {
       return { code: 400, message: '通知发送失败，请检查参数' };
     }
   }
+
+  public async resetAuthInfo(info: Partial<AuthInfo>) {
+    const { retries, twoFactorActivated, password, username } = info;
+    const authInfo = await this.getAuthInfo();
+    const payload = pickBy(
+      {
+        retries,
+        twoFactorActivated,
+        password,
+        username,
+      },
+      (x) => !isNil(x),
+    );
+
+    await this.updateAuthInfo(authInfo, payload);
+  }
 }

back/shared/interface.ts

@@ -0,0 +1,33 @@
+import { Dependence } from '../data/dependence';
+import { ICron } from '../protos/cron';
+
+export type Override<
+  T,
+  K extends Partial<{ [P in keyof T]: any }> | string,
+> = K extends string
+  ? Omit<T, K> & { [P in keyof T]: T[P] | unknown }
+  : Omit<T, keyof K> & K;
+
+export type TCron = Override<Partial<ICron>, { id: string }>;
+
+export interface IDependencyFn<T> {
+  (): Promise<T>;
+  dependency?: Dependence;
+}
+
+export interface ICronFn<T> {
+  (): Promise<T>;
+  cron?: TCron;
+}
+
+export interface ISchedule {
+  schedule?: string;
+  name?: string;
+  command?: string;
+  id: string;
+}
+
+export interface IScheduleFn<T> {
+  (): Promise<T>;
+  schedule?: ISchedule;
+}

back/shared/pLimit.ts

@@ -1,53 +1,222 @@
-import pLimit from 'p-limit';
+import PQueue, { QueueAddOptions } from 'p-queue-cjs';
 import os from 'os';
-import { AuthDataType, AuthModel } from '../data/auth';
+import { AuthDataType, SystemModel } from '../data/system';
 import Logger from '../loaders/logger';
-import dayjs from 'dayjs';
+import { Dependence } from '../data/dependence';
+import NotificationService from '../services/notify';
+import {
+  ICronFn,
+  IDependencyFn,
+  ISchedule,
+  IScheduleFn,
+  TCron,
+} from './interface';
+import config from '../config';
+import { credentials } from '@grpc/grpc-js';
+import { ApiClient } from '../protos/api';
 
 class TaskLimit {
-  private oneLimit = pLimit(1);
+  private dependenyLimit = new PQueue({ concurrency: 1 });
-  private updateLogLimit = pLimit(1);
+  private queuedDependencyIds = new Set<number>([]);
-  private cpuLimit = pLimit(Math.max(os.cpus().length, 4));
+  private queuedCrons = new Map<string, ICronFn<any>[]>();
+  private repeatCronNotifyMap = new Map<string, number>();
+  private updateLogLimit = new PQueue({ concurrency: 1 });
+  private cronLimit = new PQueue({
+    concurrency: Math.max(os.cpus().length, 4),
+  });
+  private manualCronoLimit = new PQueue({
+    concurrency: Math.max(os.cpus().length, 4),
+  });
+  private subscriptionLimit = new PQueue({
+    concurrency: Math.max(os.cpus().length, 4),
+  });
+  private scriptLimit = new PQueue({
+    concurrency: Math.max(os.cpus().length, 4),
+  });
+  private systemLimit = new PQueue({
+    concurrency: Math.max(os.cpus().length, 4),
+  });
+  private client = new ApiClient(
+    `0.0.0.0:${config.grpcPort}`,
+    credentials.createInsecure(),
+    { 'grpc.enable_http_proxy': 0 },
+  );
 
-  get cpuLimitActiveCount() {
+  get cronLimitActiveCount() {
-    return this.cpuLimit.activeCount;
+    return this.cronLimit.pending;
   }
 
-  get cpuLimitPendingCount() {
+  get cronLimitPendingCount() {
-    return this.cpuLimit.pendingCount;
+    return this.cronLimit.size;
   }
 
+  get firstDependencyId() {
+    return [...this.queuedDependencyIds.values()][0];
+  }
+
+  private notificationService: NotificationService = new NotificationService();
+
   constructor() {
     this.setCustomLimit();
+    this.handleEvents();
+  }
+
+  private handleEvents() {
+    this.cronLimit.on('add', () => {
+      Logger.info(
+        `[schedule][任务加入队列] 运行中任务数: ${this.cronLimitActiveCount}, 等待中任务数: ${this.cronLimitPendingCount}`,
+      );
+    });
+    this.cronLimit.on('active', () => {
+      Logger.info(
+        `[schedule][开始处理任务] 运行中任务数: ${
+          this.cronLimitActiveCount + 1
+        }, 等待中任务数: ${this.cronLimitPendingCount}`,
+      );
+    });
+    this.cronLimit.on('completed', (param) => {
+      Logger.info(`[schedule][任务处理成功] 参数 ${JSON.stringify(param)}`);
+    });
+    this.cronLimit.on('error', (error) => {
+      Logger.error(`[schedule][任务处理错误] 参数 ${JSON.stringify(error)}`);
+    });
+    this.cronLimit.on('next', () => {
+      Logger.info(
+        `[schedule][任务处理结束] 运行中任务数: ${this.cronLimitActiveCount}, 等待中任务数: ${this.cronLimitPendingCount}`,
+      );
+    });
+    this.cronLimit.on('idle', () => {
+      Logger.info(`[schedule][任务队列] 空闲中...`);
+    });
+  }
+
+  public removeQueuedDependency(dependency: Dependence) {
+    if (this.queuedDependencyIds.has(dependency.id!)) {
+      this.queuedDependencyIds.delete(dependency.id!);
+    }
+  }
+
+  public removeQueuedCron(id: string) {
+    if (this.queuedCrons.has(id)) {
+      const runs = this.queuedCrons.get(id);
+      if (runs && runs.length > 0) {
+        runs.pop();
+        this.queuedCrons.set(id, runs);
+      }
+    }
   }
 
   public async setCustomLimit(limit?: number) {
     if (limit) {
-      this.cpuLimit = pLimit(limit);
+      this.cronLimit.concurrency = limit;
+      this.manualCronoLimit.concurrency = limit;
       return;
     }
-    await AuthModel.sync();
+    await SystemModel.sync();
-    const doc = await AuthModel.findOne({
+    const doc = await SystemModel.findOne({
       where: { type: AuthDataType.systemConfig },
     });
     if (doc?.info?.cronConcurrency) {
-      this.cpuLimit = pLimit(doc?.info?.cronConcurrency);
+      this.cronLimit.concurrency = doc.info.cronConcurrency;
+      this.manualCronoLimit.concurrency = doc.info.cronConcurrency;
     }
   }
 
-  public runWithCpuLimit<T>(fn: () => Promise<T>): Promise<T> {
+  public async runWithCronLimit<T>(
-    Logger.info(
+    cron: TCron,
-      `[schedule][任务加入队列] 运行中任务数: ${this.cpuLimitActiveCount}, 等待中任务数: ${this.cpuLimitPendingCount}`,
+    fn: ICronFn<T>,
-    );
+    options?: Partial<QueueAddOptions>,
-    return this.cpuLimit(fn);
+  ): Promise<T | void> {
+    fn.cron = cron;
+    let runs = this.queuedCrons.get(cron.id);
+    const result = runs?.length ? [...runs, fn] : [fn];
+    const repeatTimes = this.repeatCronNotifyMap.get(cron.id) || 0;
+    if (result?.length > 5) {
+      if (repeatTimes < 3) {
+        this.repeatCronNotifyMap.set(cron.id, repeatTimes + 1);
+        this.client.systemNotify(
+          {
+            title: '任务重复运行',
+            content: `任务：${cron.name}，命令：${cron.command}，定时：${cron.schedule}，处于运行中的超过 5 个，请检查定时设置`,
+          },
+          (err, res) => {
+            if (err) {
+              Logger.error(
+                `[schedule][任务重复运行] 通知失败 ${JSON.stringify(err)}`,
+              );
+            }
+          },
+        );
+      }
+      Logger.warn(`[schedule][任务重复运行] 参数 ${JSON.stringify(cron)}`);
+      return;
+    }
+    this.queuedCrons.set(cron.id, result);
+    return this.cronLimit.add(fn, options);
   }
 
-  public runOneByOne<T>(fn: () => Promise<T>): Promise<T> {
+  public async manualRunWithCronLimit<T>(
-    return this.oneLimit(fn);
+    fn: () => Promise<T>,
+    options?: Partial<QueueAddOptions>,
+  ): Promise<T | void> {
+    return this.manualCronoLimit.add(fn, options);
   }
 
-  public updateDepLog<T>(fn: () => Promise<T>): Promise<T> {
+  public async runWithSubscriptionLimit<T>(
-    return this.updateLogLimit(fn);
+    schedule: TCron,
+    fn: IScheduleFn<T>,
+    options?: Partial<QueueAddOptions>,
+  ): Promise<T | void> {
+    fn.schedule = schedule;
+    return this.subscriptionLimit.add(fn, options);
+  }
+
+  public async runWithSystemLimit<T>(
+    schedule: TCron,
+    fn: IScheduleFn<T>,
+    options?: Partial<QueueAddOptions>,
+  ): Promise<T | void> {
+    fn.schedule = schedule;
+    return this.systemLimit.add(fn, options);
+  }
+
+  public async runWithScriptLimit<T>(
+    schedule: ISchedule,
+    fn: IScheduleFn<T>,
+    options?: Partial<QueueAddOptions>,
+  ): Promise<T | void> {
+    fn.schedule = schedule;
+    return this.scriptLimit.add(fn, options);
+  }
+
+  public async waitDependencyQueueDone(): Promise<void> {
+    if (this.dependenyLimit.size === 0 && this.dependenyLimit.pending === 0) {
+      return;
+    }
+    return new Promise((resolve) => {
+      const onIdle = () => {
+        this.dependenyLimit.removeListener('idle', onIdle);
+        resolve();
+      };
+      this.dependenyLimit.on('idle', onIdle);
+    });
+  }
+
+  public runDependeny<T>(
+    dependency: Dependence,
+    fn: IDependencyFn<T>,
+    options?: Partial<QueueAddOptions>,
+  ): Promise<T | void> {
+    this.queuedDependencyIds.add(dependency.id!);
+    fn.dependency = dependency;
+    return this.dependenyLimit.add(fn, options);
+  }
+
+  public updateDepLog<T>(
+    fn: () => Promise<T>,
+    options?: Partial<QueueAddOptions>,
+  ): Promise<T | void> {
+    return this.updateLogLimit.add(fn, options);
   }
 }
 

back/shared/runCron.ts

@@ -1,12 +1,17 @@
 import { spawn } from 'cross-spawn';
 import taskLimit from './pLimit';
 import Logger from '../loaders/logger';
+import { ICron } from '../protos/cron';
 
-export function runCron(cmd: string): Promise<number> {
+export function runCron(cmd: string, cron: ICron): Promise<number | void> {
-  return taskLimit.runWithCpuLimit(() => {
+  return taskLimit.runWithCronLimit(cron, () => {
     return new Promise(async (resolve: any) => {
-      Logger.info(`[schedule][开始执行任务] 运行命令: ${cmd}`);
+      Logger.info(
-
+        `[schedule][开始执行任务] 参数 ${JSON.stringify({
+          ...cron,
+          command: cmd,
+        })}`,
+      );
       const cp = spawn(cmd, { shell: '/bin/bash' });
 
       cp.stderr.on('data', (data) => {
@@ -24,9 +29,17 @@ export function runCron(cmd: string): Promise<number> {
         );
       });
 
-      cp.on('close', async (code) => {
+      cp.on('exit', async (code) => {
-        Logger.info(`[schedule][任务退出] ${cmd} 进程id: ${cp.pid} 退出, 退出码 ${code}`);
+        taskLimit.removeQueuedCron(cron.id);
-        resolve();
+        Logger.info(
+          '[schedule][执行任务结束] 参数: %s, 退出码: %j',
+          JSON.stringify({
+            ...cron,
+            command: cmd,
+          }),
+          code,
+        );
+        resolve({ ...cron, command: cmd, pid: cp.pid, code });
       });
     });
   });

back/shared/store.ts

@@ -0,0 +1,34 @@
+import { AuthInfo } from '../data/system';
+import { App } from '../data/open';
+import Keyv from 'keyv';
+import KeyvSqlite from '@keyv/sqlite';
+import config from '../config';
+import path from 'path';
+
+export enum EKeyv {
+  'apps' = 'apps',
+  'authInfo' = 'authInfo',
+}
+
+export interface IKeyvStore {
+  apps: App[];
+  authInfo: AuthInfo;
+}
+
+const keyvSqlite = new KeyvSqlite(path.join(config.dbPath, 'keyv.sqlite'));
+export const keyvStore = new Keyv<IKeyvStore>({ store: keyvSqlite });
+
+export const shareStore = {
+  getAuthInfo() {
+    return keyvStore.get<IKeyvStore['authInfo']>(EKeyv.authInfo);
+  },
+  updateAuthInfo(value: IKeyvStore['authInfo']) {
+    return keyvStore.set<IKeyvStore['authInfo']>(EKeyv.authInfo, value);
+  },
+  getApps() {
+    return keyvStore.get<IKeyvStore['apps']>(EKeyv.apps);
+  },
+  updateApps(apps: App[]) {
+    return keyvStore.set<IKeyvStore['apps']>(EKeyv.apps, apps);
+  },
+};

back/shared/utils.ts

@@ -0,0 +1,42 @@
+import { lock } from 'proper-lockfile';
+import os from 'os';
+import path from 'path';
+import { writeFile, open, chmod } from 'fs/promises';
+import { fileExist } from '../config/util';
+
+function getUniqueLockPath(filePath: string) {
+  const sanitizedPath = filePath
+    .replace(/[<>:"/\\|?*]/g, '_')
+    .replace(/^_/, '');
+  return path.join(os.tmpdir(), `${sanitizedPath}.ql_lock`);
+}
+
+export async function writeFileWithLock(
+  filePath: string,
+  content: string,
+  options: Parameters<typeof writeFile>[2] = {},
+) {
+  if (typeof options === 'string') {
+    options = { encoding: options };
+  }
+  if (!(await fileExist(filePath))) {
+    const fileHandle = await open(filePath, 'w');
+    fileHandle.close();
+  }
+  const lockfilePath = getUniqueLockPath(filePath);
+
+  const release = await lock(filePath, {
+    retries: {
+      retries: 10,
+      factor: 2,
+      minTimeout: 100,
+      maxTimeout: 3000,
+    },
+    lockfilePath,
+  });
+  await writeFile(filePath, content, { encoding: 'utf8', ...options });
+  if (options?.mode) {
+    await chmod(filePath, options.mode);
+  }
+  await release();
+}

back/token.ts

@@ -2,10 +2,10 @@ import 'reflect-metadata';
 import OpenService from './services/open';
 import { Container } from 'typedi';
 import LoggerInstance from './loaders/logger';
-import fs from 'fs';
 import config from './config';
 import path from 'path';
 import os from 'os';
+import { writeFileWithLock } from './shared/utils';
 
 const tokenFile = path.join(config.configPath, 'token.json');
 
@@ -25,16 +25,7 @@ async function getToken() {
 }
 
 async function writeFile(data: any) {
-  return new Promise<void>((resolve, reject) => {
+  await writeFileWithLock(tokenFile, `${JSON.stringify(data)}${os.EOL}`);
-    fs.writeFile(
-      tokenFile,
-      `${JSON.stringify(data)}${os.EOL}`,
-      { encoding: 'utf8' },
-      () => {
-        resolve();
-      },
-    );
-  });
 }
 
 getToken();

back/tsconfig.json

@@ -1,28 +1,27 @@
 {
   "compilerOptions": {
     "target": "es2017",
-    "lib": ["es2021", "esnext.asynciterable", "DOM"],
+    "lib": ["ESNext"],
     "typeRoots": [
-      "./node_modules/@types",
+      "./types",
-      "./src/types",
+      "../node_modules/celebrate/lib",
-      "./node_modules/celebrate/lib/index.d.ts"
+      "../node_modules/@types"
     ],
-    "paths": {
-      "@/*": ["./back/*"],
-    },
     "allowSyntheticDefaultImports": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
     "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
     "moduleResolution": "node",
     "module": "commonjs",
     "pretty": true,
     "sourceMap": true,
-    "outDir": "./static/build",
+    "outDir": "../static/build",
     "allowJs": true,
     "noEmit": false,
     "esModuleInterop": true
   },
-  "include": ["./back/**/*"],
+  "include": ["./**/*"],
-  "exclude": ["node_modules", "tests"]
+  "exclude": ["node_modules"]
 }

back/types/express.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="express" />
+
+export {};
+
+declare global {
+  namespace Express {
+    interface Request {
+      platform: 'desktop' | 'mobile';
+    }
+  }
+} 

back/validation/schedule.ts

@@ -0,0 +1,40 @@
+import { Joi } from 'celebrate';
+import cron_parser from 'cron-parser';
+import { ScheduleType } from '../interface/schedule';
+
+const validateSchedule = (value: string, helpers: any) => {
+  if (
+    value.startsWith(ScheduleType.ONCE) ||
+    value.startsWith(ScheduleType.BOOT)
+  ) {
+    return value;
+  }
+
+  try {
+    if (cron_parser.parseExpression(value).hasNext()) {
+      return value;
+    }
+  } catch (e) {
+    return helpers.error('any.invalid');
+  }
+  return helpers.error('any.invalid');
+};
+
+export const scheduleSchema = Joi.string()
+  .required()
+  .custom(validateSchedule)
+  .messages({
+    'any.invalid': '无效的定时规则',
+    'string.empty': '定时规则不能为空',
+  });
+
+export const commonCronSchema = {
+  name: Joi.string().optional(),
+  command: Joi.string().required(),
+  schedule: scheduleSchema,
+  labels: Joi.array().optional(),
+  sub_id: Joi.number().optional().allow(null),
+  extra_schedules: Joi.array().optional().allow(null),
+  task_before: Joi.string().optional().allow('').allow(null),
+  task_after: Joi.string().optional().allow('').allow(null),
+};

cli/commands/update.ts

@@ -1,13 +0,0 @@
-import { CommandModule } from 'yargs';
-export const updateCommand: CommandModule = {
-  command: 'update',
-  describe: 'Update and restart qinglong',
-  builder: (yargs) => {
-    return yargs.option('repositority', {
-      type: 'string',
-      alias: 'r',
-      describe: `Specify the release warehouse address of the package`,
-    });
-  },
-  handler: async (argv) => {},
-};

cli/index.ts

@@ -1,13 +0,0 @@
-import * as yargs from 'yargs';
-import { green, red } from 'chalk';
-import { updateCommand } from './commands/update';
-
-yargs
-  .usage('Usage: ql [command] <options>')
-  .command(updateCommand)
-  .fail((err) => {
-    console.error(`${red(err)}`);
-  })
-  .alias('h', 'help')
-  .showHelp()
-  .recommendCommands().argv;

docker/310.Dockerfile

@@ -0,0 +1,89 @@
+FROM python:3.10-alpine3.18 AS builder
+COPY package.json .npmrc pnpm-lock.yaml /tmp/build/
+RUN set -x \
+  && apk update \
+  && apk add nodejs npm git \
+  && npm i -g pnpm@8.3.1 pm2 ts-node \
+  && cd /tmp/build \
+  && pnpm install --prod
+
+FROM python:3.10-alpine
+
+ARG QL_MAINTAINER="whyour"
+LABEL maintainer="${QL_MAINTAINER}"
+ARG QL_URL=https://github.com/${QL_MAINTAINER}/qinglong.git
+ARG QL_BRANCH=develop
+ARG PYTHON_SHORT_VERSION=3.10
+
+ENV QL_DIR=/ql \
+  QL_BRANCH=${QL_BRANCH} \
+  LANG=C.UTF-8 \
+  SHELL=/bin/bash \
+  PS1="\u@\h:\w \$ "
+
+VOLUME /ql/data
+  
+EXPOSE 5700
+
+COPY --from=builder /usr/local/lib/node_modules/. /usr/local/lib/node_modules/
+COPY --from=builder /usr/local/bin/. /usr/local/bin/
+
+RUN set -x \
+  && apk update -f \
+  && apk upgrade \
+  && apk --no-cache add -f bash \
+  coreutils \
+  git \
+  curl \
+  wget \
+  tzdata \
+  perl \
+  openssl \
+  nginx \
+  nodejs \
+  jq \
+  openssh \
+  procps \
+  netcat-openbsd \
+  unzip \
+  npm \
+  && rm -rf /var/cache/apk/* \
+  && apk update \
+  && ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
+  && echo "Asia/Shanghai" > /etc/timezone \
+  && git config --global user.email "qinglong@users.noreply.github.com" \
+  && git config --global user.name "qinglong" \
+  && git config --global http.postBuffer 524288000 \
+  && rm -rf /root/.cache \
+  && ulimit -c 0
+
+ARG SOURCE_COMMIT
+RUN git clone --depth=1 -b ${QL_BRANCH} ${QL_URL} ${QL_DIR} \
+  && cd ${QL_DIR} \
+  && cp -f .env.example .env \
+  && chmod 777 ${QL_DIR}/shell/*.sh \
+  && chmod 777 ${QL_DIR}/docker/*.sh \
+  && git clone --depth=1 -b ${QL_BRANCH} https://github.com/${QL_MAINTAINER}/qinglong-static.git /static \
+  && mkdir -p ${QL_DIR}/static \
+  && cp -rf /static/* ${QL_DIR}/static \
+  && rm -rf /static
+
+ENV PNPM_HOME=${QL_DIR}/data/dep_cache/node \
+  PYTHON_HOME=${QL_DIR}/data/dep_cache/python3 \
+  PYTHONUSERBASE=${QL_DIR}/data/dep_cache/python3
+
+ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:${PNPM_HOME}:${PYTHON_HOME}/bin \
+  NODE_PATH=/usr/local/bin:/usr/local/lib/node_modules:${PNPM_HOME}/global/5/node_modules \
+  PIP_CACHE_DIR=${PYTHON_HOME}/pip \
+  PYTHONPATH=${PYTHON_HOME}:${PYTHON_HOME}/lib/python${PYTHON_SHORT_VERSION}:${PYTHON_HOME}/lib/python${PYTHON_SHORT_VERSION}/site-packages
+
+RUN pip3 install --prefix ${PYTHON_HOME} requests
+
+COPY --from=builder /tmp/build/node_modules/. /ql/node_modules/
+
+WORKDIR ${QL_DIR}
+
+HEALTHCHECK --interval=5s --timeout=2s --retries=20 \
+  CMD curl -sf --noproxy '*' http://127.0.0.1:5600/api/health || exit 1
+
+ENTRYPOINT ["./docker/docker-entrypoint.sh"]

docker/Dockerfile

@@ -1,30 +1,34 @@
-FROM python:3.10-alpine as builder
+FROM python:3.11-alpine3.18 AS builder
 COPY package.json .npmrc pnpm-lock.yaml /tmp/build/
 RUN set -x \
   && apk update \
   && apk add nodejs npm git \
-  && npm i -g pnpm@8.3.1 \
+  && npm i -g pnpm@8.3.1 pm2 ts-node \
   && cd /tmp/build \
-  && pnpm --registry https://registry.npmmirror.com install --prod
+  && pnpm install --prod
 
-FROM python:3.10-alpine
+FROM python:3.11-alpine
 
 ARG QL_MAINTAINER="whyour"
 LABEL maintainer="${QL_MAINTAINER}"
 ARG QL_URL=https://github.com/${QL_MAINTAINER}/qinglong.git
 ARG QL_BRANCH=develop
+ARG PYTHON_SHORT_VERSION=3.11
 
-ENV PNPM_HOME=/root/.local/share/pnpm \
+ENV QL_DIR=/ql \
-  PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/root/.local/share/pnpm:/root/.local/share/pnpm/global/5/node_modules:$PNPM_HOME \
+  QL_BRANCH=${QL_BRANCH} \
-  NODE_PATH=/usr/local/bin:/usr/local/pnpm-global/5/node_modules:/usr/local/lib/node_modules:/root/.local/share/pnpm/global/5/node_modules \
   LANG=C.UTF-8 \
   SHELL=/bin/bash \
-  PS1="\u@\h:\w \$ " \
+  PS1="\u@\h:\w \$ "
-  QL_DIR=/ql \
+
-  QL_BRANCH=${QL_BRANCH}
+VOLUME /ql/data
+  
+EXPOSE 5700
+
+COPY --from=builder /usr/local/lib/node_modules/. /usr/local/lib/node_modules/
+COPY --from=builder /usr/local/bin/. /usr/local/bin/
 
 RUN set -x \
-  && sed -i 's/dl-cdn.alpinelinux.org/mirrors.aliyun.com/g' /etc/apk/repositories \
   && apk update -f \
   && apk upgrade \
   && apk --no-cache add -f bash \
@@ -41,21 +45,17 @@ RUN set -x \
   openssh \
   procps \
   netcat-openbsd \
+  unzip \
   npm \
   && rm -rf /var/cache/apk/* \
   && apk update \
   && ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime \
   && echo "Asia/Shanghai" > /etc/timezone \
-  && git config --global user.email "qinglong@@users.noreply.github.com" \
+  && git config --global user.email "qinglong@users.noreply.github.com" \
   && git config --global user.name "qinglong" \
   && git config --global http.postBuffer 524288000 \
-  && npm install -g pnpm@8.3.1 \
-  && cd && pnpm config set registry https://registry.npmmirror.com \
-  && pnpm add -g pm2 tsx \
-  && rm -rf /root/.pnpm-store \
-  && rm -rf /root/.local/share/pnpm/store \
   && rm -rf /root/.cache \
-  && rm -rf /root/.npm
+  && ulimit -c 0
 
 ARG SOURCE_COMMIT
 RUN git clone --depth=1 -b ${QL_BRANCH} ${QL_URL} ${QL_DIR} \
@@ -68,11 +68,22 @@ RUN git clone --depth=1 -b ${QL_BRANCH} ${QL_URL} ${QL_DIR} \
   && cp -rf /static/* ${QL_DIR}/static \
   && rm -rf /static
 
+ENV PNPM_HOME=${QL_DIR}/data/dep_cache/node \
+  PYTHON_HOME=${QL_DIR}/data/dep_cache/python3 \
+  PYTHONUSERBASE=${QL_DIR}/data/dep_cache/python3
+
+ENV PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:${PNPM_HOME}:${PYTHON_HOME}/bin \
+  NODE_PATH=/usr/local/bin:/usr/local/lib/node_modules:${PNPM_HOME}/global/5/node_modules \
+  PIP_CACHE_DIR=${PYTHON_HOME}/pip \
+  PYTHONPATH=${PYTHON_HOME}:${PYTHON_HOME}/lib/python${PYTHON_SHORT_VERSION}:${PYTHON_HOME}/lib/python${PYTHON_SHORT_VERSION}/site-packages
+
+RUN pip3 install --prefix ${PYTHON_HOME} requests
+
 COPY --from=builder /tmp/build/node_modules/. /ql/node_modules/
 
 WORKDIR ${QL_DIR}
 
 HEALTHCHECK --interval=5s --timeout=2s --retries=20 \
-  CMD curl -sf http://127.0.0.1:5400/api/health || exit 1
+  CMD curl -sf --noproxy '*' http://127.0.0.1:5600/api/health || exit 1
 
 ENTRYPOINT ["./docker/docker-entrypoint.sh"]

docker/docker-compose.yml

@@ -1,15 +1,10 @@
-version: '2'
 services:
   web:
-    # alpine 基础镜像版本
+    image: whyour/qinglong:latest # 基于 Debian 的版本：whyour/qinglong:debian  
-    image: whyour/qinglong:latest
-    # debian-slim 基础镜像版本
-    # image: whyour/qinglong:debian  
     volumes:
       - ./data:/ql/data
     ports:
-      - "0.0.0.0:5700:5700"
+      - "5700:5700"
     environment:
-      # 部署路径非必须，以斜杠开头和结尾，比如 /test/
+      QlBaseUrl: '/' # 部署路径非必须，以斜杠开头和结尾，比如 /test/
-      QlBaseUrl: '/'
     restart: unless-stopped

docker/docker-entrypoint.sh

@@ -2,9 +2,18 @@
 
 dir_shell=/ql/shell
 . $dir_shell/share.sh
-link_shell
+. $dir_shell/env.sh
 
-echo -e "======================1. 检测配置文件========================\n"
+log_with_style() {
+  local level="$1"
+  local message="$2"
+  local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
+
+  printf "\n[%s] [%7s]  %s\n" "${timestamp}" "${level}" "${message}"
+}
+
+log_with_style "INFO" "🚀 1. 检测配置文件..."
+import_config "$@"
 make_dir /etc/nginx/conf.d
 make_dir /run/nginx
 init_nginx
@@ -12,45 +21,23 @@ fix_config
 
 pm2 l &>/dev/null
 
-echo -e "======================2. 安装依赖========================\n"
+log_with_style "INFO" "🔄 2. 启动 nginx..."
-patch_version
-if [[ $PipMirror ]]; then
-  pip3 config set global.index-url $PipMirror
-fi
-current_npm_registry=$(cd && pnpm config get registry)
-is_equal_registry=$(echo $current_npm_registry | grep "${NpmMirror}")
-if [[ "$is_equal_registry" == "" ]]; then
-  cd && pnpm config set registry $NpmMirror
-  pnpm install -g
-fi
-if [[ ! -s $dir_scripts/package.json ]] || [[ $(diff $dir_sample/package.json $dir_scripts/package.json) ]]; then
-  cp -f $dir_sample/package.json $dir_scripts/package.json
-  npm_install_2 $dir_scripts
-fi
-echo
-
-echo -e "======================3. 启动nginx========================\n"
 nginx -s reload 2>/dev/null || nginx -c /etc/nginx/nginx.conf
-echo -e "nginx启动成功...\n"
 
-echo -e "======================4. 启动pm2服务========================\n"
+log_with_style "INFO" "⚙️  3. 启动 pm2 服务..."
 reload_pm2
 
 if [[ $AutoStartBot == true ]]; then
-  echo -e "======================5. 启动bot========================\n"
+  log_with_style "INFO" "🤖 4. 启动 bot..."
-  nohup ql -l bot >$dir_log/bot.log 2>&1 &
+  nohup ql bot >$dir_log/bot.log 2>&1 &
-  echo -e "bot后台启动中...\n"
 fi
 
 if [[ $EnableExtraShell == true ]]; then
-  echo -e "====================6. 执行自定义脚本========================\n"
+  log_with_style "INFO" "🛠️ 5. 执行自定义脚本..."
-  nohup ql -l extra >$dir_log/extra.log 2>&1 &
+  nohup ql extra >$dir_log/extra.log 2>&1 &
-  echo -e "自定义脚本后台执行中...\n"
 fi
 
-echo -e "############################################################\n"
+log_with_style "SUCCESS" "🎉 容器启动成功!"
-echo -e "容器启动成功..."
-echo -e "############################################################\n"
 
 crond -f >/dev/null
 

docker/front.conf

@@ -2,34 +2,26 @@ upstream baseApi {
   server 0.0.0.0:5600;
 }
 
-upstream publicApi {
-  server 0.0.0.0:5400;
-}
-
 map $http_upgrade $connection_upgrade {
   default keep-alive;
   'websocket' upgrade;
 }
 
 server {
-  listen 5700;
+  IPV4_CONFIG
   IPV6_CONFIG
   ssl_session_timeout 5m;
 
-  location QL_BASE_URLapi/public/ {
-    proxy_set_header Host $http_host;
-    proxy_set_header X-Real-IP $remote_addr;
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    proxy_pass http://publicApi/api/;
-    proxy_buffering off;
-  }
-
   location QL_BASE_URLapi/ {
     proxy_set_header Host $http_host;
     proxy_set_header X-Real-IP $remote_addr;
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_pass http://baseApi/api/;
     proxy_buffering off;
+    proxy_redirect default;
+    proxy_connect_timeout 1800;
+    proxy_send_timeout 1800;
+    proxy_read_timeout 1800;
 
     proxy_set_header Upgrade $http_upgrade;
     proxy_set_header Connection $connection_upgrade;
@@ -41,6 +33,10 @@ server {
     proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
     proxy_pass http://baseApi/open/;
     proxy_buffering off;
+    proxy_redirect default;
+    proxy_connect_timeout 1800;
+    proxy_send_timeout 1800;
+    proxy_read_timeout 1800;
   }
 
   gzip on;

ecosystem.config.js

@@ -1,34 +1,22 @@
 module.exports = {
   apps: [
     {
-      name: 'schedule',
+      name: 'qinglong',
-      max_restarts: 10,
+      max_restarts: 5,
-      kill_timeout: 15000,
+      kill_timeout: 1000,
       wait_ready: true,
-      listen_timeout: 10000,
+      listen_timeout: 5000,
-      source_map_support: true,
-      time: true,
-      script: 'static/build/schedule/index.js',
-    },
-    {
-      name: 'public',
-      max_restarts: 10,
-      kill_timeout: 15000,
-      wait_ready: true,
-      listen_timeout: 10000,
-      source_map_support: true,
-      time: true,
-      script: 'static/build/public.js',
-    },
-    {
-      name: 'panel',
-      max_restarts: 10,
-      kill_timeout: 15000,
-      wait_ready: true,
-      listen_timeout: 10000,
       source_map_support: true,
       time: true,
       script: 'static/build/app.js',
+      env: {
+        http_proxy: '',
+        https_proxy: '',
+        HTTP_PROXY: '',
+        HTTPS_PROXY: '',
+        all_proxy: '',
+        ALL_PROXY: '',
+      },
     },
   ],
 };

nodemon.json

@@ -1,6 +1,5 @@
 {
   "watch": ["back", ".env"],
   "ext": "js,ts,json",
-  "ignore": ["src/**/*.spec.ts"],
+  "exec": "ts-node -P ./back/tsconfig.json ./back/app.ts"
-  "exec": "ts-node  --transpile-only ./back/app.ts"
 }