Merge branch 'canary' into 1345-domain-not-working-after-server-restart-or-traefik-reload

apps/dokploy/server/api/routers/ai.ts

@@ -25,6 +25,10 @@ import {
 	addNewService,
 	checkServiceAccess,
 } from "@dokploy/server/services/user";
+import {
+	getProviderHeaders,
+	type Model,
+} from "@dokploy/server/utils/ai/select-ai-provider";
 import { TRPCError } from "@trpc/server";
 import { z } from "zod";
 
@@ -41,6 +45,58 @@ export const aiRouter = createTRPCRouter({
 			}
 			return aiSetting;
 		}),
+
+	getModels: protectedProcedure
+		.input(z.object({ apiUrl: z.string().min(1), apiKey: z.string().min(1) }))
+		.query(async ({ input }) => {
+			try {
+				const headers = getProviderHeaders(input.apiUrl, input.apiKey);
+				const response = await fetch(`${input.apiUrl}/models`, { headers });
+
+				if (!response.ok) {
+					const errorText = await response.text();
+					throw new Error(`Failed to fetch models: ${errorText}`);
+				}
+
+				const res = await response.json();
+
+				if (Array.isArray(res)) {
+					return res.map((model) => ({
+						id: model.id || model.name,
+						object: "model",
+						created: Date.now(),
+						owned_by: "provider",
+					}));
+				}
+
+				if (res.models) {
+					return res.models.map((model: any) => ({
+						id: model.id || model.name,
+						object: "model",
+						created: Date.now(),
+						owned_by: "provider",
+					})) as Model[];
+				}
+
+				if (res.data) {
+					return res.data as Model[];
+				}
+
+				const possibleModels =
+					(Object.values(res).find(Array.isArray) as any[]) || [];
+				return possibleModels.map((model) => ({
+					id: model.id || model.name,
+					object: "model",
+					created: Date.now(),
+					owned_by: "provider",
+				})) as Model[];
+			} catch (error) {
+				throw new TRPCError({
+					code: "BAD_REQUEST",
+					message: error instanceof Error ? error?.message : `Error: ${error}`,
+				});
+			}
+		}),
 	create: adminProcedure.input(apiCreateAi).mutation(async ({ ctx, input }) => {
 		return await saveAiSettings(ctx.session.activeOrganizationId, input);
 	}),

apps/dokploy/server/api/routers/application.ts

@@ -344,6 +344,7 @@ export const applicationRouter = createTRPCRouter({
 				buildPath: input.buildPath,
 				applicationStatus: "idle",
 				githubId: input.githubId,
+				watchPaths: input.watchPaths,
 			});
 
 			return true;
@@ -370,6 +371,7 @@ export const applicationRouter = createTRPCRouter({
 				gitlabId: input.gitlabId,
 				gitlabProjectId: input.gitlabProjectId,
 				gitlabPathNamespace: input.gitlabPathNamespace,
+				watchPaths: input.watchPaths,
 			});
 
 			return true;
@@ -394,6 +396,7 @@ export const applicationRouter = createTRPCRouter({
 				sourceType: "bitbucket",
 				applicationStatus: "idle",
 				bitbucketId: input.bitbucketId,
+				watchPaths: input.watchPaths,
 			});
 
 			return true;
@@ -440,6 +443,7 @@ export const applicationRouter = createTRPCRouter({
 				customGitSSHKeyId: input.customGitSSHKeyId,
 				sourceType: "git",
 				applicationStatus: "idle",
+				watchPaths: input.watchPaths,
 			});
 
 			return true;
@@ -668,4 +672,49 @@ export const applicationRouter = createTRPCRouter({
 
 			return stats;
 		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				applicationId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const application = await findApplicationById(input.applicationId);
+			if (
+				application.project.organizationId !== ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this application",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the application's projectId
+			const updatedApplication = await db
+				.update(applications)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(applications.applicationId, input.applicationId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedApplication) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move application",
+				});
+			}
+
+			return updatedApplication;
+		}),
 });

apps/dokploy/server/api/routers/compose.ts

@@ -8,7 +8,7 @@ import {
 	apiFindCompose,
 	apiRandomizeCompose,
 	apiUpdateCompose,
-	compose,
+	compose as composeTable,
 } from "@/server/db/schema";
 import { cleanQueuesByCompose, myQueue } from "@/server/queues/queueSetup";
 import { templates } from "@/templates/templates";
@@ -24,6 +24,7 @@ import { dump } from "js-yaml";
 import _ from "lodash";
 import { nanoid } from "nanoid";
 import { createTRPCRouter, protectedProcedure } from "../trpc";
+import { z } from "zod";
 
 import type { DeploymentJob } from "@/server/queues/queue-types";
 import { deploy } from "@/server/utils/deploy";
@@ -157,8 +158,8 @@ export const composeRouter = createTRPCRouter({
 			4;
 
 			const result = await db
-				.delete(compose)
-				.where(eq(compose.composeId, input.composeId))
+				.delete(composeTable)
+				.where(eq(composeTable.composeId, input.composeId))
 				.returning();
 
 			const cleanupOperations = [
@@ -501,4 +502,48 @@ export const composeRouter = createTRPCRouter({
 		const uniqueTags = _.uniq(allTags);
 		return uniqueTags;
 	}),
+
+	move: protectedProcedure
+		.input(
+			z.object({
+				composeId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const compose = await findComposeById(input.composeId);
+			if (compose.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this compose",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the compose's projectId
+			const updatedCompose = await db
+				.update(composeTable)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(composeTable.composeId, input.composeId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedCompose) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move compose",
+				});
+			}
+
+			return updatedCompose;
+		}),
 });

apps/dokploy/server/api/routers/destination.ts

@@ -21,7 +21,7 @@ import {
 	updateDestinationById,
 } from "@dokploy/server";
 import { TRPCError } from "@trpc/server";
-import { eq } from "drizzle-orm";
+import { eq, desc } from "drizzle-orm";
 
 export const destinationRouter = createTRPCRouter({
 	create: adminProcedure
@@ -98,6 +98,7 @@ export const destinationRouter = createTRPCRouter({
 	all: protectedProcedure.query(async ({ ctx }) => {
 		return await db.query.destinations.findMany({
 			where: eq(destinations.organizationId, ctx.session.activeOrganizationId),
+			orderBy: [desc(destinations.createdAt)],
 		});
 	}),
 	remove: adminProcedure

apps/dokploy/server/api/routers/mariadb.ts

@@ -8,6 +8,8 @@ import {
 	apiSaveEnvironmentVariablesMariaDB,
 	apiSaveExternalPortMariaDB,
 	apiUpdateMariaDB,
+	apiRebuildMariadb,
+	mariadb as mariadbTable,
 } from "@/server/db/schema";
 import { cancelJobs } from "@/server/utils/backup";
 import {
@@ -30,7 +32,10 @@ import {
 } from "@dokploy/server";
 import { TRPCError } from "@trpc/server";
 import { observable } from "@trpc/server/observable";
-
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { db } from "@/server/db";
+import { rebuildDatabase } from "@dokploy/server";
 export const mariadbRouter = createTRPCRouter({
 	create: protectedProcedure
 		.input(apiCreateMariaDB)
@@ -320,6 +325,63 @@ export const mariadbRouter = createTRPCRouter({
 				});
 			}
 
+			return true;
+		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				mariadbId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const mariadb = await findMariadbById(input.mariadbId);
+			if (mariadb.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this mariadb",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the mariadb's projectId
+			const updatedMariadb = await db
+				.update(mariadbTable)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(mariadbTable.mariadbId, input.mariadbId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedMariadb) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move mariadb",
+				});
+			}
+
+			return updatedMariadb;
+		}),
+	rebuild: protectedProcedure
+		.input(apiRebuildMariadb)
+		.mutation(async ({ input, ctx }) => {
+			const mariadb = await findMariadbById(input.mariadbId);
+			if (mariadb.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to rebuild this MariaDB database",
+				});
+			}
+
+			await rebuildDatabase(mariadb.mariadbId, "mariadb");
 			return true;
 		}),
 });

apps/dokploy/server/api/routers/mongo.ts

@@ -4,10 +4,12 @@ import {
 	apiCreateMongo,
 	apiDeployMongo,
 	apiFindOneMongo,
+	apiRebuildMongo,
 	apiResetMongo,
 	apiSaveEnvironmentVariablesMongo,
 	apiSaveExternalPortMongo,
 	apiUpdateMongo,
+	mongo as mongoTable,
 } from "@/server/db/schema";
 import { cancelJobs } from "@/server/utils/backup";
 import {
@@ -30,7 +32,10 @@ import {
 } from "@dokploy/server";
 import { TRPCError } from "@trpc/server";
 import { observable } from "@trpc/server/observable";
-
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { db } from "@/server/db";
+import { rebuildDatabase } from "@dokploy/server";
 export const mongoRouter = createTRPCRouter({
 	create: protectedProcedure
 		.input(apiCreateMongo)
@@ -334,6 +339,64 @@ export const mongoRouter = createTRPCRouter({
 				});
 			}
 
+			return true;
+		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				mongoId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const mongo = await findMongoById(input.mongoId);
+			if (mongo.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this mongo",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the mongo's projectId
+			const updatedMongo = await db
+				.update(mongoTable)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(mongoTable.mongoId, input.mongoId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedMongo) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move mongo",
+				});
+			}
+
+			return updatedMongo;
+		}),
+	rebuild: protectedProcedure
+		.input(apiRebuildMongo)
+		.mutation(async ({ input, ctx }) => {
+			const mongo = await findMongoById(input.mongoId);
+			if (mongo.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to rebuild this MongoDB database",
+				});
+			}
+
+			await rebuildDatabase(mongo.mongoId, "mongo");
+
 			return true;
 		}),
 });

apps/dokploy/server/api/routers/mysql.ts

@@ -4,10 +4,12 @@ import {
 	apiCreateMySql,
 	apiDeployMySql,
 	apiFindOneMySql,
+	apiRebuildMysql,
 	apiResetMysql,
 	apiSaveEnvironmentVariablesMySql,
 	apiSaveExternalPortMySql,
 	apiUpdateMySql,
+	mysql as mysqlTable,
 } from "@/server/db/schema";
 
 import { TRPCError } from "@trpc/server";
@@ -23,6 +25,7 @@ import {
 	findBackupsByDbId,
 	findMySqlById,
 	findProjectById,
+	rebuildDatabase,
 	removeMySqlById,
 	removeService,
 	startService,
@@ -32,6 +35,9 @@ import {
 	updateMySqlById,
 } from "@dokploy/server";
 import { observable } from "@trpc/server/observable";
+import { eq } from "drizzle-orm";
+import { db } from "@/server/db";
+import { z } from "zod";
 
 export const mysqlRouter = createTRPCRouter({
 	create: protectedProcedure
@@ -330,6 +336,64 @@ export const mysqlRouter = createTRPCRouter({
 				});
 			}
 
+			return true;
+		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				mysqlId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const mysql = await findMySqlById(input.mysqlId);
+			if (mysql.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this mysql",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the mysql's projectId
+			const updatedMysql = await db
+				.update(mysqlTable)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(mysqlTable.mysqlId, input.mysqlId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedMysql) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move mysql",
+				});
+			}
+
+			return updatedMysql;
+		}),
+	rebuild: protectedProcedure
+		.input(apiRebuildMysql)
+		.mutation(async ({ input, ctx }) => {
+			const mysql = await findMySqlById(input.mysqlId);
+			if (mysql.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to rebuild this MySQL database",
+				});
+			}
+
+			await rebuildDatabase(mysql.mysqlId, "mysql");
+
 			return true;
 		}),
 });

apps/dokploy/server/api/routers/organization.ts

@@ -133,6 +133,18 @@ export const organizationRouter = createTRPCRouter({
 				});
 			}
 
+			const ownerOrgs = await db.query.organization.findMany({
+				where: eq(organization.ownerId, ctx.user.id),
+			});
+
+			if (ownerOrgs.length <= 1) {
+				throw new TRPCError({
+					code: "FORBIDDEN",
+					message:
+						"You must maintain at least one organization where you are the owner",
+				});
+			}
+
 			const result = await db
 				.delete(organization)
 				.where(eq(organization.id, input.organizationId));

apps/dokploy/server/api/routers/postgres.ts

@@ -4,10 +4,12 @@ import {
 	apiCreatePostgres,
 	apiDeployPostgres,
 	apiFindOnePostgres,
+	apiRebuildPostgres,
 	apiResetPostgres,
 	apiSaveEnvironmentVariablesPostgres,
 	apiSaveExternalPortPostgres,
 	apiUpdatePostgres,
+	postgres as postgresTable,
 } from "@/server/db/schema";
 import { cancelJobs } from "@/server/utils/backup";
 import {
@@ -20,6 +22,7 @@ import {
 	findBackupsByDbId,
 	findPostgresById,
 	findProjectById,
+	rebuildDatabase,
 	removePostgresById,
 	removeService,
 	startService,
@@ -30,7 +33,9 @@ import {
 } from "@dokploy/server";
 import { TRPCError } from "@trpc/server";
 import { observable } from "@trpc/server/observable";
-
+import { z } from "zod";
+import { eq } from "drizzle-orm";
+import { db } from "@/server/db";
 export const postgresRouter = createTRPCRouter({
 	create: protectedProcedure
 		.input(apiCreatePostgres)
@@ -350,6 +355,68 @@ export const postgresRouter = createTRPCRouter({
 				});
 			}
 
+			return true;
+		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				postgresId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const postgres = await findPostgresById(input.postgresId);
+			if (
+				postgres.project.organizationId !== ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this postgres",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the postgres's projectId
+			const updatedPostgres = await db
+				.update(postgresTable)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(postgresTable.postgresId, input.postgresId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedPostgres) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move postgres",
+				});
+			}
+
+			return updatedPostgres;
+		}),
+	rebuild: protectedProcedure
+		.input(apiRebuildPostgres)
+		.mutation(async ({ input, ctx }) => {
+			const postgres = await findPostgresById(input.postgresId);
+			if (
+				postgres.project.organizationId !== ctx.session.activeOrganizationId
+			) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to rebuild this Postgres database",
+				});
+			}
+
+			await rebuildDatabase(postgres.postgresId, "postgres");
+
 			return true;
 		}),
 });

apps/dokploy/server/api/routers/redis.ts

@@ -8,6 +8,8 @@ import {
 	apiSaveEnvironmentVariablesRedis,
 	apiSaveExternalPortRedis,
 	apiUpdateRedis,
+	redis as redisTable,
+	apiRebuildRedis,
 } from "@/server/db/schema";
 
 import { TRPCError } from "@trpc/server";
@@ -30,7 +32,10 @@ import {
 	updateRedisById,
 } from "@dokploy/server";
 import { observable } from "@trpc/server/observable";
-
+import { eq } from "drizzle-orm";
+import { db } from "@/server/db";
+import { z } from "zod";
+import { rebuildDatabase } from "@dokploy/server";
 export const redisRouter = createTRPCRouter({
 	create: protectedProcedure
 		.input(apiCreateRedis)
@@ -314,6 +319,63 @@ export const redisRouter = createTRPCRouter({
 				});
 			}
 
+			return true;
+		}),
+	move: protectedProcedure
+		.input(
+			z.object({
+				redisId: z.string(),
+				targetProjectId: z.string(),
+			}),
+		)
+		.mutation(async ({ input, ctx }) => {
+			const redis = await findRedisById(input.redisId);
+			if (redis.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move this redis",
+				});
+			}
+
+			const targetProject = await findProjectById(input.targetProjectId);
+			if (targetProject.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to move to this project",
+				});
+			}
+
+			// Update the redis's projectId
+			const updatedRedis = await db
+				.update(redisTable)
+				.set({
+					projectId: input.targetProjectId,
+				})
+				.where(eq(redisTable.redisId, input.redisId))
+				.returning()
+				.then((res) => res[0]);
+
+			if (!updatedRedis) {
+				throw new TRPCError({
+					code: "INTERNAL_SERVER_ERROR",
+					message: "Failed to move redis",
+				});
+			}
+
+			return updatedRedis;
+		}),
+	rebuild: protectedProcedure
+		.input(apiRebuildRedis)
+		.mutation(async ({ input, ctx }) => {
+			const redis = await findRedisById(input.redisId);
+			if (redis.project.organizationId !== ctx.session.activeOrganizationId) {
+				throw new TRPCError({
+					code: "UNAUTHORIZED",
+					message: "You are not authorized to rebuild this Redis database",
+				});
+			}
+
+			await rebuildDatabase(redis.redisId, "redis");
 			return true;
 		}),
 });

apps/dokploy/server/api/routers/server.ts

@@ -206,6 +206,10 @@ export const serverRouter = createTRPCRouter({
 						enabled: boolean;
 						version: string;
 					};
+					railpack: {
+						enabled: boolean;
+						version: string;
+					};
 					isDokployNetworkInstalled: boolean;
 					isSwarmInstalled: boolean;
 					isMainDirectoryInstalled: boolean;

apps/dokploy/server/api/routers/settings.ts

@@ -28,7 +28,6 @@ import {
 	getDokployImageTag,
 	getUpdateData,
 	initializeTraefik,
-	logRotationManager,
 	parseRawConfig,
 	paths,
 	prepareEnvironmentVariables,
@@ -49,6 +48,9 @@ import {
 	writeConfig,
 	writeMainConfig,
 	writeTraefikConfigInPath,
+	startLogCleanup,
+	stopLogCleanup,
+	getLogCleanupStatus,
 } from "@dokploy/server";
 import { checkGPUStatus, setupGPUSupport } from "@dokploy/server";
 import { generateOpenApiDocument } from "@dokploy/trpc-openapi";
@@ -570,48 +572,51 @@ export const settingsRouter = createTRPCRouter({
 					totalCount: 0,
 				};
 			}
-			const rawConfig = readMonitoringConfig();
+			const rawConfig = readMonitoringConfig(
+				!!input.dateRange?.start && !!input.dateRange?.end,
+			);
+
 			const parsedConfig = parseRawConfig(
 				rawConfig as string,
 				input.page,
 				input.sort,
 				input.search,
 				input.status,
+				input.dateRange,
 			);
 
 			return parsedConfig;
 		}),
-	readStats: adminProcedure.query(() => {
-		if (IS_CLOUD) {
-			return [];
-		}
-		const rawConfig = readMonitoringConfig();
-		const processedLogs = processLogs(rawConfig as string);
-		return processedLogs || [];
-	}),
-	getLogRotateStatus: adminProcedure.query(async () => {
-		if (IS_CLOUD) {
-			return true;
-		}
-		return await logRotationManager.getStatus();
-	}),
-	toggleLogRotate: adminProcedure
+	readStats: adminProcedure
+		.meta({
+			openapi: {
+				path: "/read-stats",
+				method: "POST",
+				override: true,
+				enabled: false,
+			},
+		})
 		.input(
-			z.object({
-				enable: z.boolean(),
-			}),
+			z
+				.object({
+					dateRange: z
+						.object({
+							start: z.string().optional(),
+							end: z.string().optional(),
+						})
+						.optional(),
+				})
+				.optional(),
 		)
-		.mutation(async ({ input }) => {
+		.query(({ input }) => {
 			if (IS_CLOUD) {
-				return true;
+				return [];
 			}
-			if (input.enable) {
-				await logRotationManager.activate();
-			} else {
-				await logRotationManager.deactivate();
-			}
-
-			return true;
+			const rawConfig = readMonitoringConfig(
+				!!input?.dateRange?.start || !!input?.dateRange?.end,
+			);
+			const processedLogs = processLogs(rawConfig as string, input?.dateRange);
+			return processedLogs || [];
 		}),
 	haveActivateRequests: adminProcedure.query(async () => {
 		if (IS_CLOUD) {
@@ -831,10 +836,20 @@ export const settingsRouter = createTRPCRouter({
 				});
 			}
 		}),
+	updateLogCleanup: adminProcedure
+		.input(
+			z.object({
+				cronExpression: z.string().nullable(),
+			}),
+		)
+		.mutation(async ({ input }) => {
+			if (input.cronExpression) {
+				return startLogCleanup(input.cronExpression);
+			}
+			return stopLogCleanup();
+		}),
+
+	getLogCleanupStatus: adminProcedure.query(async () => {
+		return getLogCleanupStatus();
+	}),
 });
-// {
-// 	"Parallelism": 1,
-// 	"Delay": 10000000000,
-// 	"FailureAction": "rollback",
-// 	"Order": "start-first"
-//   }