@whyour/qinglong 2.18.2-2 → 2.18.2-5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whyour/qinglong",
-  "version": "2.18.2-2",
+  "version": "2.18.2-5",
   "description": "Timed task management platform supporting Python3, JavaScript, Shell, Typescript",
   "repository": {
     "type": "git",
@@ -24,7 +24,7 @@
     "schedule": "npm run build:back && node static/build/schedule/index.js",
     "public": "npm run build:back && node static/build/public.js",
     "update": "npm run build:back && node static/build/update.js",
-    "gen:proto": "protoc --experimental_allow_proto3_optional --plugin=./node_modules/.bin/protoc-gen-ts_proto ./back/protos/*.proto --ts_proto_out=./ --ts_proto_opt=outputServices=grpc-js,env=node,esModuleInterop=true",
+    "gen:proto": "protoc --experimental_allow_proto3_optional --plugin=./node_modules/.bin/protoc-gen-ts_proto ./back/protos/*.proto --ts_proto_out=./ --ts_proto_opt=outputServices=grpc-js,env=node,esModuleInterop=true,snakeToCamel=false",
     "gen:api": "python3 -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. ./back/protos/api.proto",
     "prettier": "prettier --write '**/*.{js,jsx,tsx,ts,less,md,json}'",
     "postinstall": "max setup 2>/dev/null || true",
@@ -104,7 +104,7 @@
     "node-schedule": "^2.1.0",
     "nodemailer": "^6.9.16",
     "p-queue-cjs": "7.3.4",
-    "protobufjs": "^7.4.0",
+    "@bufbuild/protobuf": "^2.2.3",
     "pstree.remy": "^1.1.8",
     "reflect-metadata": "^0.2.2",
     "sequelize": "^6.37.5",
@@ -187,7 +187,7 @@
     "react-split-pane": "^0.1.92",
     "sockjs-client": "^1.6.0",
     "ts-node": "^10.9.2",
-    "ts-proto": "^1.146.0",
+    "ts-proto": "^2.6.1",
     "tslib": "^2.4.0",
     "typescript": "5.2.2",
     "vh-check": "^2.0.5",

package/shell/preload/client.js

@@ -1,45 +1,154 @@
 const grpc = require('@grpc/grpc-js');
 const protoLoader = require('@grpc/proto-loader');
+const { join } = require('path');
 
-const PROTO_PATH = `${process.env.QL_DIR}/back/protos/api.proto`;
-const options = {
-  keepCase: true,
-  longs: String,
-  enums: String,
-  defaults: true,
-};
-
-const packageDefinition = protoLoader.loadSync(PROTO_PATH, options);
-const apiProto = grpc.loadPackageDefinition(packageDefinition).com.ql.api;
-
-const client = new apiProto.Api(
-  `0.0.0.0:5500`,
-  grpc.credentials.createInsecure(),
-  { 'grpc.enable_http_proxy': 0 },
-);
-
-const promisify = (fn) => {
-  return (...args) => {
-    return new Promise((resolve, reject) => {
-      fn.call(client, ...args, (err, response) => {
-        if (err) return reject(err);
-        resolve(response);
+class GrpcClient {
+  static #config = {
+    protoPath: join(process.env.QL_DIR, 'back/protos/api.proto'),
+    serverAddress: '0.0.0.0:5500',
+    protoOptions: {
+      keepCase: true,
+      longs: String,
+      enums: String,
+      defaults: true,
+    },
+    grpcOptions: {
+      'grpc.enable_http_proxy': 0,
+      'grpc.keepalive_time_ms': 120000,
+      'grpc.keepalive_timeout_ms': 20000,
+      'grpc.max_receive_message_length': 100 * 1024 * 1024,
+    },
+    defaultTimeout: 30000,
+  };
+
+  static #methods = [
+    'getEnvs',
+    'createEnv',
+    'updateEnv',
+    'deleteEnvs',
+    'moveEnv',
+    'disableEnvs',
+    'enableEnvs',
+    'updateEnvNames',
+    'getEnvById',
+    'systemNotify',
+    'getCronDetail',
+    'createCron',
+    'updateCron',
+    'deleteCrons',
+  ];
+
+  #client;
+  #api = {};
+
+  constructor() {
+    this.#initializeClient();
+    this.#bindMethods();
+  }
+
+  #initializeClient() {
+    try {
+      const { protoPath, protoOptions, serverAddress, grpcOptions } =
+        GrpcClient.#config;
+
+      const packageDefinition = protoLoader.loadSync(protoPath, protoOptions);
+      const apiProto = grpc.loadPackageDefinition(packageDefinition).com.ql.api;
+
+      this.#client = new apiProto.Api(
+        serverAddress,
+        grpc.credentials.createInsecure(),
+        grpcOptions,
+      );
+
+      this.#checkConnection();
+    } catch (error) {
+      console.error('Failed to initialize gRPC client:', error);
+      process.exit(1);
+    }
+  }
+
+  #checkConnection() {
+    this.#client.waitForReady(Date.now() + 5000, (error) => {
+      if (error) {
+        console.error('gRPC client connection failed:', error);
+        process.exit(1);
+      }
+    });
+  }
+
+  #promisifyMethod(methodName) {
+    const capitalizedMethod =
+      methodName.charAt(0).toUpperCase() + methodName.slice(1);
+    const method = this.#client[capitalizedMethod].bind(this.#client);
+
+    return async (params = {}) => {
+      return new Promise((resolve, reject) => {
+        const metadata = new grpc.Metadata();
+        const deadline = new Date(
+          Date.now() + GrpcClient.#config.defaultTimeout,
+        );
+
+        method(params, metadata, { deadline }, (error, response) => {
+          if (error) {
+            return reject(error);
+          }
+          resolve(response);
+        });
       });
+    };
+  }
+
+  #bindMethods() {
+    GrpcClient.#methods.forEach((method) => {
+      this.#api[method] = this.#promisifyMethod(method);
     });
-  };
-};
-
-const api = {
-  getEnvs: promisify(client.GetEnvs),
-  createEnv: promisify(client.CreateEnv),
-  updateEnv: promisify(client.UpdateEnv),
-  deleteEnvs: promisify(client.DeleteEnvs),
-  moveEnv: promisify(client.MoveEnv),
-  disableEnvs: promisify(client.DisableEnvs),
-  enableEnvs: promisify(client.EnableEnvs),
-  updateEnvNames: promisify(client.UpdateEnvNames),
-  getEnvById: promisify(client.GetEnvById),
-  systemNotify: promisify(client.SystemNotify),
-};
-
-module.exports = api;
+  }
+
+  getApi() {
+    return {
+      ...this.#api,
+      close: this.close.bind(this),
+    };
+  }
+
+  close() {
+    if (this.#client) {
+      this.#client.close();
+      this.#client = null;
+    }
+  }
+}
+
+const grpcClient = new GrpcClient();
+
+process.on('SIGTERM', () => {
+  grpcClient.close();
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  grpcClient.close();
+  process.exit(0);
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  if (reason instanceof Error) {
+    if (reason.stack) {
+      const relevantStack = reason.stack
+        .split('\n')
+        .filter((line) => {
+          return (
+            !line.includes('node:internal') &&
+            !line.includes('node_modules/@grpc') &&
+            !line.includes('processTicksAndRejections')
+          );
+        })
+        .join('\n');
+      console.error(relevantStack);
+    }
+  } else {
+    console.error(reason);
+  }
+});
+
+module.exports = grpcClient.getApi();

package/shell/preload/client.py

@@ -2,7 +2,7 @@ import subprocess
 import json
 import tempfile
 import os
-from typing import Dict, List
+from typing import Dict, List, TypedDict, Optional
 from functools import wraps
 
 
@@ -11,16 +11,170 @@ def error_handler(func):
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
-        except json.JSONDecodeError as e:
-            raise Exception(f"parse json error: {str(e)}")
-        except subprocess.SubprocessError as e:
-            raise Exception(f"node process error: {str(e)}")
+        except TypeError as e:
+            if "missing" in str(e):
+                func_name = func.__name__
+                annotations = func.__annotations__
+                param_type = next(
+                    (t for name, t in annotations.items() if name != "return"), None
+                )
+                if param_type and hasattr(param_type, "__annotations__"):
+                    required_fields = {
+                        k: v
+                        for k, v in param_type.__annotations__.items()
+                        if not getattr(param_type, "__total__", True)
+                        or k in getattr(param_type, "__required_keys__", set())
+                    }
+                    fields_str = ", ".join(
+                        f'"{k}": {v.__name__}' for k, v in required_fields.items()
+                    )
+                    raise Exception(
+                        f"{func_name}() requires a dictionary with parameters: {{{fields_str}}}"
+                    ) from None
+            raise Exception(f"{str(e)}") from None
         except Exception as e:
-            raise Exception(f"unknown error: {str(e)}")
+            error_msg = str(e)
+            if "Error:" in error_msg:
+                error_msg = error_msg.split("Error:")[-1].split("\n")[0].strip()
+            raise Exception(f"{error_msg}") from None
 
     return wrapper
 
 
+class EnvItem(TypedDict, total=False):
+    id: Optional[int]
+    name: Optional[str]
+    value: Optional[str]
+    remarks: Optional[str]
+    status: Optional[int]
+    position: Optional[int]
+
+
+class GetEnvsParams(TypedDict, total=False):
+    searchValue: str
+
+
+class CreateEnvParams(TypedDict):
+    envs: List[EnvItem]
+
+
+class UpdateEnvParams(TypedDict):
+    env: EnvItem
+
+
+class DeleteEnvsParams(TypedDict):
+    ids: List[int]
+
+
+class MoveEnvParams(TypedDict):
+    id: int
+    fromIndex: int
+    toIndex: int
+
+
+class DisableEnvsParams(TypedDict):
+    ids: List[int]
+
+
+class EnableEnvsParams(TypedDict):
+    ids: List[int]
+
+
+class UpdateEnvNamesParams(TypedDict):
+    ids: List[int]
+    name: str
+
+
+class GetEnvByIdParams(TypedDict):
+    id: int
+
+
+class SystemNotifyParams(TypedDict):
+    title: str
+    content: str
+
+
+class EnvsResponse(TypedDict):
+    code: int
+    data: List[EnvItem]
+    message: Optional[str]
+
+
+class EnvResponse(TypedDict):
+    code: int
+    data: EnvItem
+    message: Optional[str]
+
+
+class Response(TypedDict):
+    code: int
+    message: Optional[str]
+
+
+class ExtraScheduleItem(TypedDict, total=False):
+    schedule: Optional[str]
+
+
+class CronItem(TypedDict, total=False):
+    id: Optional[int]
+    command: Optional[str]
+    schedule: Optional[str]
+    name: Optional[str]
+    labels: List[str]
+    sub_id: Optional[int]
+    extra_schedules: List[ExtraScheduleItem]
+    task_before: Optional[str]
+    task_after: Optional[str]
+    status: Optional[int]
+    log_path: Optional[str]
+    pid: Optional[int]
+    last_running_time: Optional[int]
+    last_execution_time: Optional[int]
+
+
+class CreateCronParams(TypedDict):
+    command: str
+    schedule: str
+    name: Optional[str]
+    labels: List[str]
+    sub_id: Optional[int]
+    extra_schedules: List[ExtraScheduleItem]
+    task_before: Optional[str]
+    task_after: Optional[str]
+
+
+class UpdateCronParams(TypedDict):
+    id: int
+    command: str
+    schedule: str
+    name: Optional[str]
+    labels: List[str]
+    sub_id: Optional[int]
+    extra_schedules: List[ExtraScheduleItem]
+    task_before: Optional[str]
+    task_after: Optional[str]
+
+
+class DeleteCronsParams(TypedDict):
+    ids: List[int]
+
+
+class CronDetailParams(TypedDict):
+    log_path: str
+
+
+class CronsResponse(TypedDict):
+    code: int
+    data: List[CronItem]
+    message: Optional[str]
+
+
+class CronResponse(TypedDict):
+    code: int
+    data: CronItem
+    message: Optional[str]
+
+
 class Client:
     def __init__(self):
         self.temp_dir = tempfile.mkdtemp(prefix="node_client_")
@@ -46,7 +200,8 @@ class Client:
             }} catch (error) {{
                 console.error(JSON.stringify({{
                     error: error.message,
-                    stack: error.stack
+                    stack: error.stack,
+                    name: error.name
                 }}));
                 process.exit(1);
             }}
@@ -56,58 +211,73 @@ class Client:
         with open(self.temp_script, "w", encoding="utf-8") as f:
             f.write(node_code)
 
-        try:
-            result = subprocess.run(
-                ["node", self.temp_script],
-                capture_output=True,
-                text=True,
-                timeout=30,
-            )
+        result = subprocess.run(
+            ["node", self.temp_script],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
 
-            if result.returncode != 0:
-                error_data = json.loads(result.stderr)
-                raise Exception(f"{error_data.get('stack')}")
+        if result.returncode != 0:
+            error_data = json.loads(result.stderr)
+            raise Exception(
+                f"{error_data.get('name', 'Error')}: {error_data.get('stack')}"
+            )
 
-            return json.loads(result.stdout)
-        except subprocess.TimeoutExpired:
-            raise Exception("node process timeout")
+        return json.loads(result.stdout)
 
     @error_handler
-    def getEnvs(self, params: Dict = None) -> Dict:
+    def getEnvs(self, params: GetEnvsParams = None) -> EnvsResponse:
         return self._execute_node("getEnvs", params)
 
     @error_handler
-    def createEnv(self, data: Dict) -> Dict:
+    def createEnv(self, data: CreateEnvParams) -> EnvsResponse:
         return self._execute_node("createEnv", data)
 
     @error_handler
-    def updateEnv(self, data: Dict) -> Dict:
+    def updateEnv(self, data: UpdateEnvParams) -> EnvResponse:
         return self._execute_node("updateEnv", data)
 
     @error_handler
-    def deleteEnvs(self, data: Dict) -> Dict:
+    def deleteEnvs(self, data: DeleteEnvsParams) -> Response:
         return self._execute_node("deleteEnvs", data)
 
     @error_handler
-    def moveEnv(self, data: Dict) -> Dict:
+    def moveEnv(self, data: MoveEnvParams) -> EnvResponse:
         return self._execute_node("moveEnv", data)
 
     @error_handler
-    def disableEnvs(self, data: Dict) -> Dict:
+    def disableEnvs(self, data: DisableEnvsParams) -> Response:
         return self._execute_node("disableEnvs", data)
 
     @error_handler
-    def enableEnvs(self, data: Dict) -> Dict:
+    def enableEnvs(self, data: EnableEnvsParams) -> Response:
         return self._execute_node("enableEnvs", data)
 
     @error_handler
-    def updateEnvNames(self, data: Dict) -> Dict:
+    def updateEnvNames(self, data: UpdateEnvNamesParams) -> Response:
         return self._execute_node("updateEnvNames", data)
 
     @error_handler
-    def getEnvById(self, data: Dict) -> Dict:
+    def getEnvById(self, data: GetEnvByIdParams) -> EnvResponse:
         return self._execute_node("getEnvById", data)
 
     @error_handler
-    def systemNotify(self, data: Dict) -> Dict:
+    def systemNotify(self, data: SystemNotifyParams) -> Response:
         return self._execute_node("systemNotify", data)
+
+    @error_handler
+    def getCronDetail(self, data: CronDetailParams) -> CronResponse:
+        return self._execute_node("getCronDetail", data)
+
+    @error_handler
+    def createCron(self, data: CreateCronParams) -> CronResponse:
+        return self._execute_node("createCron", data)
+
+    @error_handler
+    def updateCron(self, data: UpdateCronParams) -> CronResponse:
+        return self._execute_node("updateCron", data)
+
+    @error_handler
+    def deleteCrons(self, data: DeleteCronsParams) -> Response:
+        return self._execute_node("deleteCrons", data)

package/shell/preload/sitecustomize.js

@@ -98,7 +98,7 @@ try {
 
   run();
 
-  const { sendNotify } = require('./notify.js');
+  const { sendNotify } = require('./__ql_notify__.js');
   global.QLAPI = {
     notify: sendNotify,
     ...client,

package/shell/preload/sitecustomize.py

@@ -107,7 +107,7 @@ try:
 
     run()
 
-    from notify import send
+    from __ql_notify__ import send
 
     class BaseApi(Client):
         def notify(self, *args, **kwargs):

package/shell/share.sh

@@ -474,17 +474,17 @@ handle_task_end() {
   local end_timestamp=$(format_timestamp "$time_format" "$etime")
   local diff_time=$(($end_timestamp - $begin_timestamp))
   local suffix=""
-  [[ "$MANUAL" == "true" ]] && suffix="(手动停止)"
+  [[ "${MANUAL:=}" == "true" ]] && suffix="(手动停止)"
 
   [[ "$diff_time" == 0 ]] && diff_time=1
 
   if [[ $ID ]]; then
-    local error=$(update_cron "\"$ID\"" "1" "" "$log_path" "$begin_timestamp" "$diff_time")
+    local error=$(update_cron "\"$ID\"" "1" "$$" "$log_path" "$begin_timestamp" "$diff_time")
     if [[ $error ]]; then
       error_message=", 任务状态更新失败(${error})"
     fi
   fi
-  echo -e "\n## 执行结束$suffix... $end_time  耗时 $diff_time 秒${error_message}　　　　　"
+  echo -e "\n## 执行结束$suffix... $end_time  耗时 $diff_time 秒${error_message:=}　　　　　"
 }
 
 init_env

package/shell/update.sh

@@ -543,6 +543,9 @@ main() {
   resettfa)
     eval update_auth_config "\\\"twoFactorActivated\\\":false" "禁用两步验证" $cmd
     ;;
+  resetpwd)
+    eval update_auth_config "\\\"password\\\":\\\"$p2\\\"" "重置密码" $cmd
+    ;;
   *)
     eval echo -e "命令输入错误...\\\n" $cmd
     eval usage $cmd
@@ -553,7 +556,7 @@ main() {
   local end_time=$(format_time "$time_format" "$etime")
   local end_timestamp=$(format_timestamp "$time_format" "$etime")
   local diff_time=$(($end_timestamp - $begin_timestamp))
-  [[ $ID ]] && update_cron "\"$ID\"" "1" "" "$log_path" "$begin_timestamp" "$diff_time"
+  [[ $ID ]] && update_cron "\"$ID\"" "1" "$$" "$log_path" "$begin_timestamp" "$diff_time"
 
   if [[ "$p1" != "repo" ]] && [[ "$p1" != "raw" ]]; then
     eval echo -e "\\\n\#\# 执行结束... $end_time  耗时 $diff_time 秒　　　　　" $cmd

package/static/build/api/cron.js

@@ -8,7 +8,7 @@ const typedi_1 = require("typedi");
 const cron_1 = __importDefault(require("../services/cron"));
 const cronView_1 = __importDefault(require("../services/cronView"));
 const celebrate_1 = require("celebrate");
-const cron_parser_1 = __importDefault(require("cron-parser"));
+const schedule_1 = require("../validation/schedule");
 const route = (0, express_1.Router)();
 exports.default = (app) => {
     app.use('/crons', route);
@@ -141,27 +141,13 @@ exports.default = (app) => {
         }
     });
     route.post('/', (0, celebrate_1.celebrate)({
-        body: celebrate_1.Joi.object({
-            command: celebrate_1.Joi.string().required(),
-            schedule: celebrate_1.Joi.string().required(),
-            name: celebrate_1.Joi.string().optional(),
-            labels: celebrate_1.Joi.array().optional(),
-            sub_id: celebrate_1.Joi.number().optional().allow(null),
-            extra_schedules: celebrate_1.Joi.array().optional().allow(null),
-            task_before: celebrate_1.Joi.string().optional().allow('').allow(null),
-            task_after: celebrate_1.Joi.string().optional().allow('').allow(null),
-        }),
+        body: celebrate_1.Joi.object(schedule_1.commonCronSchema),
     }), async (req, res, next) => {
         const logger = typedi_1.Container.get('logger');
         try {
-            if (cron_parser_1.default.parseExpression(req.body.schedule).hasNext()) {
-                const cronService = typedi_1.Container.get(cron_1.default);
-                const data = await cronService.create(req.body);
-                return res.send({ code: 200, data });
-            }
-            else {
-                return res.send({ code: 400, message: 'param schedule error' });
-            }
+            const cronService = typedi_1.Container.get(cron_1.default);
+            const data = await cronService.create(req.body);
+            return res.send({ code: 200, data });
         }
         catch (e) {
             return next(e);
@@ -267,29 +253,13 @@ exports.default = (app) => {
         }
     });
     route.put('/', (0, celebrate_1.celebrate)({
-        body: celebrate_1.Joi.object({
-            labels: celebrate_1.Joi.array().optional().allow(null),
-            command: celebrate_1.Joi.string().required(),
-            schedule: celebrate_1.Joi.string().required(),
-            name: celebrate_1.Joi.string().optional().allow(null),
-            sub_id: celebrate_1.Joi.number().optional().allow(null),
-            extra_schedules: celebrate_1.Joi.array().optional().allow(null),
-            task_before: celebrate_1.Joi.string().optional().allow('').allow(null),
-            task_after: celebrate_1.Joi.string().optional().allow('').allow(null),
-            id: celebrate_1.Joi.number().required(),
-        }),
+        body: celebrate_1.Joi.object(Object.assign(Object.assign({}, schedule_1.commonCronSchema), { id: celebrate_1.Joi.number().required() })),
     }), async (req, res, next) => {
         const logger = typedi_1.Container.get('logger');
         try {
-            if (!req.body.schedule ||
-                cron_parser_1.default.parseExpression(req.body.schedule).hasNext()) {
-                const cronService = typedi_1.Container.get(cron_1.default);
-                const data = await cronService.update(req.body);
-                return res.send({ code: 200, data });
-            }
-            else {
-                return res.send({ code: 400, message: 'param schedule error' });
-            }
+            const cronService = typedi_1.Container.get(cron_1.default);
+            const data = await cronService.update(req.body);
+            return res.send({ code: 200, data });
         }
         catch (e) {
             return next(e);
@@ -338,7 +308,7 @@ exports.default = (app) => {
         const logger = typedi_1.Container.get('logger');
         try {
             const cronService = typedi_1.Container.get(cron_1.default);
-            const data = await cronService.import_crontab();
+            const data = await cronService.importCrontab();
             return res.send({ code: 200, data });
         }
         catch (e) {