Enhance schedule management with new fields and improved components

- Introduced new fields in the schedule schema: `serviceName`, `scheduleType`, and `script`, allowing for more flexible schedule configurations.
- Updated the `HandleSchedules` component to incorporate the new fields, enhancing user input options for schedule creation and updates.
- Refactored the `ShowSchedules` component to support the new `scheduleType` and display relevant information based on the selected type.
- Improved API handling for schedule creation and updates to accommodate the new fields, ensuring proper validation and error handling.
- Added a new `ShowSchedulesModal` component for better integration of schedule viewing in server settings, enhancing user experience.

packages/server/src/db/schema/compose.ts

@@ -15,7 +15,7 @@ import { server } from "./server";
 import { applicationStatus, triggerType } from "./shared";
 import { sshKeys } from "./ssh-key";
 import { generateAppName } from "./utils";
-
+import { schedules } from "./schedule";
 export const sourceTypeCompose = pgEnum("sourceTypeCompose", [
 	"git",
 	"github",
@@ -135,6 +135,7 @@ export const composeRelations = relations(compose, ({ one, many }) => ({
 		fields: [compose.serverId],
 		references: [server.serverId],
 	}),
+	schedules: many(schedules),
 }));
 
 const createSchema = createInsertSchema(compose, {

packages/server/src/db/schema/schedule.ts

@@ -6,9 +6,18 @@ import { z } from "zod";
 import { applications } from "./application";
 import { deployments } from "./deployment";
 import { generateAppName } from "./utils";
-
+import { compose } from "./compose";
+import { server } from "./server";
+import { users_temp } from "./user";
 export const shellTypes = pgEnum("shellType", ["bash", "sh"]);
 
+export const scheduleType = pgEnum("scheduleType", [
+	"application",
+	"compose",
+	"server",
+	"dokploy-server",
+]);
+
 export const schedules = pgTable("schedule", {
 	scheduleId: text("scheduleId")
 		.notNull()
@@ -19,13 +28,26 @@ export const schedules = pgTable("schedule", {
 	appName: text("appName")
 		.notNull()
 		.$defaultFn(() => generateAppName("schedule")),
+	serviceName: text("serviceName"),
 	shellType: shellTypes("shellType").notNull().default("bash"),
+	scheduleType: scheduleType("scheduleType").notNull().default("application"),
 	command: text("command").notNull(),
-	applicationId: text("applicationId")
-		.notNull()
-		.references(() => applications.applicationId, {
+	script: text("script"),
+	applicationId: text("applicationId").references(
+		() => applications.applicationId,
+		{
 			onDelete: "cascade",
-		}),
+		},
+	),
+	composeId: text("composeId").references(() => compose.composeId, {
+		onDelete: "cascade",
+	}),
+	serverId: text("serverId").references(() => server.serverId, {
+		onDelete: "cascade",
+	}),
+	userId: text("userId").references(() => users_temp.id, {
+		onDelete: "cascade",
+	}),
 	enabled: boolean("enabled").notNull().default(true),
 	createdAt: text("createdAt")
 		.notNull()
@@ -39,15 +61,22 @@ export const schedulesRelations = relations(schedules, ({ one, many }) => ({
 		fields: [schedules.applicationId],
 		references: [applications.applicationId],
 	}),
+	compose: one(compose, {
+		fields: [schedules.composeId],
+		references: [compose.composeId],
+	}),
+	server: one(server, {
+		fields: [schedules.serverId],
+		references: [server.serverId],
+	}),
+	user: one(users_temp, {
+		fields: [schedules.userId],
+		references: [users_temp.id],
+	}),
 	deployments: many(deployments),
 }));
 
-export const createScheduleSchema = createInsertSchema(schedules, {
-	name: z.string().min(1),
-	cronExpression: z.string().min(1),
-	command: z.string().min(1),
-	applicationId: z.string().min(1),
-});
+export const createScheduleSchema = createInsertSchema(schedules);
 
 export const updateScheduleSchema = createUpdateSchema(schedules).extend({
 	scheduleId: z.string().min(1),

packages/server/src/db/schema/server.ts

@@ -22,7 +22,7 @@ import { postgres } from "./postgres";
 import { redis } from "./redis";
 import { sshKeys } from "./ssh-key";
 import { generateAppName } from "./utils";
-
+import { schedules } from "./schedule";
 export const serverStatus = pgEnum("serverStatus", ["active", "inactive"]);
 
 export const server = pgTable("server", {
@@ -114,6 +114,7 @@ export const serverRelations = relations(server, ({ one, many }) => ({
 		fields: [server.organizationId],
 		references: [organization.id],
 	}),
+	schedules: many(schedules),
 }));
 
 const createSchema = createInsertSchema(server, {

packages/server/src/db/schema/user.ts

@@ -14,6 +14,7 @@ import { account, apikey, organization } from "./account";
 import { projects } from "./project";
 import { certificateType } from "./shared";
 import { backups } from "./backups";
+import { schedules } from "./schedule";
 /**
  * This is an example of how to use the multi-project schema feature of Drizzle ORM. Use the same
  * database instance for multiple projects.
@@ -127,6 +128,7 @@ export const usersRelations = relations(users_temp, ({ one, many }) => ({
 	projects: many(projects),
 	apiKeys: many(apikey),
 	backups: many(backups),
+	schedules: many(schedules),
 }));
 
 const createSchema = createInsertSchema(users_temp, {

packages/server/src/services/deployment.ts

@@ -281,17 +281,19 @@ export const createDeploymentSchedule = async (
 	const schedule = await findScheduleById(deployment.scheduleId);
 
 	try {
-		await removeDeploymentsSchedule(
-			deployment.scheduleId,
-			schedule.application.serverId,
-		);
-		const { SCHEDULES_PATH } = paths(!!schedule.application.serverId);
+		const serverId =
+			schedule.application?.serverId ||
+			schedule.compose?.serverId ||
+			schedule.server?.serverId;
+		await removeDeploymentsSchedule(deployment.scheduleId, serverId);
+		const { SCHEDULES_PATH } = paths(!!serverId);
 		const formattedDateTime = format(new Date(), "yyyy-MM-dd:HH:mm:ss");
 		const fileName = `${schedule.appName}-${formattedDateTime}.log`;
 		const logFilePath = path.join(SCHEDULES_PATH, schedule.appName, fileName);
 
-		if (schedule.application.serverId) {
-			const server = await findServerById(schedule.application.serverId);
+		if (serverId) {
+			console.log("serverId", serverId);
+			const server = await findServerById(serverId);
 
 			const command = `
 				mkdir -p ${SCHEDULES_PATH}/${schedule.appName};
@@ -324,6 +326,7 @@ export const createDeploymentSchedule = async (
 		}
 		return deploymentCreate[0];
 	} catch (error) {
+		console.log(error);
 		await db
 			.insert(deployments)
 			.values({
@@ -476,7 +479,7 @@ export const removeLastTenPreviewDeploymenById = async (
 
 export const removeDeploymentsSchedule = async (
 	scheduleId: string,
-	serverId: string | null,
+	serverId?: string | null,
 ) => {
 	const deploymentList = await db.query.deployments.findMany({
 		where: eq(deployments.scheduleId, scheduleId),

packages/server/src/services/schedule.ts

@@ -1,13 +1,41 @@
-import { schedules } from "../db/schema/schedule";
+import { type Schedule, schedules } from "../db/schema/schedule";
 import { db } from "../db";
 import { eq } from "drizzle-orm";
 import { TRPCError } from "@trpc/server";
+import type { z } from "zod";
+import type {
+	createScheduleSchema,
+	updateScheduleSchema,
+} from "../db/schema/schedule";
+import { execAsync, execAsyncRemote } from "../utils/process/execAsync";
+import { paths } from "../constants";
+import path from "node:path";
+
+export type ScheduleExtended = Awaited<ReturnType<typeof findScheduleById>>;
+
+export const createSchedule = async (
+	input: z.infer<typeof createScheduleSchema>,
+) => {
+	const { scheduleId, ...rest } = input;
+	const [newSchedule] = await db.insert(schedules).values(rest).returning();
+
+	if (
+		newSchedule &&
+		(newSchedule.scheduleType === "dokploy-server" ||
+			newSchedule.scheduleType === "server")
+	) {
+		await handleScript(newSchedule);
+	}
+	return newSchedule;
+};
 
 export const findScheduleById = async (scheduleId: string) => {
 	const schedule = await db.query.schedules.findFirst({
 		where: eq(schedules.scheduleId, scheduleId),
 		with: {
 			application: true,
+			compose: true,
+			server: true,
 		},
 	});
 
@@ -19,3 +47,66 @@ export const findScheduleById = async (scheduleId: string) => {
 	}
 	return schedule;
 };
+
+export const deleteSchedule = async (scheduleId: string) => {
+	const schedule = await findScheduleById(scheduleId);
+
+	const { SCHEDULES_PATH } = paths(!!schedule?.serverId);
+	const fullPath = path.join(SCHEDULES_PATH, schedule?.appName || "");
+	const command = `rm -rf ${fullPath}`;
+	if (schedule.serverId) {
+		await execAsyncRemote(schedule.serverId, command);
+	} else {
+		await execAsync(command);
+	}
+
+	const scheduleResult = await db
+		.delete(schedules)
+		.where(eq(schedules.scheduleId, scheduleId));
+	if (!scheduleResult) {
+		throw new TRPCError({
+			code: "NOT_FOUND",
+			message: "Schedule not found",
+		});
+	}
+
+	return true;
+};
+
+export const updateSchedule = async (
+	input: z.infer<typeof updateScheduleSchema>,
+) => {
+	const { scheduleId, ...rest } = input;
+	const [updatedSchedule] = await db
+		.update(schedules)
+		.set(rest)
+		.where(eq(schedules.scheduleId, scheduleId))
+		.returning();
+
+	if (
+		updatedSchedule?.scheduleType === "dokploy-server" ||
+		updatedSchedule?.scheduleType === "server"
+	) {
+		await handleScript(updatedSchedule);
+	}
+	return updatedSchedule;
+};
+
+const handleScript = async (schedule: Schedule) => {
+	const { SCHEDULES_PATH } = paths(!!schedule?.serverId);
+	const fullPath = path.join(SCHEDULES_PATH, schedule?.appName || "");
+
+	const script = `
+	 	 mkdir -p ${fullPath}
+	 	 rm -f ${fullPath}/script.sh
+		 touch ${fullPath}/script.sh
+		 chmod +x ${fullPath}/script.sh
+		 echo "${schedule?.script}" > ${fullPath}/script.sh
+	`;
+
+	if (schedule?.scheduleType === "dokploy-server") {
+		await execAsync(script);
+	} else if (schedule?.scheduleType === "server") {
+		await execAsyncRemote(schedule?.serverId || "", script);
+	}
+};

packages/server/src/utils/docker/utils.ts

@@ -13,6 +13,7 @@ import type { RedisNested } from "../databases/redis";
 import { execAsync, execAsyncRemote } from "../process/execAsync";
 import { spawnAsync } from "../process/spawnAsync";
 import { getRemoteDocker } from "../servers/remote-docker";
+import type { Compose } from "@dokploy/server/services/compose";
 
 interface RegistryAuth {
 	username: string;
@@ -541,3 +542,67 @@ export const getRemoteServiceContainer = async (
 		throw error;
 	}
 };
+
+export const getServiceContainerIV2 = async (
+	appName: string,
+	serverId?: string | null,
+) => {
+	try {
+		const filter = {
+			status: ["running"],
+			label: [`com.docker.swarm.service.name=${appName}`],
+		};
+		const remoteDocker = await getRemoteDocker(serverId);
+		const containers = await remoteDocker.listContainers({
+			filters: JSON.stringify(filter),
+		});
+
+		if (containers.length === 0 || !containers[0]) {
+			throw new Error(`No container found with name: ${appName}`);
+		}
+
+		const container = containers[0];
+		return container;
+	} catch (error) {
+		throw error;
+	}
+};
+
+export const getComposeContainer = async (
+	compose: Compose,
+	serviceName: string,
+) => {
+	try {
+		const { appName, composeType, serverId } = compose;
+		// 1. Determine the correct labels based on composeType
+		const labels: string[] = [];
+		if (composeType === "stack") {
+			// Labels for Docker Swarm stack services
+			labels.push(`com.docker.stack.namespace=${appName}`);
+			labels.push(`com.docker.swarm.service.name=${appName}_${serviceName}`);
+		} else {
+			// Labels for Docker Compose projects (default)
+			labels.push(`com.docker.compose.project=${appName}`);
+			labels.push(`com.docker.compose.service=${serviceName}`);
+		}
+		const filter = {
+			status: ["running"],
+			label: labels,
+		};
+
+		const remoteDocker = await getRemoteDocker(serverId);
+		const containers = await remoteDocker.listContainers({
+			filters: JSON.stringify(filter),
+			limit: 1,
+		});
+
+		if (containers.length === 0 || !containers[0]) {
+			throw new Error(`No container found with name: ${appName}`);
+		}
+
+		const container = containers[0];
+		return container;
+	} catch (error) {
+		throw error;
+	}
+};

packages/server/src/utils/schedules/utils.ts

@@ -1,15 +1,15 @@
 import type { Schedule } from "@dokploy/server/db/schema/schedule";
 import { findScheduleById } from "@dokploy/server/services/schedule";
 import { scheduleJob as scheduleJobNode } from "node-schedule";
-import {
-	getRemoteServiceContainer,
-	getServiceContainer,
-} from "../docker/utils";
+import { getComposeContainer, getServiceContainerIV2 } from "../docker/utils";
 import { execAsyncRemote } from "../process/execAsync";
 import { spawnAsync } from "../process/spawnAsync";
 import { createDeploymentSchedule } from "@dokploy/server/services/deployment";
 import { createWriteStream } from "node:fs";
 import { updateDeploymentStatus } from "@dokploy/server/services/deployment";
+import { paths } from "@dokploy/server/constants";
+import path from "node:path";
+
 export const scheduleJob = (schedule: Schedule) => {
 	const { cronExpression, scheduleId } = schedule;
 
@@ -19,17 +19,16 @@ export const scheduleJob = (schedule: Schedule) => {
 };
 
 export const runCommand = async (scheduleId: string) => {
-	const { application, command, shellType } =
-		await findScheduleById(scheduleId);
-
-	const isServer = !!application.serverId;
-
-	const { Id: containerId } = isServer
-		? await getRemoteServiceContainer(
-				application.serverId || "",
-				application.appName,
-			)
-		: await getServiceContainer(application.appName);
+	const {
+		application,
+		command,
+		shellType,
+		scheduleType,
+		compose,
+		serviceName,
+		appName,
+		serverId,
+	} = await findScheduleById(scheduleId);
 
 	const deployment = await createDeploymentSchedule({
 		scheduleId,
@@ -37,51 +36,109 @@ export const runCommand = async (scheduleId: string) => {
 		description: "Schedule",
 	});
 
-	if (isServer) {
-		try {
-			await execAsyncRemote(
+	if (scheduleType === "application" || scheduleType === "compose") {
+		let containerId = "";
+		let serverId = "";
+		if (scheduleType === "application" && application) {
+			const container = await getServiceContainerIV2(
+				application.appName,
 				application.serverId,
-				`
-                set -e
-				echo "Running command: docker exec ${containerId} ${shellType} -c \"${command}\"" >> ${deployment.logPath};
-                docker exec ${containerId} ${shellType} -c "${command}" || { 
-                    echo "❌ Command failed" >> ${deployment.logPath};
-                    exit 1;
-                }
-                `,
 			);
-		} catch (error) {
-			await updateDeploymentStatus(deployment.deploymentId, "error");
-			throw error;
+			containerId = container.Id;
+			serverId = application.serverId || "";
+		}
+		if (scheduleType === "compose" && compose) {
+			const container = await getComposeContainer(compose, serviceName || "");
+			containerId = container.Id;
+			serverId = compose.serverId || "";
 		}
-	} else {
-		const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
 
+		if (serverId) {
+			try {
+				await execAsyncRemote(
+					serverId,
+					`
+					set -e
+					echo "Running command: docker exec ${containerId} ${shellType} -c \"${command}\"" >> ${deployment.logPath};
+					docker exec ${containerId} ${shellType} -c "${command}" >> ${deployment.logPath} 2>> ${deployment.logPath} || { 
+						echo "❌ Command failed" >> ${deployment.logPath};
+						exit 1;
+					}
+					echo "✅ Command executed successfully" >> ${deployment.logPath};
+					`,
+				);
+			} catch (error) {
+				await updateDeploymentStatus(deployment.deploymentId, "error");
+				throw error;
+			}
+		} else {
+			const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
+
+			try {
+				writeStream.write(
+					`docker exec ${containerId} ${shellType} -c "${command}"\n`,
+				);
+				await spawnAsync(
+					"docker",
+					["exec", containerId, shellType, "-c", command],
+					(data) => {
+						if (writeStream.writable) {
+							writeStream.write(data);
+						}
+					},
+				);
+
+				writeStream.write("✅ Command executed successfully\n");
+			} catch (error) {
+				writeStream.write("❌ Command failed\n");
+				writeStream.write(
+					error instanceof Error ? error.message : "Unknown error",
+				);
+				writeStream.end();
+				await updateDeploymentStatus(deployment.deploymentId, "error");
+				throw error;
+			}
+		}
+	} else if (scheduleType === "dokploy-server") {
 		try {
-			writeStream.write(
-				`docker exec ${containerId} ${shellType} -c "${command}"\n`,
-			);
+			const writeStream = createWriteStream(deployment.logPath, { flags: "a" });
+			const { SCHEDULES_PATH } = paths();
+			const fullPath = path.join(SCHEDULES_PATH, appName || "");
+
 			await spawnAsync(
-				"docker",
-				["exec", containerId, shellType, "-c", command],
+				"bash",
+				["-c", "./script.sh"],
 				(data) => {
 					if (writeStream.writable) {
 						writeStream.write(data);
 					}
 				},
+				{
+					cwd: fullPath,
+				},
 			);
-
-			writeStream.write("✅ Command executed successfully\n");
 		} catch (error) {
-			writeStream.write("❌ Command failed\n");
-			writeStream.write(
-				error instanceof Error ? error.message : "Unknown error",
-			);
-			writeStream.end();
+			await updateDeploymentStatus(deployment.deploymentId, "error");
+			throw error;
+		}
+	} else if (scheduleType === "server") {
+		try {
+			const { SCHEDULES_PATH } = paths(true);
+			const fullPath = path.join(SCHEDULES_PATH, appName || "");
+			const command = `
+				set -e
+				echo "Running script" >> ${deployment.logPath};
+				bash -c ${fullPath}/script.sh >> ${deployment.logPath} 2>> ${deployment.logPath} || { 
+					echo "❌ Command failed" >> ${deployment.logPath};
+					exit 1;
+				  }
+				echo "✅ Command executed successfully" >> ${deployment.logPath};
+			`;
+			await execAsyncRemote(serverId, command);
+		} catch (error) {
 			await updateDeploymentStatus(deployment.deploymentId, "error");
 			throw error;
 		}
 	}
-
 	await updateDeploymentStatus(deployment.deploymentId, "done");
 };