diff --git a/back/protos/api.proto b/back/protos/api.proto
index f399a3d1..77d35ee9 100644
--- a/back/protos/api.proto
+++ b/back/protos/api.proto
@@ -8,7 +8,7 @@ message EnvItem {
   optional string value = 3;
   optional string remarks = 4;
   optional int32 status = 5;
-  optional int32 position = 6;
+  optional int64 position = 6;
 }
 
 message GetEnvsRequest { string searchValue = 1; }
@@ -58,6 +58,72 @@ message SystemNotifyRequest {
   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;
+  string command = 2;
+  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) {}
@@ -69,4 +135,8 @@ service Api {
   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) {}
 }
\ No newline at end of file
diff --git a/back/protos/api.ts b/back/protos/api.ts
index 10780ec3..558cb693 100644
--- a/back/protos/api.ts
+++ b/back/protos/api.ts
@@ -1,10 +1,11 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.181.2
+//   protoc-gen-ts_proto  v2.6.1
 //   protoc               v3.17.3
 // source: back/protos/api.proto
 
 /* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import {
   type CallOptions,
   ChannelCredentials,
@@ -17,7 +18,6 @@ import {
   type ServiceError,
   type UntypedServiceImplementation,
 } from "@grpc/grpc-js";
-import _m0 from "protobufjs/minimal";
 
 export const protobufPackage = "com.ql.api";
 
@@ -91,6 +91,76 @@ export interface SystemNotifyRequest {
   content: string;
 }
 
+export interface ExtraScheduleItem {
+  schedule: string;
+}
+
+export interface CronItem {
+  id?: number | undefined;
+  command?: string | undefined;
+  schedule?: string | undefined;
+  name?: string | undefined;
+  labels: string[];
+  sub_id?: number | undefined;
+  extra_schedules: ExtraScheduleItem[];
+  task_before?: string | undefined;
+  task_after?: string | undefined;
+  status?: number | undefined;
+  log_path?: string | undefined;
+  pid?: number | undefined;
+  last_running_time?: number | undefined;
+  last_execution_time?: number | undefined;
+}
+
+export interface CreateCronRequest {
+  command: string;
+  schedule: string;
+  name?: string | undefined;
+  labels: string[];
+  sub_id?: number | undefined;
+  extra_schedules: ExtraScheduleItem[];
+  task_before?: string | undefined;
+  task_after?: string | undefined;
+}
+
+export interface UpdateCronRequest {
+  id: number;
+  command: string;
+  schedule: string;
+  name?: string | undefined;
+  labels: string[];
+  sub_id?: number | undefined;
+  extra_schedules: ExtraScheduleItem[];
+  task_before?: string | undefined;
+  task_after?: string | undefined;
+}
+
+export interface DeleteCronsRequest {
+  ids: number[];
+}
+
+export interface CronsResponse {
+  code: number;
+  data: CronItem[];
+  message?: string | undefined;
+}
+
+export interface CronResponse {
+  code: number;
+  data: CronItem | undefined;
+  message?: string | undefined;
+}
+
+export interface CronDetailRequest {
+  log_path: string;
+}
+
+export interface CronDetailResponse {
+  code: number;
+  data: CronItem | undefined;
+  message?: string | undefined;
+}
+
 function createBaseEnvItem(): EnvItem {
   return {
     id: undefined,
@@ -102,8 +172,8 @@ function createBaseEnvItem(): EnvItem {
   };
 }
 
-export const EnvItem = {
-  encode(message: EnvItem, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const EnvItem: MessageFns<EnvItem> = {
+  encode(message: EnvItem, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.id !== undefined) {
       writer.uint32(8).int32(message.id);
     }
@@ -120,65 +190,71 @@ export const EnvItem = {
       writer.uint32(40).int32(message.status);
     }
     if (message.position !== undefined) {
-      writer.uint32(48).int32(message.position);
+      writer.uint32(48).int64(message.position);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): EnvItem {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): EnvItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEnvItem();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.id = reader.int32();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.name = reader.string();
           continue;
-        case 3:
+        }
+        case 3: {
           if (tag !== 26) {
             break;
           }
 
           message.value = reader.string();
           continue;
-        case 4:
+        }
+        case 4: {
           if (tag !== 34) {
             break;
           }
 
           message.remarks = reader.string();
           continue;
-        case 5:
+        }
+        case 5: {
           if (tag !== 40) {
             break;
           }
 
           message.status = reader.int32();
           continue;
-        case 6:
+        }
+        case 6: {
           if (tag !== 48) {
             break;
           }
 
-          message.position = reader.int32();
+          message.position = longToNumber(reader.int64());
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -236,33 +312,34 @@ function createBaseGetEnvsRequest(): GetEnvsRequest {
   return { searchValue: "" };
 }
 
-export const GetEnvsRequest = {
-  encode(message: GetEnvsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const GetEnvsRequest: MessageFns<GetEnvsRequest> = {
+  encode(message: GetEnvsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.searchValue !== "") {
       writer.uint32(10).string(message.searchValue);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): GetEnvsRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): GetEnvsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetEnvsRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.searchValue = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -293,33 +370,34 @@ function createBaseCreateEnvRequest(): CreateEnvRequest {
   return { envs: [] };
 }
 
-export const CreateEnvRequest = {
-  encode(message: CreateEnvRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const CreateEnvRequest: MessageFns<CreateEnvRequest> = {
+  encode(message: CreateEnvRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     for (const v of message.envs) {
-      EnvItem.encode(v!, writer.uint32(10).fork()).ldelim();
+      EnvItem.encode(v!, writer.uint32(10).fork()).join();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): CreateEnvRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateEnvRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCreateEnvRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.envs.push(EnvItem.decode(reader, reader.uint32()));
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -350,33 +428,34 @@ function createBaseUpdateEnvRequest(): UpdateEnvRequest {
   return { env: undefined };
 }
 
-export const UpdateEnvRequest = {
-  encode(message: UpdateEnvRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const UpdateEnvRequest: MessageFns<UpdateEnvRequest> = {
+  encode(message: UpdateEnvRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.env !== undefined) {
-      EnvItem.encode(message.env, writer.uint32(10).fork()).ldelim();
+      EnvItem.encode(message.env, writer.uint32(10).fork()).join();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): UpdateEnvRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateEnvRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseUpdateEnvRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.env = EnvItem.decode(reader, reader.uint32());
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -407,24 +486,24 @@ function createBaseDeleteEnvsRequest(): DeleteEnvsRequest {
   return { ids: [] };
 }
 
-export const DeleteEnvsRequest = {
-  encode(message: DeleteEnvsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const DeleteEnvsRequest: MessageFns<DeleteEnvsRequest> = {
+  encode(message: DeleteEnvsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     writer.uint32(10).fork();
     for (const v of message.ids) {
       writer.int32(v);
     }
-    writer.ldelim();
+    writer.join();
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): DeleteEnvsRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteEnvsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseDeleteEnvsRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag === 8) {
             message.ids.push(reader.int32());
 
@@ -441,11 +520,12 @@ export const DeleteEnvsRequest = {
           }
 
           break;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -476,8 +556,8 @@ function createBaseMoveEnvRequest(): MoveEnvRequest {
   return { id: 0, fromIndex: 0, toIndex: 0 };
 }
 
-export const MoveEnvRequest = {
-  encode(message: MoveEnvRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const MoveEnvRequest: MessageFns<MoveEnvRequest> = {
+  encode(message: MoveEnvRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.id !== 0) {
       writer.uint32(8).int32(message.id);
     }
@@ -490,39 +570,42 @@ export const MoveEnvRequest = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): MoveEnvRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): MoveEnvRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseMoveEnvRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.id = reader.int32();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 16) {
             break;
           }
 
           message.fromIndex = reader.int32();
           continue;
-        case 3:
+        }
+        case 3: {
           if (tag !== 24) {
             break;
           }
 
           message.toIndex = reader.int32();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -565,24 +648,24 @@ function createBaseDisableEnvsRequest(): DisableEnvsRequest {
   return { ids: [] };
 }
 
-export const DisableEnvsRequest = {
-  encode(message: DisableEnvsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const DisableEnvsRequest: MessageFns<DisableEnvsRequest> = {
+  encode(message: DisableEnvsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     writer.uint32(10).fork();
     for (const v of message.ids) {
       writer.int32(v);
     }
-    writer.ldelim();
+    writer.join();
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): DisableEnvsRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): DisableEnvsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseDisableEnvsRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag === 8) {
             message.ids.push(reader.int32());
 
@@ -599,11 +682,12 @@ export const DisableEnvsRequest = {
           }
 
           break;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -634,24 +718,24 @@ function createBaseEnableEnvsRequest(): EnableEnvsRequest {
   return { ids: [] };
 }
 
-export const EnableEnvsRequest = {
-  encode(message: EnableEnvsRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const EnableEnvsRequest: MessageFns<EnableEnvsRequest> = {
+  encode(message: EnableEnvsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     writer.uint32(10).fork();
     for (const v of message.ids) {
       writer.int32(v);
     }
-    writer.ldelim();
+    writer.join();
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): EnableEnvsRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): EnableEnvsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEnableEnvsRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag === 8) {
             message.ids.push(reader.int32());
 
@@ -668,11 +752,12 @@ export const EnableEnvsRequest = {
           }
 
           break;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -703,27 +788,27 @@ function createBaseUpdateEnvNamesRequest(): UpdateEnvNamesRequest {
   return { ids: [], name: "" };
 }
 
-export const UpdateEnvNamesRequest = {
-  encode(message: UpdateEnvNamesRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const UpdateEnvNamesRequest: MessageFns<UpdateEnvNamesRequest> = {
+  encode(message: UpdateEnvNamesRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     writer.uint32(10).fork();
     for (const v of message.ids) {
       writer.int32(v);
     }
-    writer.ldelim();
+    writer.join();
     if (message.name !== "") {
       writer.uint32(18).string(message.name);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): UpdateEnvNamesRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateEnvNamesRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseUpdateEnvNamesRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag === 8) {
             message.ids.push(reader.int32());
 
@@ -740,18 +825,20 @@ export const UpdateEnvNamesRequest = {
           }
 
           break;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.name = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -789,33 +876,34 @@ function createBaseGetEnvByIdRequest(): GetEnvByIdRequest {
   return { id: 0 };
 }
 
-export const GetEnvByIdRequest = {
-  encode(message: GetEnvByIdRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const GetEnvByIdRequest: MessageFns<GetEnvByIdRequest> = {
+  encode(message: GetEnvByIdRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.id !== 0) {
       writer.uint32(8).int32(message.id);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): GetEnvByIdRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): GetEnvByIdRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseGetEnvByIdRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.id = reader.int32();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -846,13 +934,13 @@ function createBaseEnvsResponse(): EnvsResponse {
   return { code: 0, data: [], message: undefined };
 }
 
-export const EnvsResponse = {
-  encode(message: EnvsResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const EnvsResponse: MessageFns<EnvsResponse> = {
+  encode(message: EnvsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.code !== 0) {
       writer.uint32(8).int32(message.code);
     }
     for (const v of message.data) {
-      EnvItem.encode(v!, writer.uint32(18).fork()).ldelim();
+      EnvItem.encode(v!, writer.uint32(18).fork()).join();
     }
     if (message.message !== undefined) {
       writer.uint32(26).string(message.message);
@@ -860,39 +948,42 @@ export const EnvsResponse = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): EnvsResponse {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): EnvsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEnvsResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.code = reader.int32();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.data.push(EnvItem.decode(reader, reader.uint32()));
           continue;
-        case 3:
+        }
+        case 3: {
           if (tag !== 26) {
             break;
           }
 
           message.message = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -935,13 +1026,13 @@ function createBaseEnvResponse(): EnvResponse {
   return { code: 0, data: undefined, message: undefined };
 }
 
-export const EnvResponse = {
-  encode(message: EnvResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const EnvResponse: MessageFns<EnvResponse> = {
+  encode(message: EnvResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.code !== 0) {
       writer.uint32(8).int32(message.code);
     }
     if (message.data !== undefined) {
-      EnvItem.encode(message.data, writer.uint32(18).fork()).ldelim();
+      EnvItem.encode(message.data, writer.uint32(18).fork()).join();
     }
     if (message.message !== undefined) {
       writer.uint32(26).string(message.message);
@@ -949,39 +1040,42 @@ export const EnvResponse = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): EnvResponse {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): EnvResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseEnvResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.code = reader.int32();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.data = EnvItem.decode(reader, reader.uint32());
           continue;
-        case 3:
+        }
+        case 3: {
           if (tag !== 26) {
             break;
           }
 
           message.message = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -1024,8 +1118,8 @@ function createBaseResponse(): Response {
   return { code: 0, message: undefined };
 }
 
-export const Response = {
-  encode(message: Response, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const Response: MessageFns<Response> = {
+  encode(message: Response, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.code !== 0) {
       writer.uint32(8).int32(message.code);
     }
@@ -1035,32 +1129,34 @@ export const Response = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): Response {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): Response {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.code = reader.int32();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.message = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -1098,8 +1194,8 @@ function createBaseSystemNotifyRequest(): SystemNotifyRequest {
   return { title: "", content: "" };
 }
 
-export const SystemNotifyRequest = {
-  encode(message: SystemNotifyRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const SystemNotifyRequest: MessageFns<SystemNotifyRequest> = {
+  encode(message: SystemNotifyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.title !== "") {
       writer.uint32(10).string(message.title);
     }
@@ -1109,32 +1205,34 @@ export const SystemNotifyRequest = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): SystemNotifyRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): SystemNotifyRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseSystemNotifyRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.title = reader.string();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.content = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -1168,6 +1266,1138 @@ export const SystemNotifyRequest = {
   },
 };
 
+function createBaseExtraScheduleItem(): ExtraScheduleItem {
+  return { schedule: "" };
+}
+
+export const ExtraScheduleItem: MessageFns<ExtraScheduleItem> = {
+  encode(message: ExtraScheduleItem, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.schedule !== "") {
+      writer.uint32(10).string(message.schedule);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): ExtraScheduleItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseExtraScheduleItem();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.schedule = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): ExtraScheduleItem {
+    return { schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "" };
+  },
+
+  toJSON(message: ExtraScheduleItem): unknown {
+    const obj: any = {};
+    if (message.schedule !== "") {
+      obj.schedule = message.schedule;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<ExtraScheduleItem>, I>>(base?: I): ExtraScheduleItem {
+    return ExtraScheduleItem.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<ExtraScheduleItem>, I>>(object: I): ExtraScheduleItem {
+    const message = createBaseExtraScheduleItem();
+    message.schedule = object.schedule ?? "";
+    return message;
+  },
+};
+
+function createBaseCronItem(): CronItem {
+  return {
+    id: undefined,
+    command: undefined,
+    schedule: undefined,
+    name: undefined,
+    labels: [],
+    sub_id: undefined,
+    extra_schedules: [],
+    task_before: undefined,
+    task_after: undefined,
+    status: undefined,
+    log_path: undefined,
+    pid: undefined,
+    last_running_time: undefined,
+    last_execution_time: undefined,
+  };
+}
+
+export const CronItem: MessageFns<CronItem> = {
+  encode(message: CronItem, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== undefined) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.command !== undefined) {
+      writer.uint32(18).string(message.command);
+    }
+    if (message.schedule !== undefined) {
+      writer.uint32(26).string(message.schedule);
+    }
+    if (message.name !== undefined) {
+      writer.uint32(34).string(message.name);
+    }
+    for (const v of message.labels) {
+      writer.uint32(42).string(v!);
+    }
+    if (message.sub_id !== undefined) {
+      writer.uint32(48).int32(message.sub_id);
+    }
+    for (const v of message.extra_schedules) {
+      ExtraScheduleItem.encode(v!, writer.uint32(58).fork()).join();
+    }
+    if (message.task_before !== undefined) {
+      writer.uint32(66).string(message.task_before);
+    }
+    if (message.task_after !== undefined) {
+      writer.uint32(74).string(message.task_after);
+    }
+    if (message.status !== undefined) {
+      writer.uint32(80).int32(message.status);
+    }
+    if (message.log_path !== undefined) {
+      writer.uint32(90).string(message.log_path);
+    }
+    if (message.pid !== undefined) {
+      writer.uint32(96).int32(message.pid);
+    }
+    if (message.last_running_time !== undefined) {
+      writer.uint32(104).int64(message.last_running_time);
+    }
+    if (message.last_execution_time !== undefined) {
+      writer.uint32(112).int64(message.last_execution_time);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CronItem {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCronItem();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.command = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.schedule = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.labels.push(reader.string());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.sub_id = reader.int32();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.extra_schedules.push(ExtraScheduleItem.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.task_before = reader.string();
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+
+          message.task_after = reader.string();
+          continue;
+        }
+        case 10: {
+          if (tag !== 80) {
+            break;
+          }
+
+          message.status = reader.int32();
+          continue;
+        }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+
+          message.log_path = reader.string();
+          continue;
+        }
+        case 12: {
+          if (tag !== 96) {
+            break;
+          }
+
+          message.pid = reader.int32();
+          continue;
+        }
+        case 13: {
+          if (tag !== 104) {
+            break;
+          }
+
+          message.last_running_time = longToNumber(reader.int64());
+          continue;
+        }
+        case 14: {
+          if (tag !== 112) {
+            break;
+          }
+
+          message.last_execution_time = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CronItem {
+    return {
+      id: isSet(object.id) ? globalThis.Number(object.id) : undefined,
+      command: isSet(object.command) ? globalThis.String(object.command) : undefined,
+      schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : undefined,
+      name: isSet(object.name) ? globalThis.String(object.name) : undefined,
+      labels: globalThis.Array.isArray(object?.labels) ? object.labels.map((e: any) => globalThis.String(e)) : [],
+      sub_id: isSet(object.sub_id) ? globalThis.Number(object.sub_id) : undefined,
+      extra_schedules: globalThis.Array.isArray(object?.extra_schedules)
+        ? object.extra_schedules.map((e: any) => ExtraScheduleItem.fromJSON(e))
+        : [],
+      task_before: isSet(object.task_before) ? globalThis.String(object.task_before) : undefined,
+      task_after: isSet(object.task_after) ? globalThis.String(object.task_after) : undefined,
+      status: isSet(object.status) ? globalThis.Number(object.status) : undefined,
+      log_path: isSet(object.log_path) ? globalThis.String(object.log_path) : undefined,
+      pid: isSet(object.pid) ? globalThis.Number(object.pid) : undefined,
+      last_running_time: isSet(object.last_running_time) ? globalThis.Number(object.last_running_time) : undefined,
+      last_execution_time: isSet(object.last_execution_time)
+        ? globalThis.Number(object.last_execution_time)
+        : undefined,
+    };
+  },
+
+  toJSON(message: CronItem): unknown {
+    const obj: any = {};
+    if (message.id !== undefined) {
+      obj.id = Math.round(message.id);
+    }
+    if (message.command !== undefined) {
+      obj.command = message.command;
+    }
+    if (message.schedule !== undefined) {
+      obj.schedule = message.schedule;
+    }
+    if (message.name !== undefined) {
+      obj.name = message.name;
+    }
+    if (message.labels?.length) {
+      obj.labels = message.labels;
+    }
+    if (message.sub_id !== undefined) {
+      obj.sub_id = Math.round(message.sub_id);
+    }
+    if (message.extra_schedules?.length) {
+      obj.extra_schedules = message.extra_schedules.map((e) => ExtraScheduleItem.toJSON(e));
+    }
+    if (message.task_before !== undefined) {
+      obj.task_before = message.task_before;
+    }
+    if (message.task_after !== undefined) {
+      obj.task_after = message.task_after;
+    }
+    if (message.status !== undefined) {
+      obj.status = Math.round(message.status);
+    }
+    if (message.log_path !== undefined) {
+      obj.log_path = message.log_path;
+    }
+    if (message.pid !== undefined) {
+      obj.pid = Math.round(message.pid);
+    }
+    if (message.last_running_time !== undefined) {
+      obj.last_running_time = Math.round(message.last_running_time);
+    }
+    if (message.last_execution_time !== undefined) {
+      obj.last_execution_time = Math.round(message.last_execution_time);
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CronItem>, I>>(base?: I): CronItem {
+    return CronItem.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CronItem>, I>>(object: I): CronItem {
+    const message = createBaseCronItem();
+    message.id = object.id ?? undefined;
+    message.command = object.command ?? undefined;
+    message.schedule = object.schedule ?? undefined;
+    message.name = object.name ?? undefined;
+    message.labels = object.labels?.map((e) => e) || [];
+    message.sub_id = object.sub_id ?? undefined;
+    message.extra_schedules = object.extra_schedules?.map((e) => ExtraScheduleItem.fromPartial(e)) || [];
+    message.task_before = object.task_before ?? undefined;
+    message.task_after = object.task_after ?? undefined;
+    message.status = object.status ?? undefined;
+    message.log_path = object.log_path ?? undefined;
+    message.pid = object.pid ?? undefined;
+    message.last_running_time = object.last_running_time ?? undefined;
+    message.last_execution_time = object.last_execution_time ?? undefined;
+    return message;
+  },
+};
+
+function createBaseCreateCronRequest(): CreateCronRequest {
+  return {
+    command: "",
+    schedule: "",
+    name: undefined,
+    labels: [],
+    sub_id: undefined,
+    extra_schedules: [],
+    task_before: undefined,
+    task_after: undefined,
+  };
+}
+
+export const CreateCronRequest: MessageFns<CreateCronRequest> = {
+  encode(message: CreateCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.command !== "") {
+      writer.uint32(10).string(message.command);
+    }
+    if (message.schedule !== "") {
+      writer.uint32(18).string(message.schedule);
+    }
+    if (message.name !== undefined) {
+      writer.uint32(26).string(message.name);
+    }
+    for (const v of message.labels) {
+      writer.uint32(34).string(v!);
+    }
+    if (message.sub_id !== undefined) {
+      writer.uint32(40).int32(message.sub_id);
+    }
+    for (const v of message.extra_schedules) {
+      ExtraScheduleItem.encode(v!, writer.uint32(50).fork()).join();
+    }
+    if (message.task_before !== undefined) {
+      writer.uint32(58).string(message.task_before);
+    }
+    if (message.task_after !== undefined) {
+      writer.uint32(66).string(message.task_after);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CreateCronRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateCronRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.command = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.schedule = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.labels.push(reader.string());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.sub_id = reader.int32();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+
+          message.extra_schedules.push(ExtraScheduleItem.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.task_before = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.task_after = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CreateCronRequest {
+    return {
+      command: isSet(object.command) ? globalThis.String(object.command) : "",
+      schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : undefined,
+      labels: globalThis.Array.isArray(object?.labels) ? object.labels.map((e: any) => globalThis.String(e)) : [],
+      sub_id: isSet(object.sub_id) ? globalThis.Number(object.sub_id) : undefined,
+      extra_schedules: globalThis.Array.isArray(object?.extra_schedules)
+        ? object.extra_schedules.map((e: any) => ExtraScheduleItem.fromJSON(e))
+        : [],
+      task_before: isSet(object.task_before) ? globalThis.String(object.task_before) : undefined,
+      task_after: isSet(object.task_after) ? globalThis.String(object.task_after) : undefined,
+    };
+  },
+
+  toJSON(message: CreateCronRequest): unknown {
+    const obj: any = {};
+    if (message.command !== "") {
+      obj.command = message.command;
+    }
+    if (message.schedule !== "") {
+      obj.schedule = message.schedule;
+    }
+    if (message.name !== undefined) {
+      obj.name = message.name;
+    }
+    if (message.labels?.length) {
+      obj.labels = message.labels;
+    }
+    if (message.sub_id !== undefined) {
+      obj.sub_id = Math.round(message.sub_id);
+    }
+    if (message.extra_schedules?.length) {
+      obj.extra_schedules = message.extra_schedules.map((e) => ExtraScheduleItem.toJSON(e));
+    }
+    if (message.task_before !== undefined) {
+      obj.task_before = message.task_before;
+    }
+    if (message.task_after !== undefined) {
+      obj.task_after = message.task_after;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateCronRequest>, I>>(base?: I): CreateCronRequest {
+    return CreateCronRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CreateCronRequest>, I>>(object: I): CreateCronRequest {
+    const message = createBaseCreateCronRequest();
+    message.command = object.command ?? "";
+    message.schedule = object.schedule ?? "";
+    message.name = object.name ?? undefined;
+    message.labels = object.labels?.map((e) => e) || [];
+    message.sub_id = object.sub_id ?? undefined;
+    message.extra_schedules = object.extra_schedules?.map((e) => ExtraScheduleItem.fromPartial(e)) || [];
+    message.task_before = object.task_before ?? undefined;
+    message.task_after = object.task_after ?? undefined;
+    return message;
+  },
+};
+
+function createBaseUpdateCronRequest(): UpdateCronRequest {
+  return {
+    id: 0,
+    command: "",
+    schedule: "",
+    name: undefined,
+    labels: [],
+    sub_id: undefined,
+    extra_schedules: [],
+    task_before: undefined,
+    task_after: undefined,
+  };
+}
+
+export const UpdateCronRequest: MessageFns<UpdateCronRequest> = {
+  encode(message: UpdateCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.id !== 0) {
+      writer.uint32(8).int32(message.id);
+    }
+    if (message.command !== "") {
+      writer.uint32(18).string(message.command);
+    }
+    if (message.schedule !== "") {
+      writer.uint32(26).string(message.schedule);
+    }
+    if (message.name !== undefined) {
+      writer.uint32(34).string(message.name);
+    }
+    for (const v of message.labels) {
+      writer.uint32(42).string(v!);
+    }
+    if (message.sub_id !== undefined) {
+      writer.uint32(48).int32(message.sub_id);
+    }
+    for (const v of message.extra_schedules) {
+      ExtraScheduleItem.encode(v!, writer.uint32(58).fork()).join();
+    }
+    if (message.task_before !== undefined) {
+      writer.uint32(66).string(message.task_before);
+    }
+    if (message.task_after !== undefined) {
+      writer.uint32(74).string(message.task_after);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): UpdateCronRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseUpdateCronRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.id = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.command = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.schedule = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.labels.push(reader.string());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.sub_id = reader.int32();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.extra_schedules.push(ExtraScheduleItem.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.task_before = reader.string();
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+
+          message.task_after = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): UpdateCronRequest {
+    return {
+      id: isSet(object.id) ? globalThis.Number(object.id) : 0,
+      command: isSet(object.command) ? globalThis.String(object.command) : "",
+      schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : undefined,
+      labels: globalThis.Array.isArray(object?.labels) ? object.labels.map((e: any) => globalThis.String(e)) : [],
+      sub_id: isSet(object.sub_id) ? globalThis.Number(object.sub_id) : undefined,
+      extra_schedules: globalThis.Array.isArray(object?.extra_schedules)
+        ? object.extra_schedules.map((e: any) => ExtraScheduleItem.fromJSON(e))
+        : [],
+      task_before: isSet(object.task_before) ? globalThis.String(object.task_before) : undefined,
+      task_after: isSet(object.task_after) ? globalThis.String(object.task_after) : undefined,
+    };
+  },
+
+  toJSON(message: UpdateCronRequest): unknown {
+    const obj: any = {};
+    if (message.id !== 0) {
+      obj.id = Math.round(message.id);
+    }
+    if (message.command !== "") {
+      obj.command = message.command;
+    }
+    if (message.schedule !== "") {
+      obj.schedule = message.schedule;
+    }
+    if (message.name !== undefined) {
+      obj.name = message.name;
+    }
+    if (message.labels?.length) {
+      obj.labels = message.labels;
+    }
+    if (message.sub_id !== undefined) {
+      obj.sub_id = Math.round(message.sub_id);
+    }
+    if (message.extra_schedules?.length) {
+      obj.extra_schedules = message.extra_schedules.map((e) => ExtraScheduleItem.toJSON(e));
+    }
+    if (message.task_before !== undefined) {
+      obj.task_before = message.task_before;
+    }
+    if (message.task_after !== undefined) {
+      obj.task_after = message.task_after;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<UpdateCronRequest>, I>>(base?: I): UpdateCronRequest {
+    return UpdateCronRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<UpdateCronRequest>, I>>(object: I): UpdateCronRequest {
+    const message = createBaseUpdateCronRequest();
+    message.id = object.id ?? 0;
+    message.command = object.command ?? "";
+    message.schedule = object.schedule ?? "";
+    message.name = object.name ?? undefined;
+    message.labels = object.labels?.map((e) => e) || [];
+    message.sub_id = object.sub_id ?? undefined;
+    message.extra_schedules = object.extra_schedules?.map((e) => ExtraScheduleItem.fromPartial(e)) || [];
+    message.task_before = object.task_before ?? undefined;
+    message.task_after = object.task_after ?? undefined;
+    return message;
+  },
+};
+
+function createBaseDeleteCronsRequest(): DeleteCronsRequest {
+  return { ids: [] };
+}
+
+export const DeleteCronsRequest: MessageFns<DeleteCronsRequest> = {
+  encode(message: DeleteCronsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    writer.uint32(10).fork();
+    for (const v of message.ids) {
+      writer.int32(v);
+    }
+    writer.join();
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseDeleteCronsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag === 8) {
+            message.ids.push(reader.int32());
+
+            continue;
+          }
+
+          if (tag === 10) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.ids.push(reader.int32());
+            }
+
+            continue;
+          }
+
+          break;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): DeleteCronsRequest {
+    return { ids: globalThis.Array.isArray(object?.ids) ? object.ids.map((e: any) => globalThis.Number(e)) : [] };
+  },
+
+  toJSON(message: DeleteCronsRequest): unknown {
+    const obj: any = {};
+    if (message.ids?.length) {
+      obj.ids = message.ids.map((e) => Math.round(e));
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<DeleteCronsRequest>, I>>(base?: I): DeleteCronsRequest {
+    return DeleteCronsRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<DeleteCronsRequest>, I>>(object: I): DeleteCronsRequest {
+    const message = createBaseDeleteCronsRequest();
+    message.ids = object.ids?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseCronsResponse(): CronsResponse {
+  return { code: 0, data: [], message: undefined };
+}
+
+export const CronsResponse: MessageFns<CronsResponse> = {
+  encode(message: CronsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.code !== 0) {
+      writer.uint32(8).int32(message.code);
+    }
+    for (const v of message.data) {
+      CronItem.encode(v!, writer.uint32(18).fork()).join();
+    }
+    if (message.message !== undefined) {
+      writer.uint32(26).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CronsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCronsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.code = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.data.push(CronItem.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CronsResponse {
+    return {
+      code: isSet(object.code) ? globalThis.Number(object.code) : 0,
+      data: globalThis.Array.isArray(object?.data) ? object.data.map((e: any) => CronItem.fromJSON(e)) : [],
+      message: isSet(object.message) ? globalThis.String(object.message) : undefined,
+    };
+  },
+
+  toJSON(message: CronsResponse): unknown {
+    const obj: any = {};
+    if (message.code !== 0) {
+      obj.code = Math.round(message.code);
+    }
+    if (message.data?.length) {
+      obj.data = message.data.map((e) => CronItem.toJSON(e));
+    }
+    if (message.message !== undefined) {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CronsResponse>, I>>(base?: I): CronsResponse {
+    return CronsResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CronsResponse>, I>>(object: I): CronsResponse {
+    const message = createBaseCronsResponse();
+    message.code = object.code ?? 0;
+    message.data = object.data?.map((e) => CronItem.fromPartial(e)) || [];
+    message.message = object.message ?? undefined;
+    return message;
+  },
+};
+
+function createBaseCronResponse(): CronResponse {
+  return { code: 0, data: undefined, message: undefined };
+}
+
+export const CronResponse: MessageFns<CronResponse> = {
+  encode(message: CronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.code !== 0) {
+      writer.uint32(8).int32(message.code);
+    }
+    if (message.data !== undefined) {
+      CronItem.encode(message.data, writer.uint32(18).fork()).join();
+    }
+    if (message.message !== undefined) {
+      writer.uint32(26).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CronResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCronResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.code = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.data = CronItem.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CronResponse {
+    return {
+      code: isSet(object.code) ? globalThis.Number(object.code) : 0,
+      data: isSet(object.data) ? CronItem.fromJSON(object.data) : undefined,
+      message: isSet(object.message) ? globalThis.String(object.message) : undefined,
+    };
+  },
+
+  toJSON(message: CronResponse): unknown {
+    const obj: any = {};
+    if (message.code !== 0) {
+      obj.code = Math.round(message.code);
+    }
+    if (message.data !== undefined) {
+      obj.data = CronItem.toJSON(message.data);
+    }
+    if (message.message !== undefined) {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CronResponse>, I>>(base?: I): CronResponse {
+    return CronResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CronResponse>, I>>(object: I): CronResponse {
+    const message = createBaseCronResponse();
+    message.code = object.code ?? 0;
+    message.data = (object.data !== undefined && object.data !== null) ? CronItem.fromPartial(object.data) : undefined;
+    message.message = object.message ?? undefined;
+    return message;
+  },
+};
+
+function createBaseCronDetailRequest(): CronDetailRequest {
+  return { log_path: "" };
+}
+
+export const CronDetailRequest: MessageFns<CronDetailRequest> = {
+  encode(message: CronDetailRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.log_path !== "") {
+      writer.uint32(10).string(message.log_path);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CronDetailRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCronDetailRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.log_path = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CronDetailRequest {
+    return { log_path: isSet(object.log_path) ? globalThis.String(object.log_path) : "" };
+  },
+
+  toJSON(message: CronDetailRequest): unknown {
+    const obj: any = {};
+    if (message.log_path !== "") {
+      obj.log_path = message.log_path;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CronDetailRequest>, I>>(base?: I): CronDetailRequest {
+    return CronDetailRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CronDetailRequest>, I>>(object: I): CronDetailRequest {
+    const message = createBaseCronDetailRequest();
+    message.log_path = object.log_path ?? "";
+    return message;
+  },
+};
+
+function createBaseCronDetailResponse(): CronDetailResponse {
+  return { code: 0, data: undefined, message: undefined };
+}
+
+export const CronDetailResponse: MessageFns<CronDetailResponse> = {
+  encode(message: CronDetailResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.code !== 0) {
+      writer.uint32(8).int32(message.code);
+    }
+    if (message.data !== undefined) {
+      CronItem.encode(message.data, writer.uint32(18).fork()).join();
+    }
+    if (message.message !== undefined) {
+      writer.uint32(26).string(message.message);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): CronDetailResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCronDetailResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+
+          message.code = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.data = CronItem.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.message = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CronDetailResponse {
+    return {
+      code: isSet(object.code) ? globalThis.Number(object.code) : 0,
+      data: isSet(object.data) ? CronItem.fromJSON(object.data) : undefined,
+      message: isSet(object.message) ? globalThis.String(object.message) : undefined,
+    };
+  },
+
+  toJSON(message: CronDetailResponse): unknown {
+    const obj: any = {};
+    if (message.code !== 0) {
+      obj.code = Math.round(message.code);
+    }
+    if (message.data !== undefined) {
+      obj.data = CronItem.toJSON(message.data);
+    }
+    if (message.message !== undefined) {
+      obj.message = message.message;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CronDetailResponse>, I>>(base?: I): CronDetailResponse {
+    return CronDetailResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<CronDetailResponse>, I>>(object: I): CronDetailResponse {
+    const message = createBaseCronDetailResponse();
+    message.code = object.code ?? 0;
+    message.data = (object.data !== undefined && object.data !== null) ? CronItem.fromPartial(object.data) : undefined;
+    message.message = object.message ?? undefined;
+    return message;
+  },
+};
+
 export type ApiService = typeof ApiService;
 export const ApiService = {
   getEnvs: {
@@ -1260,6 +2490,42 @@ export const ApiService = {
     responseSerialize: (value: Response) => Buffer.from(Response.encode(value).finish()),
     responseDeserialize: (value: Buffer) => Response.decode(value),
   },
+  getCronDetail: {
+    path: "/com.ql.api.Api/GetCronDetail",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: CronDetailRequest) => Buffer.from(CronDetailRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer) => CronDetailRequest.decode(value),
+    responseSerialize: (value: CronDetailResponse) => Buffer.from(CronDetailResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer) => CronDetailResponse.decode(value),
+  },
+  createCron: {
+    path: "/com.ql.api.Api/CreateCron",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: CreateCronRequest) => Buffer.from(CreateCronRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer) => CreateCronRequest.decode(value),
+    responseSerialize: (value: CronResponse) => Buffer.from(CronResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer) => CronResponse.decode(value),
+  },
+  updateCron: {
+    path: "/com.ql.api.Api/UpdateCron",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: UpdateCronRequest) => Buffer.from(UpdateCronRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer) => UpdateCronRequest.decode(value),
+    responseSerialize: (value: CronResponse) => Buffer.from(CronResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer) => CronResponse.decode(value),
+  },
+  deleteCrons: {
+    path: "/com.ql.api.Api/DeleteCrons",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: DeleteCronsRequest) => Buffer.from(DeleteCronsRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer) => DeleteCronsRequest.decode(value),
+    responseSerialize: (value: Response) => Buffer.from(Response.encode(value).finish()),
+    responseDeserialize: (value: Buffer) => Response.decode(value),
+  },
 } as const;
 
 export interface ApiServer extends UntypedServiceImplementation {
@@ -1273,6 +2539,10 @@ export interface ApiServer extends UntypedServiceImplementation {
   updateEnvNames: handleUnaryCall<UpdateEnvNamesRequest, Response>;
   getEnvById: handleUnaryCall<GetEnvByIdRequest, EnvResponse>;
   systemNotify: handleUnaryCall<SystemNotifyRequest, Response>;
+  getCronDetail: handleUnaryCall<CronDetailRequest, CronDetailResponse>;
+  createCron: handleUnaryCall<CreateCronRequest, CronResponse>;
+  updateCron: handleUnaryCall<UpdateCronRequest, CronResponse>;
+  deleteCrons: handleUnaryCall<DeleteCronsRequest, Response>;
 }
 
 export interface ApiClient extends Client {
@@ -1426,6 +2696,66 @@ export interface ApiClient extends Client {
     options: Partial<CallOptions>,
     callback: (error: ServiceError | null, response: Response) => void,
   ): ClientUnaryCall;
+  getCronDetail(
+    request: CronDetailRequest,
+    callback: (error: ServiceError | null, response: CronDetailResponse) => void,
+  ): ClientUnaryCall;
+  getCronDetail(
+    request: CronDetailRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: CronDetailResponse) => void,
+  ): ClientUnaryCall;
+  getCronDetail(
+    request: CronDetailRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: CronDetailResponse) => void,
+  ): ClientUnaryCall;
+  createCron(
+    request: CreateCronRequest,
+    callback: (error: ServiceError | null, response: CronResponse) => void,
+  ): ClientUnaryCall;
+  createCron(
+    request: CreateCronRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: CronResponse) => void,
+  ): ClientUnaryCall;
+  createCron(
+    request: CreateCronRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: CronResponse) => void,
+  ): ClientUnaryCall;
+  updateCron(
+    request: UpdateCronRequest,
+    callback: (error: ServiceError | null, response: CronResponse) => void,
+  ): ClientUnaryCall;
+  updateCron(
+    request: UpdateCronRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: CronResponse) => void,
+  ): ClientUnaryCall;
+  updateCron(
+    request: UpdateCronRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: CronResponse) => void,
+  ): ClientUnaryCall;
+  deleteCrons(
+    request: DeleteCronsRequest,
+    callback: (error: ServiceError | null, response: Response) => void,
+  ): ClientUnaryCall;
+  deleteCrons(
+    request: DeleteCronsRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: Response) => void,
+  ): ClientUnaryCall;
+  deleteCrons(
+    request: DeleteCronsRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: Response) => void,
+  ): ClientUnaryCall;
 }
 
 export const ApiClient = makeGenericClientConstructor(ApiService, "com.ql.api.Api") as unknown as {
@@ -1446,6 +2776,26 @@ type KeysOfUnion<T> = T extends T ? keyof T : never;
 export type Exact<P, I extends P> = P extends Builtin ? P
   : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 
+function longToNumber(int64: { toString(): string }): number {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+
 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;
+}
diff --git a/back/protos/cron.ts b/back/protos/cron.ts
index d0491c1d..8524dfaf 100644
--- a/back/protos/cron.ts
+++ b/back/protos/cron.ts
@@ -1,10 +1,11 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.181.2
+//   protoc-gen-ts_proto  v2.6.1
 //   protoc               v3.17.3
 // source: back/protos/cron.proto
 
 /* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import {
   type CallOptions,
   ChannelCredentials,
@@ -17,7 +18,6 @@ import {
   type ServiceError,
   type UntypedServiceImplementation,
 } from "@grpc/grpc-js";
-import _m0 from "protobufjs/minimal";
 
 export const protobufPackage = "com.ql.cron";
 
@@ -29,7 +29,7 @@ export interface ICron {
   id: string;
   schedule: string;
   command: string;
-  extraSchedules: ISchedule[];
+  extra_schedules: ISchedule[];
   name: string;
 }
 
@@ -51,33 +51,34 @@ function createBaseISchedule(): ISchedule {
   return { schedule: "" };
 }
 
-export const ISchedule = {
-  encode(message: ISchedule, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const ISchedule: MessageFns<ISchedule> = {
+  encode(message: ISchedule, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.schedule !== "") {
       writer.uint32(10).string(message.schedule);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ISchedule {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): ISchedule {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseISchedule();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.schedule = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -105,11 +106,11 @@ export const ISchedule = {
 };
 
 function createBaseICron(): ICron {
-  return { id: "", schedule: "", command: "", extraSchedules: [], name: "" };
+  return { id: "", schedule: "", command: "", extra_schedules: [], name: "" };
 }
 
-export const ICron = {
-  encode(message: ICron, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const ICron: MessageFns<ICron> = {
+  encode(message: ICron, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.id !== "") {
       writer.uint32(10).string(message.id);
     }
@@ -119,8 +120,8 @@ export const ICron = {
     if (message.command !== "") {
       writer.uint32(26).string(message.command);
     }
-    for (const v of message.extraSchedules) {
-      ISchedule.encode(v!, writer.uint32(34).fork()).ldelim();
+    for (const v of message.extra_schedules) {
+      ISchedule.encode(v!, writer.uint32(34).fork()).join();
     }
     if (message.name !== "") {
       writer.uint32(42).string(message.name);
@@ -128,53 +129,58 @@ export const ICron = {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): ICron {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  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:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.id = reader.string();
           continue;
-        case 2:
+        }
+        case 2: {
           if (tag !== 18) {
             break;
           }
 
           message.schedule = reader.string();
           continue;
-        case 3:
+        }
+        case 3: {
           if (tag !== 26) {
             break;
           }
 
           message.command = reader.string();
           continue;
-        case 4:
+        }
+        case 4: {
           if (tag !== 34) {
             break;
           }
 
-          message.extraSchedules.push(ISchedule.decode(reader, reader.uint32()));
+          message.extra_schedules.push(ISchedule.decode(reader, reader.uint32()));
           continue;
-        case 5:
+        }
+        case 5: {
           if (tag !== 42) {
             break;
           }
 
           message.name = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -184,8 +190,8 @@ export const ICron = {
       id: isSet(object.id) ? globalThis.String(object.id) : "",
       schedule: isSet(object.schedule) ? globalThis.String(object.schedule) : "",
       command: isSet(object.command) ? globalThis.String(object.command) : "",
-      extraSchedules: globalThis.Array.isArray(object?.extraSchedules)
-        ? object.extraSchedules.map((e: any) => ISchedule.fromJSON(e))
+      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) : "",
     };
@@ -202,8 +208,8 @@ export const ICron = {
     if (message.command !== "") {
       obj.command = message.command;
     }
-    if (message.extraSchedules?.length) {
-      obj.extraSchedules = message.extraSchedules.map((e) => ISchedule.toJSON(e));
+    if (message.extra_schedules?.length) {
+      obj.extra_schedules = message.extra_schedules.map((e) => ISchedule.toJSON(e));
     }
     if (message.name !== "") {
       obj.name = message.name;
@@ -219,7 +225,7 @@ export const ICron = {
     message.id = object.id ?? "";
     message.schedule = object.schedule ?? "";
     message.command = object.command ?? "";
-    message.extraSchedules = object.extraSchedules?.map((e) => ISchedule.fromPartial(e)) || [];
+    message.extra_schedules = object.extra_schedules?.map((e) => ISchedule.fromPartial(e)) || [];
     message.name = object.name ?? "";
     return message;
   },
@@ -229,33 +235,34 @@ function createBaseAddCronRequest(): AddCronRequest {
   return { crons: [] };
 }
 
-export const AddCronRequest = {
-  encode(message: AddCronRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const AddCronRequest: MessageFns<AddCronRequest> = {
+  encode(message: AddCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     for (const v of message.crons) {
-      ICron.encode(v!, writer.uint32(10).fork()).ldelim();
+      ICron.encode(v!, writer.uint32(10).fork()).join();
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): AddCronRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): AddCronRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseAddCronRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.crons.push(ICron.decode(reader, reader.uint32()));
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -286,13 +293,13 @@ function createBaseAddCronResponse(): AddCronResponse {
   return {};
 }
 
-export const AddCronResponse = {
-  encode(_: AddCronResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const AddCronResponse: MessageFns<AddCronResponse> = {
+  encode(_: AddCronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): AddCronResponse {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): AddCronResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseAddCronResponse();
     while (reader.pos < end) {
@@ -302,7 +309,7 @@ export const AddCronResponse = {
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -329,33 +336,34 @@ function createBaseDeleteCronRequest(): DeleteCronRequest {
   return { ids: [] };
 }
 
-export const DeleteCronRequest = {
-  encode(message: DeleteCronRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const DeleteCronRequest: MessageFns<DeleteCronRequest> = {
+  encode(message: DeleteCronRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     for (const v of message.ids) {
       writer.uint32(10).string(v!);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): DeleteCronRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseDeleteCronRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.ids.push(reader.string());
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -386,13 +394,13 @@ function createBaseDeleteCronResponse(): DeleteCronResponse {
   return {};
 }
 
-export const DeleteCronResponse = {
-  encode(_: DeleteCronResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const DeleteCronResponse: MessageFns<DeleteCronResponse> = {
+  encode(_: DeleteCronResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): DeleteCronResponse {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): DeleteCronResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseDeleteCronResponse();
     while (reader.pos < end) {
@@ -402,7 +410,7 @@ export const DeleteCronResponse = {
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -506,3 +514,12 @@ export type Exact<P, I extends P> = P extends Builtin ? P
 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;
+}
diff --git a/back/protos/health.ts b/back/protos/health.ts
index b0360d6b..adaf9761 100644
--- a/back/protos/health.ts
+++ b/back/protos/health.ts
@@ -1,25 +1,25 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v1.181.2
+//   protoc-gen-ts_proto  v2.6.1
 //   protoc               v3.17.3
 // source: back/protos/health.proto
 
 /* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import {
   type CallOptions,
   ChannelCredentials,
   Client,
   type ClientOptions,
-  ClientReadableStream,
+  type ClientReadableStream,
   type ClientUnaryCall,
-  handleServerStreamingCall,
+  type handleServerStreamingCall,
   type handleUnaryCall,
   makeGenericClientConstructor,
   Metadata,
   type ServiceError,
   type UntypedServiceImplementation,
 } from "@grpc/grpc-js";
-import _m0 from "protobufjs/minimal";
 
 export const protobufPackage = "com.ql.health";
 
@@ -80,33 +80,34 @@ function createBaseHealthCheckRequest(): HealthCheckRequest {
   return { service: "" };
 }
 
-export const HealthCheckRequest = {
-  encode(message: HealthCheckRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const HealthCheckRequest: MessageFns<HealthCheckRequest> = {
+  encode(message: HealthCheckRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.service !== "") {
       writer.uint32(10).string(message.service);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HealthCheckRequest {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): HealthCheckRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseHealthCheckRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 10) {
             break;
           }
 
           message.service = reader.string();
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -137,33 +138,34 @@ function createBaseHealthCheckResponse(): HealthCheckResponse {
   return { status: 0 };
 }
 
-export const HealthCheckResponse = {
-  encode(message: HealthCheckResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+export const HealthCheckResponse: MessageFns<HealthCheckResponse> = {
+  encode(message: HealthCheckResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
     if (message.status !== 0) {
       writer.uint32(8).int32(message.status);
     }
     return writer;
   },
 
-  decode(input: _m0.Reader | Uint8Array, length?: number): HealthCheckResponse {
-    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+  decode(input: BinaryReader | Uint8Array, length?: number): HealthCheckResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseHealthCheckResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
-        case 1:
+        case 1: {
           if (tag !== 8) {
             break;
           }
 
           message.status = reader.int32() as any;
           continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
-      reader.skipType(tag & 7);
+      reader.skip(tag & 7);
     }
     return message;
   },
@@ -262,3 +264,12 @@ export type Exact<P, I extends P> = P extends Builtin ? P
 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;
+}
diff --git a/back/schedule/addCron.ts b/back/schedule/addCron.ts
index 0d4281ba..69f641d6 100644
--- a/back/schedule/addCron.ts
+++ b/back/schedule/addCron.ts
@@ -10,7 +10,7 @@ const addCron = (
   callback: sendUnaryData<AddCronResponse>,
 ) => {
   for (const item of call.request.crons) {
-    const { id, schedule, command, extraSchedules, name } = item;
+    const { id, schedule, command, extra_schedules, name } = item;
     if (scheduleStacks.has(id)) {
       scheduleStacks.get(id)?.forEach((x) => x.cancel());
     }
@@ -23,8 +23,8 @@ const addCron = (
       command,
     );
 
-    if (extraSchedules?.length) {
-      extraSchedules.forEach((x) => {
+    if (extra_schedules?.length) {
+      extra_schedules.forEach((x) => {
         Logger.info(
           '[schedule][创建定时任务], 任务ID: %s, 名称: %s, cron: %s, 执行命令: %s',
           id,
@@ -40,8 +40,8 @@ const addCron = (
         Logger.info(`[schedule][准备运行任务] 命令: ${command}`);
         runCron(command, item);
       }),
-      ...(extraSchedules?.length
-        ? extraSchedules.map((x) =>
+      ...(extra_schedules?.length
+        ? extra_schedules.map((x) =>
             nodeSchedule.scheduleJob(id, x.schedule, async () => {
               Logger.info(`[schedule][准备运行任务] 命令: ${command}`);
               runCron(command, item);
diff --git a/back/schedule/api.ts b/back/schedule/api.ts
index 080c07c5..be301543 100644
--- a/back/schedule/api.ts
+++ b/back/schedule/api.ts
@@ -4,6 +4,7 @@ import EnvService from '../services/env';
 import { sendUnaryData, ServerUnaryCall } from '@grpc/grpc-js';
 import {
   CreateEnvRequest,
+  CronItem,
   DeleteEnvsRequest,
   DisableEnvsRequest,
   EnableEnvsRequest,
@@ -21,6 +22,15 @@ import {
 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);
 
@@ -171,3 +181,58 @@ export const systemNotify = async (
     callback(e);
   }
 };
+
+export const getCronDetail = async (
+  call: ServerUnaryCall<CronDetailRequest, CronDetailResponse>,
+  callback: sendUnaryData<CronDetailResponse>,
+) => {
+  try {
+    const cronService = Container.get(CronService);
+    const data = (await cronService.find({
+      log_path: call.request.log_path,
+    })) as CronItem;
+    console.log('data', data);
+    callback(null, { code: 200, data: data || undefined });
+  } 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 });
+  } catch (e: any) {
+    callback(e);
+  }
+};
+
+export const updateCron = async (
+  call: ServerUnaryCall<UpdateCronRequest, CronResponse>,
+  callback: sendUnaryData<CronResponse>,
+) => {
+  try {
+    const cronService = Container.get(CronService);
+    const data = (await cronService.update(call.request)) as CronItem;
+    callback(null, { code: 200, 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);
+  }
+};
diff --git a/back/services/cron.ts b/back/services/cron.ts
index e7ed12e7..299d691c 100644
--- a/back/services/cron.ts
+++ b/back/services/cron.ts
@@ -46,7 +46,7 @@ export default class CronService {
           id: String(doc.id),
           schedule: doc.schedule!,
           command: this.makeCommand(doc),
-          extraSchedules: doc.extra_schedules || [],
+          extra_schedules: doc.extra_schedules || [],
         },
       ]);
     }
@@ -76,7 +76,7 @@ export default class CronService {
           id: String(newDoc.id),
           schedule: newDoc.schedule!,
           command: this.makeCommand(newDoc),
-          extraSchedules: newDoc.extra_schedules || [],
+          extra_schedules: newDoc.extra_schedules || [],
         },
       ]);
     }
@@ -320,10 +320,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;
     }
@@ -424,7 +424,7 @@ export default class CronService {
           name: cron.name,
           command: cron.command,
           schedule: cron.schedule,
-          extraSchedules: cron.extra_schedules,
+          extra_schedules: cron.extra_schedules,
         };
         if (cron.status !== CrontabStatus.queued) {
           resolve(params);
@@ -508,7 +508,7 @@ export default class CronService {
         id: String(doc.id),
         schedule: doc.schedule!,
         command: this.makeCommand(doc),
-        extraSchedules: doc.extra_schedules || [],
+        extra_schedules: doc.extra_schedules || [],
       }));
     await cronClient.addCron(sixCron);
     await this.set_crontab();
@@ -653,7 +653,7 @@ export default class CronService {
         id: String(doc.id),
         schedule: doc.schedule!,
         command: this.makeCommand(doc),
-        extraSchedules: doc.extra_schedules || [],
+        extra_schedules: doc.extra_schedules || [],
       }));
     await cronClient.addCron(sixCron);
   }
diff --git a/package.json b/package.json
index 06e53ffd..e9ce468c 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,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",
@@ -88,7 +88,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",
@@ -171,7 +171,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",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index c5edf812..66c6144d 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -8,6 +8,9 @@ overrides:
   sqlite3: git+https://github.com/whyour/node-sqlite3.git#v1.0.3
 
 dependencies:
+  '@bufbuild/protobuf':
+    specifier: ^2.2.3
+    version: 2.2.3
   '@grpc/grpc-js':
     specifier: ^1.12.3
     version: 1.12.3
@@ -101,9 +104,6 @@ dependencies:
   proper-lockfile:
     specifier: ^4.1.2
     version: 4.1.2
-  protobufjs:
-    specifier: ^7.4.0
-    version: 7.4.0
   pstree.remy:
     specifier: ^1.1.8
     version: 1.1.8
@@ -335,8 +335,8 @@ devDependencies:
     specifier: ^10.9.2
     version: 10.9.2(@types/node@17.0.45)(typescript@5.2.2)
   ts-proto:
-    specifier: ^1.146.0
-    version: 1.181.2
+    specifier: ^2.6.1
+    version: 2.6.1
   tslib:
     specifier: ^2.4.0
     version: 2.8.1
@@ -1380,6 +1380,9 @@ packages:
     resolution: {integrity: sha512-h0OYmPR3A5Dfbetra/GzxBAzQk8sH7LhRkRUTdagX6nrtlUgJGYCTv4bBK33jsTQw9HDd8PE2x1Ma+iRKEDUsw==}
     dev: true
 
+  /@bufbuild/protobuf@2.2.3:
+    resolution: {integrity: sha512-tFQoXHJdkEOSwj5tRIZSPNUuXK3RaR7T1nUrPgbYX1pUbvqqaaZAsfo+NXBPsz5rZMSKVFrgK1WL8Q/MSLvprg==}
+
   /@chenshuai2144/sketch-color@1.0.9(react@18.3.1):
     resolution: {integrity: sha512-obzSy26cb7Pm7OprWyVpgMpIlrZpZ0B7vbrU0RMbvRg0YAI890S5Xy02Aj1Nhl4+KTbi1lVYHt6HQP8Hm9s+1w==}
     peerDependencies:
@@ -3271,36 +3274,46 @@ packages:
 
   /@protobufjs/aspromise@1.1.2:
     resolution: {integrity: sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==}
+    dev: false
 
   /@protobufjs/base64@1.1.2:
     resolution: {integrity: sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==}
+    dev: false
 
   /@protobufjs/codegen@2.0.4:
     resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==}
+    dev: false
 
   /@protobufjs/eventemitter@1.1.0:
     resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==}
+    dev: false
 
   /@protobufjs/fetch@1.1.0:
     resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==}
     dependencies:
       '@protobufjs/aspromise': 1.1.2
       '@protobufjs/inquire': 1.1.0
+    dev: false
 
   /@protobufjs/float@1.0.2:
     resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==}
+    dev: false
 
   /@protobufjs/inquire@1.1.0:
     resolution: {integrity: sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==}
+    dev: false
 
   /@protobufjs/path@1.1.2:
     resolution: {integrity: sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==}
+    dev: false
 
   /@protobufjs/pool@1.1.0:
     resolution: {integrity: sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==}
+    dev: false
 
   /@protobufjs/utf8@1.1.0:
     resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
+    dev: false
 
   /@qixian.cs/path-to-regexp@6.1.0:
     resolution: {integrity: sha512-2jIiLiVZB1jnY7IIRQKtoV8Gnr7XIhk4mC88ONGunZE3hYt5IHUG4BE/6+JiTBjjEWQLBeWnZB8hGpppkufiVw==}
@@ -9846,6 +9859,7 @@ packages:
 
   /long@5.2.3:
     resolution: {integrity: sha512-lcHwpNoggQTObv5apGNCTdJrO69eHOZMi4BNC+rTLER8iHAqGrUVeLh/irVIM7zTw2bOXA8T6uNPeujwOLg/2Q==}
+    dev: false
 
   /loose-envify@1.4.0:
     resolution: {integrity: sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==}
@@ -11749,6 +11763,7 @@ packages:
       '@protobufjs/utf8': 1.1.0
       '@types/node': 17.0.45
       long: 5.2.3
+    dev: false
 
   /proxy-addr@2.0.7:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
@@ -14528,21 +14543,20 @@ packages:
       dprint-node: 1.0.8
     dev: true
 
-  /ts-proto-descriptors@1.16.0:
-    resolution: {integrity: sha512-3yKuzMLpltdpcyQji1PJZRfoo4OJjNieKTYkQY8pF7xGKsYz/RHe3aEe4KiRxcinoBmnEhmuI+yJTxLb922ULA==}
+  /ts-proto-descriptors@2.0.0:
+    resolution: {integrity: sha512-wHcTH3xIv11jxgkX5OyCSFfw27agpInAd6yh89hKG6zqIXnjW9SYqSER2CVQxdPj4czeOhGagNvZBEbJPy7qkw==}
     dependencies:
-      long: 5.2.3
-      protobufjs: 7.4.0
+      '@bufbuild/protobuf': 2.2.3
     dev: true
 
-  /ts-proto@1.181.2:
-    resolution: {integrity: sha512-knJ8dtjn2Pd0c5ZGZG8z9DMiD4PUY8iGI9T9tb8DvGdWRMkLpf0WcPO7G+7cmbZyxvNTAG6ci3fybEaFgMZIvg==}
+  /ts-proto@2.6.1:
+    resolution: {integrity: sha512-4LTT99MkwkF1+fIA0b2mZu/58Qlpq3Q1g53TwEMZZgR1w/uX00PoVT4Z8aKJxMw0LeKQD4s9NrJYsF27Clckrg==}
     hasBin: true
     dependencies:
+      '@bufbuild/protobuf': 2.2.3
       case-anything: 2.1.13
-      protobufjs: 7.4.0
       ts-poet: 6.9.0
-      ts-proto-descriptors: 1.16.0
+      ts-proto-descriptors: 2.0.0
     dev: true
 
   /tslib@1.14.1:
diff --git a/shell/preload/client.js b/shell/preload/client.js
index 9da5c1dd..6ca48a4e 100644
--- a/shell/preload/client.js
+++ b/shell/preload/client.js
@@ -1,45 +1,134 @@
 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,
   };
-};
 
-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),
-};
+  static #methods = [
+    'getEnvs',
+    'createEnv',
+    'updateEnv',
+    'deleteEnvs',
+    'moveEnv',
+    'disableEnvs',
+    'enableEnvs',
+    'updateEnvNames',
+    'getEnvById',
+    'systemNotify',
+    'getCronDetail',
+    'createCron',
+    'updateCron',
+    'deleteCrons'
+  ];
 
-module.exports = api;
+  #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 grpcMethod = 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,
+        );
+
+        grpcMethod(params, metadata, { deadline }, (error, response) => {
+          if (error) {
+            return reject(error);
+          }
+          resolve(response);
+        });
+      });
+    };
+  }
+
+  #bindMethods() {
+    GrpcClient.#methods.forEach((method) => {
+      this.#api[method] = this.#promisifyMethod(method);
+    });
+  }
+
+  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);
+});
+
+module.exports = grpcClient.getApi();
diff --git a/shell/preload/client.py b/shell/preload/client.py
index 27013bc3..ebdf3619 100644
--- a/shell/preload/client.py
+++ b/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"unknown error: {func_name}() requires a dictionary with parameters: {{{fields_str}}}"
+                    ) from None
+            raise Exception(f"unknown error: {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"unknown error: {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('name', 'Error')}: {error_data.get('stack')}"
             )
 
-            if result.returncode != 0:
-                error_data = json.loads(result.stderr)
-                raise Exception(f"{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)