feat(tasks): allow management of job intervals and disabling them (#3408)

2025-07-03 20:59:26 +02:00
parent 95c8aadb0c
commit 9398dd983c
37 changed files with 5224 additions and 195 deletions
--- a/packages/api/package.json
+++ b/packages/api/package.json
@@ -24,7 +24,7 @@
    "@homarr/auth": "workspace:^0.1.0",
    "@homarr/certificates": "workspace:^0.1.0",
    "@homarr/common": "workspace:^0.1.0",
-    "@homarr/cron-job-runner": "workspace:^0.1.0",
+    "@homarr/cron-job-api": "workspace:^0.1.0",
    "@homarr/cron-job-status": "workspace:^0.1.0",
    "@homarr/cron-jobs": "workspace:^0.1.0",
    "@homarr/db": "workspace:^0.1.0",
--- a/packages/api/src/router/cron-jobs.ts
+++ b/packages/api/src/router/cron-jobs.ts
@@ -1,7 +1,8 @@
 import { observable } from "@trpc/server/observable";
+import z from "zod/v4";

-import { objectEntries } from "@homarr/common";
-import { cronJobNames, cronJobs, jobNameSchema, triggerCronJobAsync } from "@homarr/cron-job-runner";
+import { cronExpressionSchema, jobGroupKeys, jobNameSchema } from "@homarr/cron-job-api";
+import { cronJobApi } from "@homarr/cron-job-api/client";
 import type { TaskStatus } from "@homarr/cron-job-status";
 import { createCronJobStatusChannel } from "@homarr/cron-job-status";
 import { logger } from "@homarr/log";
@@ -13,19 +14,51 @@ export const cronJobsRouter = createTRPCRouter({
    .requiresPermission("admin")
    .input(jobNameSchema)
    .mutation(async ({ input }) => {
-      await triggerCronJobAsync(input);
+      await cronJobApi.trigger.mutate(input);
    }),
-  getJobs: permissionRequiredProcedure.requiresPermission("admin").query(() => {
-    return objectEntries(cronJobs).map(([name, options]) => ({
-      name,
-      preventManualExecution: options.preventManualExecution,
-    }));
+  startJob: permissionRequiredProcedure
+    .requiresPermission("admin")
+    .input(jobNameSchema)
+    .mutation(async ({ input }) => {
+      await cronJobApi.start.mutate(input);
+    }),
+  stopJob: permissionRequiredProcedure
+    .requiresPermission("admin")
+    .input(jobNameSchema)
+    .mutation(async ({ input }) => {
+      await cronJobApi.stop.mutate(input);
+    }),
+  updateJobInterval: permissionRequiredProcedure
+    .requiresPermission("admin")
+    .input(
+      z.object({
+        name: jobNameSchema,
+        cron: cronExpressionSchema,
+      }),
+    )
+    .mutation(async ({ input }) => {
+      await cronJobApi.updateInterval.mutate(input);
+    }),
+  disableJob: permissionRequiredProcedure
+    .requiresPermission("admin")
+    .input(jobNameSchema)
+    .mutation(async ({ input }) => {
+      await cronJobApi.disable.mutate(input);
+    }),
+  enableJob: permissionRequiredProcedure
+    .requiresPermission("admin")
+    .input(jobNameSchema)
+    .mutation(async ({ input }) => {
+      await cronJobApi.enable.mutate(input);
+    }),
+  getJobs: permissionRequiredProcedure.requiresPermission("admin").query(async () => {
+    return await cronJobApi.getAll.query();
  }),
  subscribeToStatusUpdates: permissionRequiredProcedure.requiresPermission("admin").subscription(() => {
    return observable<TaskStatus>((emit) => {
      const unsubscribes: (() => void)[] = [];

-      for (const name of cronJobNames) {
+      for (const name of jobGroupKeys) {
        const channel = createCronJobStatusChannel(name);
        const unsubscribe = channel.subscribe((data) => {
          emit.next(data);
--- a/packages/common/src/cookie.ts
+++ b/packages/common/src/cookie.ts
@@ -1,10 +1,10 @@
-import type { CookieSerializeOptions } from "cookie";
+import type { SerializeOptions } from "cookie";
 import { parse, serialize } from "cookie";

 export function parseCookies(cookieString: string) {
  return parse(cookieString);
 }

-export function setClientCookie(name: string, value: string, options: CookieSerializeOptions = {}) {
+export function setClientCookie(name: string, value: string, options: SerializeOptions = {}) {
  document.cookie = serialize(name, value, options);
 }
--- a/packages/cron-job-runner/eslint.config.js
+++ b/packages/cron-job-runner/eslint.config.js
--- a/packages/cron-job-runner/package.json
+++ b/packages/cron-job-runner/package.json
@@ -1,12 +1,14 @@
 {
-  "name": "@homarr/cron-job-runner",
+  "name": "@homarr/cron-job-api",
  "version": "0.1.0",
  "private": true,
  "license": "Apache-2.0",
  "type": "module",
  "exports": {
-    ".": "./index.ts",
-    "./register": "./src/register.ts"
+    ".": "./src/index.ts",
+    "./env": "./src/env.ts",
+    "./constants": "./src/constants.ts",
+    "./client": "./src/client.ts"
  },
  "typesVersions": {
    "*": {
@@ -25,14 +27,22 @@
  "dependencies": {
    "@homarr/common": "workspace:^0.1.0",
    "@homarr/cron-jobs": "workspace:^0.1.0",
+    "@homarr/env": "workspace:^0.1.0",
    "@homarr/log": "workspace:^0.1.0",
-    "@homarr/redis": "workspace:^0.1.0",
-    "@homarr/validation": "workspace:^0.1.0"
+    "@tanstack/react-query": "^5.81.5",
+    "@trpc/client": "^11.4.3",
+    "@trpc/server": "^11.4.3",
+    "@trpc/tanstack-react-query": "^11.4.3",
+    "node-cron": "^4.2.0",
+    "react": "19.1.0",
+    "zod": "^3.25.67"
  },
  "devDependencies": {
    "@homarr/eslint-config": "workspace:^0.2.0",
    "@homarr/prettier-config": "workspace:^0.1.0",
    "@homarr/tsconfig": "workspace:^0.1.0",
+    "@types/node-cron": "^3.0.11",
+    "@types/react": "19.1.8",
    "eslint": "^9.30.1",
    "typescript": "^5.8.3"
  }
--- a/packages/cron-job-api/src/client.ts
+++ b/packages/cron-job-api/src/client.ts
@@ -0,0 +1,20 @@
+import { createTRPCClient, httpLink } from "@trpc/client";
+
+import type { JobRouter } from ".";
+import { CRON_JOB_API_KEY_HEADER, CRON_JOB_API_PATH, CRON_JOB_API_PORT } from "./constants";
+import { env } from "./env";
+
+export const cronJobApi = createTRPCClient<JobRouter>({
+  links: [
+    httpLink({
+      url: `${getBaseUrl()}${CRON_JOB_API_PATH}`,
+      headers: {
+        [CRON_JOB_API_KEY_HEADER]: env.CRON_JOB_API_KEY,
+      },
+    }),
+  ],
+});
+
+function getBaseUrl() {
+  return `http://localhost:${CRON_JOB_API_PORT}`;
+}
--- a/packages/cron-job-api/src/constants.ts
+++ b/packages/cron-job-api/src/constants.ts
@@ -0,0 +1,3 @@
+export const CRON_JOB_API_PORT = 3002;
+export const CRON_JOB_API_PATH = "/trpc";
+export const CRON_JOB_API_KEY_HEADER = "cron-job-api-key";
--- a/packages/cron-job-api/src/env.ts
+++ b/packages/cron-job-api/src/env.ts
@@ -0,0 +1,11 @@
+import { z } from "zod/v4";
+
+import { env as commonEnv } from "@homarr/common/env";
+import { createEnv } from "@homarr/env";
+
+export const env = createEnv({
+  server: {
+    CRON_JOB_API_KEY: commonEnv.NODE_ENV === "development" ? z.string().default("test") : z.string(),
+  },
+  experimental__runtimeEnv: process.env,
+});
--- a/packages/cron-job-api/src/index.ts
+++ b/packages/cron-job-api/src/index.ts
@@ -0,0 +1,82 @@
+import { initTRPC, TRPCError } from "@trpc/server";
+import { validate } from "node-cron";
+import { z } from "zod/v4";
+
+import type { JobGroupKeys } from "@homarr/cron-jobs";
+import { jobGroup } from "@homarr/cron-jobs";
+
+import { env } from "./env";
+
+export const jobGroupKeys = jobGroup.getKeys();
+export const jobNameSchema = z.enum(jobGroup.getKeys());
+
+export interface IJobManager {
+  startAsync(name: JobGroupKeys): Promise<void>;
+  triggerAsync(name: JobGroupKeys): Promise<void>;
+  stopAsync(name: JobGroupKeys): Promise<void>;
+  updateIntervalAsync(name: JobGroupKeys, cron: string): Promise<void>;
+  disableAsync(name: JobGroupKeys): Promise<void>;
+  enableAsync(name: JobGroupKeys): Promise<void>;
+  getAllAsync(): Promise<{ name: JobGroupKeys; cron: string; preventManualExecution: boolean; isEnabled: boolean }[]>;
+}
+
+const t = initTRPC
+  .context<{
+    manager: IJobManager;
+    apiKey?: string;
+  }>()
+  .create();
+
+const createTrpcRouter = t.router;
+const apiKeyProcedure = t.procedure.use(({ ctx, next }) => {
+  if (ctx.apiKey !== env.CRON_JOB_API_KEY) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Missing or invalid API key",
+    });
+  }
+
+  return next({
+    ctx: {
+      ...ctx,
+      apiKey: undefined, // Clear the API key after checking
+    },
+  });
+});
+
+export const cronExpressionSchema = z.string().refine((expression) => validate(expression), {
+  error: "Invalid cron expression",
+});
+
+export const jobRouter = createTrpcRouter({
+  start: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
+    await ctx.manager.startAsync(input);
+  }),
+  trigger: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
+    await ctx.manager.triggerAsync(input);
+  }),
+  stop: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
+    await ctx.manager.stopAsync(input);
+  }),
+  updateInterval: apiKeyProcedure
+    .input(
+      z.object({
+        name: jobNameSchema,
+        cron: cronExpressionSchema,
+      }),
+    )
+    .mutation(async ({ input, ctx }) => {
+      await ctx.manager.updateIntervalAsync(input.name, input.cron);
+    }),
+  disable: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
+    await ctx.manager.disableAsync(input);
+  }),
+  enable: apiKeyProcedure.input(jobNameSchema).mutation(async ({ input, ctx }) => {
+    await ctx.manager.enableAsync(input);
+  }),
+  getAll: apiKeyProcedure.query(({ ctx }) => {
+    return ctx.manager.getAllAsync();
+  }),
+});
+
+export type JobRouter = typeof jobRouter;
--- a/packages/cron-job-runner/tsconfig.json
+++ b/packages/cron-job-runner/tsconfig.json
--- a/packages/cron-job-runner/index.ts
+++ b/packages/cron-job-runner/index.ts
@@ -1 +0,0 @@
-export * from "./src";
--- a/packages/cron-job-runner/src/index.ts
+++ b/packages/cron-job-runner/src/index.ts
@@ -1,45 +0,0 @@
-import { objectKeys } from "@homarr/common";
-import type { JobGroupKeys } from "@homarr/cron-jobs";
-import { createSubPubChannel } from "@homarr/redis";
-import { zodEnumFromArray } from "@homarr/validation/enums";
-
-export const cronJobRunnerChannel = createSubPubChannel<JobGroupKeys>("cron-job-runner", { persist: false });
-
-export const cronJobs = {
-  analytics: { preventManualExecution: true },
-  iconsUpdater: { preventManualExecution: false },
-  ping: { preventManualExecution: false },
-  smartHomeEntityState: { preventManualExecution: false },
-  mediaServer: { preventManualExecution: false },
-  mediaOrganizer: { preventManualExecution: false },
-  downloads: { preventManualExecution: false },
-  dnsHole: { preventManualExecution: false },
-  mediaRequestStats: { preventManualExecution: false },
-  mediaRequestList: { preventManualExecution: false },
-  rssFeeds: { preventManualExecution: false },
-  indexerManager: { preventManualExecution: false },
-  healthMonitoring: { preventManualExecution: false },
-  sessionCleanup: { preventManualExecution: false },
-  updateChecker: { preventManualExecution: false },
-  mediaTranscoding: { preventManualExecution: false },
-  minecraftServerStatus: { preventManualExecution: false },
-  networkController: { preventManualExecution: false },
-  dockerContainers: { preventManualExecution: false },
-  refreshNotifications: { preventManualExecution: false },
-} satisfies Record<JobGroupKeys, { preventManualExecution?: boolean }>;
-
-/**
- * Triggers a cron job to run immediately.
- * This works over the Redis PubSub channel.
- * @param jobName name of the job to be triggered
- */
-export const triggerCronJobAsync = async (jobName: JobGroupKeys) => {
-  if (cronJobs[jobName].preventManualExecution) {
-    throw new Error(`The job "${jobName}" can not be executed manually`);
-  }
-  await cronJobRunnerChannel.publishAsync(jobName);
-};
-
-export const cronJobNames = objectKeys(cronJobs);
-
-export const jobNameSchema = zodEnumFromArray(cronJobNames);
--- a/packages/cron-job-runner/src/register.ts
+++ b/packages/cron-job-runner/src/register.ts
@@ -1,12 +0,0 @@
-import { jobGroup } from "@homarr/cron-jobs";
-
-import { cronJobRunnerChannel } from ".";
-
-/**
- * Registers the cron job runner to listen to the Redis PubSub channel.
- */
-export const registerCronJobRunner = () => {
-  cronJobRunnerChannel.subscribe((jobName) => {
-    void jobGroup.runManuallyAsync(jobName);
-  });
-};
--- a/packages/cron-jobs-core/package.json
+++ b/packages/cron-jobs-core/package.json
@@ -25,6 +25,7 @@
  "prettier": "@homarr/prettier-config",
  "dependencies": {
    "@homarr/common": "workspace:^0.1.0",
+    "@homarr/db": "workspace:^0.1.0",
    "node-cron": "^4.2.0"
  },
  "devDependencies": {
--- a/packages/cron-jobs-core/src/creator.ts
+++ b/packages/cron-jobs-core/src/creator.ts
@@ -1,9 +1,9 @@
 import { AxiosError } from "axios";
-import type { ScheduledTask } from "node-cron";
-import { schedule, validate } from "node-cron";
+import { createTask, validate } from "node-cron";

 import { Stopwatch } from "@homarr/common";
 import type { MaybePromise } from "@homarr/common/types";
+import { db } from "@homarr/db";

 import type { Logger } from "./logger";
 import type { ValidateCron } from "./validation";
@@ -18,13 +18,14 @@ export interface CreateCronJobCreatorOptions<TAllowedNames extends string> {

 interface CreateCronJobOptions {
  runOnStart?: boolean;
+  preventManualExecution?: boolean;
  expectedMaximumDurationInMillis?: number;
  beforeStart?: () => MaybePromise<void>;
 }

 const createCallback = <TAllowedNames extends string, TName extends TAllowedNames>(
  name: TName,
-  cronExpression: string,
+  defaultCronExpression: string,
  options: CreateCronJobOptions,
  creatorOptions: CreateCronJobCreatorOptions<TAllowedNames>,
 ) => {
@@ -63,25 +64,30 @@ const createCallback = <TAllowedNames extends string, TName extends TAllowedName
      }
    };

-    /**
-     * We are not using the runOnInit method as we want to run the job only once we start the cron job schedule manually.
-     * This allows us to always run it once we start it. Additionally, it will not run the callback if only the cron job file is imported.
-     */
-    let scheduledTask: ScheduledTask | null = null;
-    if (cronExpression !== "never") {
-      scheduledTask = schedule(cronExpression, () => void catchingCallbackAsync(), {
-        name,
-        timezone: creatorOptions.timezone,
-      });
-      creatorOptions.logger.logDebug(
-        `The cron job '${name}' was created with expression ${cronExpression} in timezone ${creatorOptions.timezone} and runOnStart ${options.runOnStart}`,
-      );
-    }
-
    return {
      name,
-      cronExpression,
-      scheduledTask,
+      cronExpression: defaultCronExpression,
+      async createTaskAsync() {
+        const configuration = await db.query.cronJobConfigurations.findFirst({
+          where: (cronJobConfigurations, { eq }) => eq(cronJobConfigurations.name, name),
+        });
+
+        if (defaultCronExpression === "never") return null;
+
+        const scheduledTask = createTask(
+          configuration?.cronExpression ?? defaultCronExpression,
+          () => void catchingCallbackAsync(),
+          {
+            name,
+            timezone: creatorOptions.timezone,
+          },
+        );
+        creatorOptions.logger.logDebug(
+          `The cron job '${name}' was created with expression ${defaultCronExpression} in timezone ${creatorOptions.timezone} and runOnStart ${options.runOnStart}`,
+        );
+
+        return scheduledTask;
+      },
      async onStartAsync() {
        if (options.beforeStart) {
          creatorOptions.logger.logDebug(`Running beforeStart for job: ${name}`);
@@ -93,6 +99,10 @@ const createCallback = <TAllowedNames extends string, TName extends TAllowedName
        creatorOptions.logger.logDebug(`The cron job '${name}' is running because runOnStart is set to true`);
        await catchingCallbackAsync();
      },
+      async executeAsync() {
+        await catchingCallbackAsync();
+      },
+      preventManualExecution: options.preventManualExecution ?? false,
    };
  };
 };
@@ -106,17 +116,17 @@ export const createCronJobCreator = <TAllowedNames extends string = string>(
 ) => {
  return <TName extends TAllowedNames, TExpression extends string>(
    name: TName,
-    cronExpression: TExpression,
+    defaultCronExpression: TExpression,
    options: CreateCronJobOptions = { runOnStart: false },
  ) => {
-    creatorOptions.logger.logDebug(`Validating cron expression '${cronExpression}' for job: ${name}`);
-    if (cronExpression !== "never" && !validate(cronExpression)) {
-      throw new Error(`Invalid cron expression '${cronExpression}' for job '${name}'`);
+    creatorOptions.logger.logDebug(`Validating cron expression '${defaultCronExpression}' for job: ${name}`);
+    if (defaultCronExpression !== "never" && !validate(defaultCronExpression)) {
+      throw new Error(`Invalid cron expression '${defaultCronExpression}' for job '${name}'`);
    }
-    creatorOptions.logger.logDebug(`Cron job expression '${cronExpression}' for job ${name} is valid`);
+    creatorOptions.logger.logDebug(`Cron job expression '${defaultCronExpression}' for job ${name} is valid`);

    const returnValue = {
-      withCallback: createCallback<TAllowedNames, TName>(name, cronExpression, options, creatorOptions),
+      withCallback: createCallback<TAllowedNames, TName>(name, defaultCronExpression, options, creatorOptions),
    };

    // This is a type guard to check if the cron expression is valid and give the user a type hint
--- a/packages/cron-jobs-core/src/group.ts
+++ b/packages/cron-jobs-core/src/group.ts
@@ -1,4 +1,7 @@
+import type { ScheduledTask } from "node-cron";
+
 import { objectEntries, objectKeys } from "@homarr/common";
+import { db } from "@homarr/db";

 import type { JobCallback } from "./creator";
 import type { Logger } from "./logger";
@@ -27,45 +30,78 @@ export const createJobGroupCreator = <TAllowedNames extends string = string>(
      });
    }

+    const tasks = new Map<string, ScheduledTask>();
+
    return {
+      initializeAsync: async () => {
+        const configurations = await db.query.cronJobConfigurations.findMany();
+        for (const job of jobRegistry.values()) {
+          const configuration = configurations.find(({ name }) => name === job.name);
+          if (configuration?.isEnabled === false) {
+            continue;
+          }
+          if (tasks.has(job.name)) {
+            continue;
+          }
+
+          const scheduledTask = await job.createTaskAsync();
+          if (!scheduledTask) continue;
+
+          tasks.set(job.name, scheduledTask);
+        }
+      },
      startAsync: async (name: keyof TJobs) => {
        const job = jobRegistry.get(name as string);
        if (!job) return;
+        if (!tasks.has(job.name)) return;

        options.logger.logInfo(`Starting schedule cron job ${job.name}.`);
        await job.onStartAsync();
-        await job.scheduledTask?.start();
+        await tasks.get(name as string)?.start();
      },
      startAllAsync: async () => {
        for (const job of jobRegistry.values()) {
+          if (!tasks.has(job.name)) {
+            continue;
+          }
+
          options.logger.logInfo(`Starting schedule of cron job ${job.name}.`);
          await job.onStartAsync();
-          await job.scheduledTask?.start();
+          await tasks.get(job.name)?.start();
        }
      },
      runManuallyAsync: async (name: keyof TJobs) => {
        const job = jobRegistry.get(name as string);
        if (!job) return;
+        if (job.preventManualExecution) {
+          throw new Error(`The job "${job.name}" can not be executed manually.`);
+        }

        options.logger.logInfo(`Running schedule cron job ${job.name} manually.`);
-        await job.scheduledTask?.execute();
+        await tasks.get(name as string)?.execute();
      },
      stopAsync: async (name: keyof TJobs) => {
        const job = jobRegistry.get(name as string);
        if (!job) return;

        options.logger.logInfo(`Stopping schedule cron job ${job.name}.`);
-        await job.scheduledTask?.stop();
+        await tasks.get(name as string)?.stop();
      },
      stopAllAsync: async () => {
        for (const job of jobRegistry.values()) {
          options.logger.logInfo(`Stopping schedule cron job ${job.name}.`);
-          await job.scheduledTask?.stop();
+          await tasks.get(job.name)?.stop();
        }
      },
      getJobRegistry() {
        return jobRegistry as Map<TAllowedNames, ReturnType<JobCallback<TAllowedNames, TAllowedNames>>>;
      },
+      getTask(name: keyof TJobs) {
+        return tasks.get(name as string) ?? null;
+      },
+      setTask(name: keyof TJobs, task: ScheduledTask) {
+        tasks.set(name as string, task);
+      },
      getKeys() {
        return objectKeys(jobs);
      },
--- a/packages/cron-jobs/src/jobs/analytics.ts
+++ b/packages/cron-jobs/src/jobs/analytics.ts
@@ -7,6 +7,7 @@ import { createCronJob } from "../lib";

 export const analyticsJob = createCronJob("analytics", EVERY_WEEK, {
  runOnStart: true,
+  preventManualExecution: true,
 }).withCallback(async () => {
  const analyticSetting = await getServerSettingByKeyAsync(db, "analytics");

--- a/packages/cron-jobs/src/jobs/icons-updater.ts
+++ b/packages/cron-jobs/src/jobs/icons-updater.ts
@@ -38,6 +38,7 @@ export const iconsUpdaterJob = createCronJob("iconsUpdater", EVERY_WEEK, {

  const newIconRepositories: InferInsertModel<typeof iconRepositories>[] = [];
  const newIcons: InferInsertModel<typeof icons>[] = [];
+  const allDbIcons = databaseIconRepositories.flatMap((group) => group.icons);

  for (const repositoryIconGroup of repositoryIconGroups) {
    if (!repositoryIconGroup.success) {
@@ -55,12 +56,10 @@ export const iconsUpdaterJob = createCronJob("iconsUpdater", EVERY_WEEK, {
      });
    }

+    const dbIconsInRepository = allDbIcons.filter((icon) => icon.iconRepositoryId === iconRepositoryId);
+
    for (const icon of repositoryIconGroup.icons) {
-      if (
-        databaseIconRepositories
-          .flatMap((repository) => repository.icons)
-          .some((dbIcon) => dbIcon.checksum === icon.checksum && dbIcon.iconRepositoryId === iconRepositoryId)
-      ) {
+      if (dbIconsInRepository.some((dbIcon) => dbIcon.checksum === icon.checksum)) {
        skippedChecksums.push(`${iconRepositoryId}.${icon.checksum}`);
        continue;
      }
@@ -76,9 +75,9 @@ export const iconsUpdaterJob = createCronJob("iconsUpdater", EVERY_WEEK, {
    }
  }

-  const deadIcons = databaseIconRepositories
-    .flatMap((repository) => repository.icons)
-    .filter((icon) => !skippedChecksums.includes(`${icon.iconRepositoryId}.${icon.checksum}`));
+  const deadIcons = allDbIcons.filter(
+    (icon) => !skippedChecksums.includes(`${icon.iconRepositoryId}.${icon.checksum}`),
+  );

  const deadIconRepositories = databaseIconRepositories.filter(
    (iconRepository) => !repositoryIconGroups.some((group) => group.slug === iconRepository.slug),
--- a/packages/db/migrations/mysql/0033_add_cron_job_configuration.sql
+++ b/packages/db/migrations/mysql/0033_add_cron_job_configuration.sql
@@ -0,0 +1,6 @@
+CREATE TABLE `cron_job_configuration` (
+	`name` varchar(256) NOT NULL,
+	`cron_expression` varchar(32) NOT NULL,
+	`is_enabled` boolean NOT NULL DEFAULT true,
+	CONSTRAINT `cron_job_configuration_name` PRIMARY KEY(`name`)
+);
--- a/packages/db/migrations/mysql/meta/0033_snapshot.json
+++ b/packages/db/migrations/mysql/meta/0033_snapshot.json
--- a/packages/db/migrations/mysql/meta/_journal.json
+++ b/packages/db/migrations/mysql/meta/_journal.json
@@ -232,6 +232,13 @@
      "when": 1746821770071,
      "tag": "0032_add_trusted_certificate_hostnames",
      "breakpoints": true
+    },
+    {
+      "idx": 33,
+      "version": "5",
+      "when": 1750013953833,
+      "tag": "0033_add_cron_job_configuration",
+      "breakpoints": true
    }
  ]
 }
--- a/packages/db/migrations/sqlite/0033_add_cron_job_configuration.sql
+++ b/packages/db/migrations/sqlite/0033_add_cron_job_configuration.sql
@@ -0,0 +1,5 @@
+CREATE TABLE `cron_job_configuration` (
+	`name` text PRIMARY KEY NOT NULL,
+	`cron_expression` text NOT NULL,
+	`is_enabled` integer DEFAULT true NOT NULL
+);
--- a/packages/db/migrations/sqlite/meta/0033_snapshot.json
+++ b/packages/db/migrations/sqlite/meta/0033_snapshot.json
--- a/packages/db/migrations/sqlite/meta/_journal.json
+++ b/packages/db/migrations/sqlite/meta/_journal.json
@@ -232,6 +232,13 @@
      "when": 1746821779051,
      "tag": "0032_add_trusted_certificate_hostnames",
      "breakpoints": true
+    },
+    {
+      "idx": 33,
+      "version": "6",
+      "when": 1750014001941,
+      "tag": "0033_add_cron_job_configuration",
+      "breakpoints": true
    }
  ]
 }
--- a/packages/db/schema/index.ts
+++ b/packages/db/schema/index.ts
@@ -40,6 +40,7 @@ export const {
  itemLayouts,
  sectionLayouts,
  trustedCertificateHostnames,
+  cronJobConfigurations,
 } = schema;

 export type User = InferSelectModel<typeof schema.users>;
--- a/packages/db/schema/mysql.ts
+++ b/packages/db/schema/mysql.ts
@@ -508,6 +508,12 @@ export const trustedCertificateHostnames = mysqlTable(
  }),
 );

+export const cronJobConfigurations = mysqlTable("cron_job_configuration", {
+  name: varchar({ length: 256 }).notNull().primaryKey(),
+  cronExpression: varchar({ length: 32 }).notNull(),
+  isEnabled: boolean().default(true).notNull(),
+});
+
 export const accountRelations = relations(accounts, ({ one }) => ({
  user: one(users, {
    fields: [accounts.userId],
--- a/packages/db/schema/sqlite.ts
+++ b/packages/db/schema/sqlite.ts
@@ -493,6 +493,12 @@ export const trustedCertificateHostnames = sqliteTable(
  }),
 );

+export const cronJobConfigurations = sqliteTable("cron_job_configuration", {
+  name: text().notNull().primaryKey(),
+  cronExpression: text().notNull(),
+  isEnabled: int({ mode: "boolean" }).default(true).notNull(),
+});
+
 export const accountRelations = relations(accounts, ({ one }) => ({
  user: one(users, {
    fields: [accounts.userId],
--- a/packages/translation/src/lang/en.json
+++ b/packages/translation/src/lang/en.json
@@ -3077,7 +3077,8 @@
          "status": {
            "idle": "Idle",
            "running": "Running",
-            "error": "Error"
+            "error": "Error",
+            "disabled": "Disabled"
          },
          "job": {
            "minecraftServerStatus": {
@@ -3140,6 +3141,21 @@
            "dockerContainers": {
              "label": "Docker containers"
            }
+          },
+          "interval": {
+            "seconds": "Every {interval, plural, =1 {second} other {# seconds}}",
+            "minutes": "Every {interval, plural, =1 {minute} other {# minutes}}",
+            "hours": "Every {interval, plural, =1 {hour} other {# hours}}",
+            "midnight": "Every day at midnight",
+            "weeklyMonday": "Every week on monday"
+          },
+          "settings": {
+            "title": "Task settings for {jobName}"
+          },
+          "field": {
+            "interval": {
+              "label": "Schedule interval"
+            }
          }
        },
        "api": {
--- a/packages/ui/package.json
+++ b/packages/ui/package.json
@@ -7,7 +7,8 @@
  "exports": {
    ".": "./index.ts",
    "./styles.css": "./src/styles.css",
-    "./hooks": "./src/hooks/index.ts"
+    "./hooks": "./src/hooks/index.ts",
+    "./icons": "./src/icons/index.ts"
  },
  "typesVersions": {
    "*": {
@@ -36,7 +37,8 @@
    "mantine-react-table": "2.0.0-beta.9",
    "next": "15.3.4",
    "react": "19.1.0",
-    "react-dom": "19.1.0"
+    "react-dom": "19.1.0",
+    "svgson": "^5.3.1"
  },
  "devDependencies": {
    "@homarr/eslint-config": "workspace:^0.2.0",
--- a/packages/ui/src/icons/create.ts
+++ b/packages/ui/src/icons/create.ts
@@ -0,0 +1,27 @@
+import type { IconNode } from "@tabler/icons-react";
+import { createReactComponent } from "@tabler/icons-react";
+import { parseSync } from "svgson";
+
+import { capitalize } from "@homarr/common";
+
+interface CustomIconOptions {
+  name: string;
+  svgContent: string;
+  type: "outline" | "filled";
+}
+
+export const createCustomIcon = ({ svgContent, type, name }: CustomIconOptions) => {
+  const icon = parseSync(svgContent);
+
+  const children = icon.children.map(({ name, attributes }, i) => {
+    attributes.key = `svg-${i}`;
+
+    attributes.strokeWidth = attributes["stroke-width"] ?? "2";
+    delete attributes["stroke-width"];
+
+    return [name, attributes] satisfies IconNode[number];
+  });
+
+  const pascalCaseName = `Icon${capitalize(name.replace("-", ""))}`;
+  return createReactComponent(type, name, pascalCaseName, children);
+};
--- a/packages/ui/src/icons/index.ts
+++ b/packages/ui/src/icons/index.ts
@@ -0,0 +1,12 @@
+import { createCustomIcon } from "./create";
+
+export const IconPowerOff = createCustomIcon({
+  svgContent: `<svg  xmlns="http://www.w3.org/2000/svg"  width="24"  height="24"  viewBox="0 0 24 24"  fill="none"  stroke="currentColor"  stroke-width="2"  stroke-linecap="round"  stroke-linejoin="round"  class="icon icon-tabler icons-tabler-outline icon-tabler-power-off">
+        <path xmlns="http://www.w3.org/2000/svg" d="M3 3l18 18"/>
+	<path stroke="none" d="M0 0h24v24H0z" fill="none"/>
+	<path d="M7 6a7.75 7.75 0 1 0 10 0" />
+	<path d="M12 4l0 4" />
+</svg>`,
+  type: "outline",
+  name: "power-off",
+});