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

apps/nextjs/src/app/[locale]/manage/tools/tasks/_components/jobs-list.tsx

@@ -1,89 +1,216 @@
 "use client";
 
-import React from "react";
-import { ActionIcon, Badge, Card, Group, Stack, Text } from "@mantine/core";
-import { useListState } from "@mantine/hooks";
-import { IconPlayerPlay } from "@tabler/icons-react";
+import React, { useState, useTransition } from "react";
+import { ActionIcon, Badge, Button, Card, Group, Select, Stack, Text } from "@mantine/core";
+import { useMap } from "@mantine/hooks";
+import { IconPlayerPlay, IconPower, IconSettings } from "@tabler/icons-react";
 
 import type { RouterOutputs } from "@homarr/api";
 import { clientApi } from "@homarr/api/client";
-import { useTimeAgo } from "@homarr/common";
+import { getMantineColor, useTimeAgo } from "@homarr/common";
 import type { TaskStatus } from "@homarr/cron-job-status";
-import type { TranslationKeys } from "@homarr/translation";
-import { useScopedI18n } from "@homarr/translation/client";
+import { useForm } from "@homarr/form";
+import { createModal, useModalAction } from "@homarr/modals";
+import { TranslationFunction } from "@homarr/translation";
+import { useI18n, useScopedI18n } from "@homarr/translation/client";
+import { IconPowerOff } from "@homarr/ui/icons";
 
 interface JobsListProps {
   initialJobs: RouterOutputs["cronJobs"]["getJobs"];
 }
 
-interface JobState {
-  job: JobsListProps["initialJobs"][number];
+type JobName = RouterOutputs["cronJobs"]["getJobs"][number]["name"];
+
+export const JobsList = ({ initialJobs }: JobsListProps) => {
+  const [jobs] = clientApi.cronJobs.getJobs.useSuspenseQuery(undefined, {
+    initialData: initialJobs,
+    refetchOnMount: false,
+  });
+
+  const jobStatusMap = useMap<string, TaskStatus | null>(initialJobs.map(({ name }) => [name, null] as const));
+
+  clientApi.cronJobs.subscribeToStatusUpdates.useSubscription(undefined, {
+    onData: (data) => {
+      jobStatusMap.set(data.name, data);
+    },
+  });
+
+  return (
+    <Stack>
+      {jobs.map((job) => {
+        const status = jobStatusMap.get(job.name);
+
+        return <JobCard key={job.name} job={job} status={status ?? null} />;
+      })}
+    </Stack>
+  );
+};
+
+const cronExpressions = [
+  {
+    value: "*/5 * * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.seconds", { interval: 5 }),
+  },
+  {
+    value: "*/10 * * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.seconds", { interval: 10 }),
+  },
+  {
+    value: "*/20 * * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.seconds", { interval: 20 }),
+  },
+  {
+    value: "* * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.minutes", { interval: 1 }),
+  },
+  {
+    value: "*/5 * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.minutes", { interval: 5 }),
+  },
+  {
+    value: "*/10 * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.minutes", { interval: 10 }),
+  },
+  {
+    value: "*/15 * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.minutes", { interval: 15 }),
+  },
+  {
+    value: "0 * * * *",
+    label: (t) => t("management.page.tool.tasks.interval.hours", { interval: 1 }),
+  },
+  {
+    value: "0 0 * * */1",
+    label: (t) => t("management.page.tool.tasks.interval.midnight"),
+  },
+  {
+    value: "0 0 * * 1",
+    label: (t) => t("management.page.tool.tasks.interval.weeklyMonday"),
+  },
+] satisfies { value: string; label: (t: TranslationFunction) => string }[];
+
+interface JobCardProps {
+  job: RouterOutputs["cronJobs"]["getJobs"][number];
   status: TaskStatus | null;
 }
 
-export const JobsList = ({ initialJobs }: JobsListProps) => {
-  const t = useScopedI18n("management.page.tool.tasks");
-  const [jobs, handlers] = useListState<JobState>(
-    initialJobs.map((job) => ({
-      job,
-      status: null,
-    })),
-  );
-  clientApi.cronJobs.subscribeToStatusUpdates.useSubscription(undefined, {
-    onData: (data) => {
-      const jobByName = jobs.find((job) => job.job.name === data.name);
-      if (!jobByName) {
-        return;
-      }
-      handlers.applyWhere(
-        (job) => job.job.name === data.name,
-        (job) => ({ ...job, status: data }),
-      );
-    },
-  });
-  const { mutateAsync } = clientApi.cronJobs.triggerJob.useMutation();
+const JobCard = ({ job, status }: JobCardProps) => {
+  const t = useI18n();
+  const tTasks = useScopedI18n("management.page.tool.tasks");
+  const triggerMutation = clientApi.cronJobs.triggerJob.useMutation();
   const handleJobTrigger = React.useCallback(
-    async (job: JobState) => {
-      if (job.status?.status === "running") {
-        return;
-      }
-      await mutateAsync(job.job.name);
+    async (name: JobName) => {
+      if (status?.status === "running") return;
+      await triggerMutation.mutateAsync(name);
     },
-    [mutateAsync],
+    [triggerMutation, status],
   );
-  return (
-    <Stack>
-      {jobs.map((job) => (
-        <Card key={job.job.name} withBorder>
-          <Group justify={"space-between"} gap={"md"}>
-            <Stack gap={0}>
-              <Group>
-                <Text>{t(`job.${job.job.name}.label` as TranslationKeys)}</Text>
-                {job.status?.status === "idle" && <Badge variant="default">{t("status.idle")}</Badge>}
-                {job.status?.status === "running" && <Badge color="green">{t("status.running")}</Badge>}
-                {job.status?.lastExecutionStatus === "error" && <Badge color="red">{t("status.error")}</Badge>}
-              </Group>
-              {job.status && <TimeAgo timestamp={job.status.lastExecutionTimestamp} />}
-            </Stack>
 
-            {!job.job.preventManualExecution && (
-              <ActionIcon
-                onClick={() => handleJobTrigger(job)}
-                disabled={job.status?.status === "running"}
-                variant={"default"}
-                size={"xl"}
-                radius={"xl"}
-              >
-                <IconPlayerPlay stroke={1.5} />
-              </ActionIcon>
+  const { openModal } = useModalAction(TaskConfigurationModal);
+  const [isEnabled, setEnabled] = useState(job.isEnabled);
+  const disableMutation = clientApi.cronJobs.disableJob.useMutation();
+  const enableMutation = clientApi.cronJobs.enableJob.useMutation();
+
+  const [activeStatePending, startActiveTransition] = useTransition();
+  const handleActiveChange = () =>
+    startActiveTransition(async () => {
+      if (isEnabled) {
+        await disableMutation.mutateAsync(job.name, {
+          onSuccess() {
+            setEnabled(false);
+          },
+        });
+      } else {
+        await enableMutation.mutateAsync(job.name, {
+          onSuccess() {
+            setEnabled(true);
+          },
+        });
+      }
+    });
+
+  return (
+    <Card key={job.name} withBorder>
+      <Group justify={"space-between"} gap={"md"}>
+        <Stack gap={0}>
+          <Group>
+            <Text>{tTasks(`job.${job.name}.label`)}</Text>
+            <StatusBadge isEnabled={isEnabled} status={status} />
+            {status?.lastExecutionStatus === "error" && <Badge color="red">{tTasks("status.error")}</Badge>}
+          </Group>
+          <Group gap="xs">
+            {status && (
+              <>
+                <TimeAgo timestamp={status.lastExecutionTimestamp} />
+                <Text size="sm" c="dimmed">
+                  •
+                </Text>
+                <Text size="sm" c="dimmed">
+                  {cronExpressions.find((expression) => expression.value === job.cron)?.label(t) ?? job.cron}
+                </Text>
+              </>
             )}
           </Group>
-        </Card>
-      ))}
-    </Stack>
+        </Stack>
+
+        <Group>
+          {!job.preventManualExecution && (
+            <ActionIcon
+              onClick={() => handleJobTrigger(job.name)}
+              disabled={status?.status === "running"}
+              loading={triggerMutation.isPending}
+              variant="default"
+              size="xl"
+              radius="xl"
+            >
+              <IconPlayerPlay color={getMantineColor("green", 6)} stroke={1.5} />
+            </ActionIcon>
+          )}
+          <ActionIcon onClick={handleActiveChange} loading={activeStatePending} variant="default" size="xl" radius="xl">
+            {isEnabled ? (
+              <IconPower color={getMantineColor("green", 6)} stroke={1.5} />
+            ) : (
+              <IconPowerOff color={getMantineColor("gray", 6)} stroke={1.5} />
+            )}
+          </ActionIcon>
+          <ActionIcon
+            onClick={() =>
+              openModal(
+                { job },
+                {
+                  title: tTasks("settings.title", {
+                    jobName: tTasks(`job.${job.name}.label`),
+                  }),
+                },
+              )
+            }
+            variant={"default"}
+            size={"xl"}
+            radius={"xl"}
+          >
+            <IconSettings stroke={1.5} />
+          </ActionIcon>
+        </Group>
+      </Group>
+    </Card>
   );
 };
 
+interface StatusBadgeProps {
+  isEnabled: boolean;
+  status: TaskStatus | null;
+}
+
+const StatusBadge = ({ isEnabled, status }: StatusBadgeProps) => {
+  const t = useScopedI18n("management.page.tool.tasks");
+  if (!isEnabled) return <Badge color="yellow">{t("status.disabled")}</Badge>;
+
+  if (!status) return null;
+
+  if (status.status === "running") return <Badge color="green">{t("status.running")}</Badge>;
+  return <Badge variant="default">{t("status.idle")}</Badge>;
+};
+
 const TimeAgo = ({ timestamp }: { timestamp: string }) => {
   const timeAgo = useTimeAgo(new Date(timestamp));
 
@@ -93,3 +220,65 @@ const TimeAgo = ({ timestamp }: { timestamp: string }) => {
     </Text>
   );
 };
+
+const TaskConfigurationModal = createModal<{
+  job: RouterOutputs["cronJobs"]["getJobs"][number];
+}>(({ actions, innerProps }) => {
+  const t = useI18n();
+  const form = useForm({
+    initialValues: {
+      cron: innerProps.job.cron,
+    },
+  });
+  const { mutateAsync, isPending } = clientApi.cronJobs.updateJobInterval.useMutation();
+  const utils = clientApi.useUtils();
+
+  return (
+    <form
+      onSubmit={form.onSubmit(async (values) => {
+        utils.cronJobs.getJobs.setData(undefined, (data) =>
+          data?.map((job) =>
+            job.name === innerProps.job.name
+              ? {
+                  ...job,
+                  cron: values.cron,
+                }
+              : job,
+          ),
+        );
+        await mutateAsync(
+          {
+            name: innerProps.job.name,
+            cron: values.cron,
+          },
+          {
+            onSuccess() {
+              actions.closeModal();
+            },
+            async onSettled() {
+              await utils.cronJobs.getJobs.invalidate();
+            },
+          },
+        );
+      })}
+    >
+      <Stack gap="sm">
+        <Select
+          label={t("management.page.tool.tasks.field.interval.label")}
+          {...form.getInputProps("cron")}
+          data={cronExpressions.map(({ value, label }) => ({ value, label: label(t) }))}
+        />
+        <Group justify="end">
+          <Button variant="subtle" color="gray" disabled={isPending} onClick={actions.closeModal}>
+            {t("common.action.cancel")}
+          </Button>
+          <Button type="submit" loading={isPending}>
+            {t("common.action.save")}
+          </Button>
+        </Group>
+      </Stack>
+    </form>
+  );
+}).withOptions({
+  defaultTitle: "",
+});

apps/tasks/package.json

@@ -22,7 +22,7 @@
   "dependencies": {
     "@homarr/analytics": "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-jobs": "workspace:^0.1.0",
     "@homarr/cron-jobs-core": "workspace:^0.1.0",
     "@homarr/db": "workspace:^0.1.0",
@@ -37,6 +37,7 @@
     "@homarr/widgets": "workspace:^0.1.0",
     "dayjs": "^1.11.13",
     "dotenv": "^17.0.1",
+    "fastify": "^5.4.0",
     "superjson": "2.2.2",
     "undici": "7.11.0"
   },

apps/tasks/src/job-manager.ts

@@ -0,0 +1,109 @@
+import { schedule, validate as validateCron } from "node-cron";
+
+import type { IJobManager } from "@homarr/cron-job-api";
+import type { jobGroup as cronJobGroup, JobGroupKeys } from "@homarr/cron-jobs";
+import type { Database, InferInsertModel } from "@homarr/db";
+import { eq } from "@homarr/db";
+import { cronJobConfigurations } from "@homarr/db/schema";
+import { logger } from "@homarr/log";
+
+export class JobManager implements IJobManager {
+  constructor(
+    private db: Database,
+    private jobGroup: typeof cronJobGroup,
+  ) {}
+
+  public async startAsync(name: JobGroupKeys): Promise<void> {
+    await this.jobGroup.startAsync(name);
+  }
+  public async triggerAsync(name: JobGroupKeys): Promise<void> {
+    await this.jobGroup.runManuallyAsync(name);
+  }
+  public async stopAsync(name: JobGroupKeys): Promise<void> {
+    await this.jobGroup.stopAsync(name);
+  }
+  public async updateIntervalAsync(name: JobGroupKeys, cron: string): Promise<void> {
+    logger.info(`Updating cron job interval name="${name}" expression="${cron}"`);
+    const job = this.jobGroup.getJobRegistry().get(name);
+    if (!job) throw new Error(`Job ${name} not found`);
+    if (job.cronExpression === "never") throw new Error(`Job ${name} cannot be updated as it is set to "never"`);
+    if (!validateCron(cron)) {
+      throw new Error(`Invalid cron expression: ${cron}`);
+    }
+    await this.updateConfigurationAsync(name, { cronExpression: cron });
+    await this.jobGroup.getTask(name)?.destroy();
+
+    this.jobGroup.setTask(
+      name,
+      schedule(cron, () => void job.executeAsync(), {
+        name,
+      }),
+    );
+    logger.info(`Cron job interval updated name="${name}" expression="${cron}"`);
+  }
+  public async disableAsync(name: JobGroupKeys): Promise<void> {
+    logger.info(`Disabling cron job name="${name}"`);
+    const job = this.jobGroup.getJobRegistry().get(name);
+    if (!job) throw new Error(`Job ${name} not found`);
+    if (job.cronExpression === "never") throw new Error(`Job ${name} cannot be disabled as it is set to "never"`);
+
+    await this.updateConfigurationAsync(name, { isEnabled: false });
+    await this.jobGroup.stopAsync(name);
+    logger.info(`Cron job disabled name="${name}"`);
+  }
+  public async enableAsync(name: JobGroupKeys): Promise<void> {
+    logger.info(`Enabling cron job name="${name}"`);
+    await this.updateConfigurationAsync(name, { isEnabled: true });
+    await this.jobGroup.startAsync(name);
+    logger.info(`Cron job enabled name="${name}"`);
+  }
+
+  private async updateConfigurationAsync(
+    name: JobGroupKeys,
+    configuration: Omit<Partial<InferInsertModel<typeof cronJobConfigurations>>, "name">,
+  ) {
+    const existingConfig = await this.db.query.cronJobConfigurations.findFirst({
+      where: (table, { eq }) => eq(table.name, name),
+    });
+
+    logger.debug(
+      `Updating cron job configuration name="${name}" configuration="${JSON.stringify(configuration)}" exists="${Boolean(existingConfig)}"`,
+    );
+
+    if (existingConfig) {
+      await this.db
+        .update(cronJobConfigurations)
+        // prevent updating the name, as it is the primary key
+        .set({ ...configuration, name: undefined })
+        .where(eq(cronJobConfigurations.name, name));
+      logger.debug(`Cron job configuration updated name="${name}" configuration="${JSON.stringify(configuration)}"`);
+      return;
+    }
+
+    const job = this.jobGroup.getJobRegistry().get(name);
+    if (!job) throw new Error(`Job ${name} not found`);
+
+    await this.db.insert(cronJobConfigurations).values({
+      name,
+      cronExpression: configuration.cronExpression ?? job.cronExpression,
+      isEnabled: configuration.isEnabled ?? true,
+    });
+    logger.debug(`Cron job configuration updated name="${name}" configuration="${JSON.stringify(configuration)}"`);
+  }
+
+  public async getAllAsync(): Promise<
+    { name: JobGroupKeys; cron: string; preventManualExecution: boolean; isEnabled: boolean }[]
+  > {
+    const configurations = await this.db.query.cronJobConfigurations.findMany();
+
+    return [...this.jobGroup.getJobRegistry().entries()].map(([name, job]) => {
+      const config = configurations.find((config) => config.name === name);
+      return {
+        name,
+        cron: config?.cronExpression ?? job.cronExpression,
+        preventManualExecution: job.preventManualExecution,
+        isEnabled: config?.isEnabled ?? true,
+      };
+    });
+  }
+}

apps/tasks/src/main.ts

@@ -1,10 +1,45 @@
 // This import has to be the first import in the file so that the agent is overridden before any other modules are imported.
 import "./undici-log-agent-override";
 
-import { registerCronJobRunner } from "@homarr/cron-job-runner/register";
+import type { FastifyTRPCPluginOptions } from "@trpc/server/adapters/fastify";
+import { fastifyTRPCPlugin } from "@trpc/server/adapters/fastify";
+import fastify from "fastify";
+
+import type { JobRouter } from "@homarr/cron-job-api";
+import { jobRouter } from "@homarr/cron-job-api";
+import { CRON_JOB_API_KEY_HEADER, CRON_JOB_API_PATH, CRON_JOB_API_PORT } from "@homarr/cron-job-api/constants";
 import { jobGroup } from "@homarr/cron-jobs";
+import { db } from "@homarr/db";
+import { logger } from "@homarr/log";
+
+import { JobManager } from "./job-manager";
+
+const server = fastify({
+  maxParamLength: 5000,
+});
+server.register(fastifyTRPCPlugin, {
+  prefix: CRON_JOB_API_PATH,
+  trpcOptions: {
+    router: jobRouter,
+    createContext: ({ req }) => ({
+      manager: new JobManager(db, jobGroup),
+      apiKey: req.headers[CRON_JOB_API_KEY_HEADER] as string | undefined,
+    }),
+    onError({ path, error }) {
+      logger.error(new Error(`Error in tasks tRPC handler path="${path}"`, { cause: error }));
+    },
+  } satisfies FastifyTRPCPluginOptions<JobRouter>["trpcOptions"],
+});
 
 void (async () => {
-  registerCronJobRunner();
+  await jobGroup.initializeAsync();
   await jobGroup.startAllAsync();
+
+  try {
+    await server.listen({ port: CRON_JOB_API_PORT });
+    logger.info(`Tasks web server started successfully port="${CRON_JOB_API_PORT}"`);
+  } catch (err) {
+    logger.error(new Error(`Failed to start tasks web server port="${CRON_JOB_API_PORT}"`, { cause: err }));
+    process.exit(1);
+  }
 })();

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",

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);

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);
 }

packages/cron-job-api/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"
   }

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}`;
+}

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";

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,
+});

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;

packages/cron-job-runner/index.ts

@@ -1 +0,0 @@
-export * from "./src";

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);

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);
-  });
-};

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": {

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

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);
       },

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");
 

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),

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`)
+);

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
     }
   ]
 }

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
+);

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
     }
   ]
 }

packages/db/schema/index.ts

@@ -40,6 +40,7 @@ export const {
   itemLayouts,
   sectionLayouts,
   trustedCertificateHostnames,
+  cronJobConfigurations,
 } = schema;
 
 export type User = InferSelectModel<typeof schema.users>;

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],

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],

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": {

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",

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);
+};

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",
+});

pnpm-lock.yaml

@@ -347,9 +347,9 @@ importers:
       '@homarr/common':
         specifier: workspace:^0.1.0
         version: link:../../packages/common
-      '@homarr/cron-job-runner':
+      '@homarr/cron-job-api':
         specifier: workspace:^0.1.0
-        version: link:../../packages/cron-job-runner
+        version: link:../../packages/cron-job-api
       '@homarr/cron-jobs':
         specifier: workspace:^0.1.0
         version: link:../../packages/cron-jobs
@@ -392,6 +392,9 @@ importers:
       dotenv:
         specifier: ^17.0.1
         version: 17.0.1
+      fastify:
+        specifier: ^5.4.0
+        version: 5.4.0
       superjson:
         specifier: 2.2.2
         version: 2.2.2
@@ -536,9 +539,9 @@ importers:
       '@homarr/common':
         specifier: workspace:^0.1.0
         version: link:../common
-      '@homarr/cron-job-runner':
+      '@homarr/cron-job-api':
         specifier: workspace:^0.1.0
-        version: link:../cron-job-runner
+        version: link:../cron-job-api
       '@homarr/cron-job-status':
         specifier: workspace:^0.1.0
         version: link:../cron-job-status
@@ -864,7 +867,7 @@ importers:
         specifier: ^5.8.3
         version: 5.8.3
 
-  packages/cron-job-runner:
+  packages/cron-job-api:
     dependencies:
       '@homarr/common':
         specifier: workspace:^0.1.0
@@ -872,15 +875,33 @@ importers:
       '@homarr/cron-jobs':
         specifier: workspace:^0.1.0
         version: link:../cron-jobs
+      '@homarr/env':
+        specifier: workspace:^0.1.0
+        version: link:../env
       '@homarr/log':
         specifier: workspace:^0.1.0
         version: link:../log
-      '@homarr/redis':
-        specifier: workspace:^0.1.0
-        version: link:../redis
-      '@homarr/validation':
-        specifier: workspace:^0.1.0
-        version: link:../validation
+      '@tanstack/react-query':
+        specifier: ^5.81.5
+        version: 5.81.5(react@19.1.0)
+      '@trpc/client':
+        specifier: ^11.4.3
+        version: 11.4.3(@trpc/server@11.4.3(typescript@5.8.3))(typescript@5.8.3)
+      '@trpc/server':
+        specifier: ^11.4.3
+        version: 11.4.3(typescript@5.8.3)
+      '@trpc/tanstack-react-query':
+        specifier: ^11.4.3
+        version: 11.4.3(@tanstack/react-query@5.81.5(react@19.1.0))(@trpc/client@11.4.3(@trpc/server@11.4.3(typescript@5.8.3))(typescript@5.8.3))(@trpc/server@11.4.3(typescript@5.8.3))(react-dom@19.1.0(react@19.1.0))(react@19.1.0)(typescript@5.8.3)
+      node-cron:
+        specifier: ^4.2.0
+        version: 4.2.0
+      react:
+        specifier: 19.1.0
+        version: 19.1.0
+      zod:
+        specifier: ^3.25.67
+        version: 3.25.67
     devDependencies:
       '@homarr/eslint-config':
         specifier: workspace:^0.2.0
@@ -891,6 +912,12 @@ importers:
       '@homarr/tsconfig':
         specifier: workspace:^0.1.0
         version: link:../../tooling/typescript
+      '@types/node-cron':
+        specifier: ^3.0.11
+        version: 3.0.11
+      '@types/react':
+        specifier: 19.1.8
+        version: 19.1.8
       eslint:
         specifier: ^9.30.1
         version: 9.30.1
@@ -995,6 +1022,9 @@ importers:
       '@homarr/common':
         specifier: workspace:^0.1.0
         version: link:../common
+      '@homarr/db':
+        specifier: workspace:^0.1.0
+        version: link:../db
       node-cron:
         specifier: ^4.2.0
         version: 4.2.0
@@ -1998,6 +2028,9 @@ importers:
       react-dom:
         specifier: 19.1.0
         version: 19.1.0(react@19.1.0)
+      svgson:
+        specifier: ^5.3.1
+        version: 5.3.1
     devDependencies:
       '@homarr/eslint-config':
         specifier: workspace:^0.2.0
@@ -3231,6 +3264,24 @@ packages:
     resolution: {integrity: sha512-hgTjb7vHNXPiSSshAJSE6D5w2bMW6jWklj52B2SG5BI5GakkH14PxDiXHzyRZrJgVd2t1BEcA/aaM8eXazUHaA==}
     engines: {node: '>= 18'}
 
+  '@fastify/ajv-compiler@4.0.2':
+    resolution: {integrity: sha512-Rkiu/8wIjpsf46Rr+Fitd3HRP+VsxUFDDeag0hs9L0ksfnwx2g7SPQQTFL0E8Qv+rfXzQOxBJnjUB9ITUDjfWQ==}
+
+  '@fastify/error@4.2.0':
+    resolution: {integrity: sha512-RSo3sVDXfHskiBZKBPRgnQTtIqpi/7zhJOEmAxCiBcM7d0uwdGdxLlsCaLzGs8v8NnxIRlfG0N51p5yFaOentQ==}
+
+  '@fastify/fast-json-stringify-compiler@5.0.3':
+    resolution: {integrity: sha512-uik7yYHkLr6fxd8hJSZ8c+xF4WafPK+XzneQDPU+D10r5X19GW8lJcom2YijX2+qtFF1ENJlHXKFM9ouXNJYgQ==}
+
+  '@fastify/forwarded@3.0.0':
+    resolution: {integrity: sha512-kJExsp4JCms7ipzg7SJ3y8DwmePaELHxKYtg+tZow+k0znUTf3cb+npgyqm8+ATZOdmfgfydIebPDWM172wfyA==}
+
+  '@fastify/merge-json-schemas@0.2.1':
+    resolution: {integrity: sha512-OA3KGBCy6KtIvLf8DINC5880o5iBlDX4SxzLQS8HorJAbqluzLRn80UXU0bxZn7UOFhFgpRJDasfwn9nG4FG4A==}
+
+  '@fastify/proxy-addr@5.0.0':
+    resolution: {integrity: sha512-37qVVA1qZ5sgH7KpHkkC4z9SK6StIsIcOmpjvMPXNb3vx2GQxhZocogVYbr2PbbeLCQxYIPDok307xEvRZOzGA==}
+
   '@floating-ui/core@1.6.8':
     resolution: {integrity: sha512-7XJ9cPU+yI2QeLS+FCSlqNFZJq8arvswefkZrYI1yQBbftw6FyrZOxYSh+9S7z7TpeWlRt9zJ5IhM1WIL334jA==}
 
@@ -5044,6 +5095,9 @@ packages:
     resolution: {integrity: sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==}
     engines: {node: '>=6.5'}
 
+  abstract-logging@2.0.1:
+    resolution: {integrity: sha512-2BjRTZxTPvheOvGbBslFSYOUkr+SjPtOnrLP33f+VIWLzezQpZcqVg7ja3L4dBXmzzgwT+a029jRx5PCi3JuiA==}
+
   accepts@1.3.8:
     resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
     engines: {node: '>= 0.6'}
@@ -5104,6 +5158,14 @@ packages:
       ajv:
         optional: true
 
+  ajv-formats@3.0.1:
+    resolution: {integrity: sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==}
+    peerDependencies:
+      ajv: ^8.0.0
+    peerDependenciesMeta:
+      ajv:
+        optional: true
+
   ajv-keywords@3.5.2:
     resolution: {integrity: sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==}
     peerDependencies:
@@ -5277,6 +5339,10 @@ packages:
   asynckit@0.4.0:
     resolution: {integrity: sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==}
 
+  atomic-sleep@1.0.0:
+    resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==}
+    engines: {node: '>=8.0.0'}
+
   attr-accept@2.2.5:
     resolution: {integrity: sha512-0bDNnY/u6pPwHDMoF0FieU354oBi0a8rD9FcsLwzcGWbc8KS8KPIi7y+s13OlVY+gMWc/9xEMUgNE6Qm8ZllYQ==}
     engines: {node: '>=4'}
@@ -5288,6 +5354,9 @@ packages:
     resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
     engines: {node: '>= 0.4'}
 
+  avvio@9.1.0:
+    resolution: {integrity: sha512-fYASnYi600CsH/j9EQov7lECAniYiBFiiAtBNuZYLA2leLe9qOvZzqYHFjtIj6gD2VMoMLP14834LFWvr4IfDw==}
+
   aws-ssl-profiles@1.1.2:
     resolution: {integrity: sha512-NZKeq9AfyQvEeNlN0zSYAaWrmBffJh3IELMZfRpJVWgrpEbtEpnjvzqBPf+mxoI287JohRDoa+/nsfqqiZmF6g==}
     engines: {node: '>= 6.0.0'}
@@ -5976,6 +6045,10 @@ packages:
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
+  deep-rename-keys@0.2.1:
+    resolution: {integrity: sha512-RHd9ABw4Fvk+gYDWqwOftG849x0bYOySl/RgX0tLI9i27ZIeSO91mLZJEp7oPHOMFqHvpgu21YptmDt0FYD/0A==}
+    engines: {node: '>=0.10.0'}
+
   deepmerge@4.3.1:
     resolution: {integrity: sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==}
     engines: {node: '>=0.10.0'}
@@ -6543,6 +6616,9 @@ packages:
   eventemitter2@6.4.9:
     resolution: {integrity: sha512-JEPTiaOt9f04oa6NOkc4aH+nVp5I3wEjpHbIPqfgCdD5v5bUzy7xQqwcVO2aDQgOWhI28da57HksMrzK9HlRxg==}
 
+  eventemitter3@2.0.3:
+    resolution: {integrity: sha512-jLN68Dx5kyFHaePoXWPsCGW5qdyZQtLYHkxkg02/Mz6g0kYpDx4FyP6XfArhQdlOC4b8Mv+EMxPo/8La7Tzghg==}
+
   eventemitter3@4.0.7:
     resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
 
@@ -6584,6 +6660,9 @@ packages:
   fast-content-type-parse@3.0.0:
     resolution: {integrity: sha512-ZvLdcY8P+N8mGQJahJV5G4U88CSvT1rP8ApL6uETe88MBXrBHAkZlSEySdUlyztF7ccb+Znos3TFqaepHxdhBg==}
 
+  fast-decode-uri-component@1.0.1:
+    resolution: {integrity: sha512-WKgKWg5eUxvRZGwW8FvfbaH7AXSh2cL+3j5fMGzUMCxWBJ3dV3a7Wz8y2f/uQ0e3B6WmodD3oS54jTQ9HVTIIg==}
+
   fast-deep-equal@3.1.3:
     resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
 
@@ -6608,9 +6687,19 @@ packages:
   fast-json-stable-stringify@2.1.0:
     resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
 
+  fast-json-stringify@6.0.1:
+    resolution: {integrity: sha512-s7SJE83QKBZwg54dIbD5rCtzOBVD43V1ReWXXYqBgwCwHLYAAT0RQc/FmrQglXqWPpz6omtryJQOau5jI4Nrvg==}
+
   fast-levenshtein@2.0.6:
     resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
 
+  fast-querystring@1.1.2:
+    resolution: {integrity: sha512-g6KuKWmFXc0fID8WWH0jit4g0AGBoJhCkJMb1RmbsSEUNvQ+ZC8D6CUZ+GtF8nMzSPXnhiePyyqqipzNNEnHjg==}
+
+  fast-redact@3.5.0:
+    resolution: {integrity: sha512-dwsoQlS7h9hMeYUq1W++23NDcBLV4KqONnITDV9DjfS3q1SgDGVrBdvvTLUotWtPSD7asWDV9/CmsZPy8Hf70A==}
+    engines: {node: '>=6'}
+
   fast-uri@3.0.6:
     resolution: {integrity: sha512-Atfo14OibSv5wAp4VWNsFYE1AchQRTv9cBGWET4pZWHzYshFSS9NQI6I57rdKn9croWVMbYFbLhJ+yJvmZIIHw==}
 
@@ -6624,6 +6713,9 @@ packages:
     peerDependencies:
       '@babel/types': ^7
 
+  fastify@5.4.0:
+    resolution: {integrity: sha512-I4dVlUe+WNQAhKSyv15w+dwUh2EPiEl4X2lGYMmNSgF83WzTMAPKGdWEv5tPsCQOb+SOZwz8Vlta2vF+OeDgRw==}
+
   fastq@1.17.1:
     resolution: {integrity: sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==}
 
@@ -6677,6 +6769,10 @@ packages:
     resolution: {integrity: sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==}
     engines: {node: '>=8'}
 
+  find-my-way@9.3.0:
+    resolution: {integrity: sha512-eRoFWQw+Yv2tuYlK2pjFS2jGXSxSppAs3hSQjfxVKxM5amECzIgYYc1FEI8ZmhSh/Ig+FrKEz43NLRKJjYCZVg==}
+    engines: {node: '>=20'}
+
   find-up-simple@1.0.0:
     resolution: {integrity: sha512-q7Us7kcjj2VMePAa02hDAF6d+MzsdsAWEwYyOpwUtlerRBkOEPBCRZrAV4XfcSN8fHAgaD0hP7miwoay6DCprw==}
     engines: {node: '>=18'}
@@ -7193,6 +7289,10 @@ packages:
     resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}
     engines: {node: '>= 12'}
 
+  ipaddr.js@2.2.0:
+    resolution: {integrity: sha512-Ag3wB2o37wslZS19hZqorUnrnzSkpOVy+IiiDEiTqNubEYpYuHWIf6K4psgN2ZWKExS4xhVCrRVfb/wfW8fWJA==}
+    engines: {node: '>= 10'}
+
   iron-webcrypto@1.2.1:
     resolution: {integrity: sha512-feOM6FaSr6rEABp/eDfVseKyTMDt+KGpeB35SkVn9Tyn0CqvVsY3EwI0v5i8nMHyJnzCIQf7nsy3p41TPkJZhg==}
 
@@ -7241,6 +7341,9 @@ packages:
     resolution: {integrity: sha512-l9qO6eFlUETHtuihLcYOaLKByJ1f+N4kthcU9YjHy3N+B3hWv0y/2Nd0mu/7lTFnRQHTrSdXF50HQ3bl5fEnng==}
     engines: {node: '>= 0.4'}
 
+  is-buffer@1.1.6:
+    resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==}
+
   is-callable@1.2.7:
     resolution: {integrity: sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA==}
     engines: {node: '>= 0.4'}
@@ -7586,6 +7689,9 @@ packages:
   json-parse-even-better-errors@2.3.1:
     resolution: {integrity: sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==}
 
+  json-schema-ref-resolver@2.0.1:
+    resolution: {integrity: sha512-HG0SIB9X4J8bwbxCbnd5FfPEbcXAJYTi1pBJeP/QPON+w8ovSME8iRG+ElHNxZNX2Qh6eYn1GdzJFS4cDFfx0Q==}
+
   json-schema-traverse@0.4.1:
     resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
 
@@ -7623,6 +7729,10 @@ packages:
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
+  kind-of@3.2.2:
+    resolution: {integrity: sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==}
+    engines: {node: '>=0.10.0'}
+
   kleur@4.1.5:
     resolution: {integrity: sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ==}
     engines: {node: '>=6'}
@@ -7653,6 +7763,9 @@ packages:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
+  light-my-request@6.6.0:
+    resolution: {integrity: sha512-CHYbu8RtboSIoVsHZ6Ye4cj4Aw/yg2oAFimlF7mNvfDV192LR7nDiKtSIfCuLT7KokPSTn/9kfVLm5OGN0A28A==}
+
   lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
@@ -8394,6 +8507,10 @@ packages:
   ohash@1.1.4:
     resolution: {integrity: sha512-FlDryZAahJmEF3VR3w1KogSEdWX3WhA5GPakFx4J81kEAiHyLMpdLLElS8n8dfNadMgAne/MywcvmogzscVt4g==}
 
+  on-exit-leak-free@2.1.2:
+    resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==}
+    engines: {node: '>=14.0.0'}
+
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
@@ -8625,6 +8742,16 @@ packages:
     resolution: {integrity: sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg==}
     engines: {node: '>=4'}
 
+  pino-abstract-transport@2.0.0:
+    resolution: {integrity: sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==}
+
+  pino-std-serializers@7.0.0:
+    resolution: {integrity: sha512-e906FRY0+tV27iq4juKzSYPbUj2do2X2JX4EzSca1631EB2QJQUqGbDuERal7LCtOpxl6x3+nvo9NPZcmjkiFA==}
+
+  pino@9.7.0:
+    resolution: {integrity: sha512-vnMCM6xZTb1WDmLvtG2lE/2p+t9hDEIvTWJsu6FejkE62vB7gDhvzrpFR4Cw2to+9JNQxVnkAKVPA1KPB98vWg==}
+    hasBin: true
+
   piscina@4.6.1:
     resolution: {integrity: sha512-z30AwWGtQE+Apr+2WBZensP2lIvwoaMcOPkQlIEmSGMJNUvaYACylPYrQM6wSdUNJlnDVMSpLv7xTMJqlVshOA==}
 
@@ -8750,6 +8877,12 @@ packages:
   process-nextick-args@2.0.1:
     resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
 
+  process-warning@4.0.1:
+    resolution: {integrity: sha512-3c2LzQ3rY9d0hc1emcsHhfT9Jwz0cChib/QN89oME2R451w5fy3f0afAhERFZAwrbDU43wk12d0ORBpDVME50Q==}
+
+  process-warning@5.0.0:
+    resolution: {integrity: sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==}
+
   process@0.11.10:
     resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
     engines: {node: '>= 0.6.0'}
@@ -8873,6 +9006,9 @@ packages:
   queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
+  quick-format-unescaped@4.0.4:
+    resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==}
+
   radix3@1.1.2:
     resolution: {integrity: sha512-b484I/7b8rDEdSDKckSSBA8knMpcdsXudlE/LNL639wFoHKwLbEkQFZHWEYwDC0wa0FKUcCY+GAF73Z7wxNVFA==}
 
@@ -9070,6 +9206,10 @@ packages:
     resolution: {integrity: sha512-GkMg9uOTpIWWKbSsgwb5fA4EavTR+SG/PMPoAY8hkhHfEEY0/vqljY+XHqtDf2cr2IJtoNRDbrrEpZUiZCkYRw==}
     engines: {node: '>= 14.16.0'}
 
+  real-require@0.2.0:
+    resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==}
+    engines: {node: '>= 12.13.0'}
+
   recast@0.23.11:
     resolution: {integrity: sha512-YTUo+Flmw4ZXiWfQKGcwwc11KnoRAYgzAE2E7mXKCjSviTKShtxBsN6YUUBB2gtaBzKzeKunxhUwNHQuRryhWA==}
     engines: {node: '>= 4'}
@@ -9151,6 +9291,10 @@ packages:
   remove-accents@0.5.0:
     resolution: {integrity: sha512-8g3/Otx1eJaVD12e31UbJj1YzdtVvzH85HV7t+9MJYk/u3XmkOUJ5Ys9wQrf9PCPK8+xn4ymzqYCiZl6QWKn+A==}
 
+  rename-keys@1.2.0:
+    resolution: {integrity: sha512-U7XpAktpbSgHTRSNRrjKSrjYkZKuhUukfoBlXWXUExCAqhzh1TU3BDRAfJmarcl5voKS+pbKU9MvyLWKZ4UEEg==}
+    engines: {node: '>= 0.8.0'}
+
   repeat-string@1.6.1:
     resolution: {integrity: sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==}
     engines: {node: '>=0.10'}
@@ -9196,6 +9340,10 @@ packages:
     resolution: {integrity: sha512-M0b3YWQs7R3Z917WRQy1HHA7Ba7D8hvZg6UE5mLykJxQVE2ju0IXbGlaHPPlkY+WN7wFP+wUMXmBFA0aV6vYGQ==}
     engines: {node: '>=4'}
 
+  ret@0.5.0:
+    resolution: {integrity: sha512-I1XxrZSQ+oErkRR4jYbAyEEu2I0avBvvMM5JN+6EBprOGRCs63ENqZ3vjavq8fBw2+62G5LF5XelKwuJpcvcxw==}
+    engines: {node: '>=10'}
+
   retry@0.12.0:
     resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==}
     engines: {node: '>= 4'}
@@ -9207,6 +9355,9 @@ packages:
   rfc4648@1.5.3:
     resolution: {integrity: sha512-MjOWxM065+WswwnmNONOT+bD1nXzY9Km6u3kzvnx8F8/HXGZdz3T6e6vZJ8Q/RIMUSp/nxqjH3GwvJDy8ijeQQ==}
 
+  rfdc@1.4.1:
+    resolution: {integrity: sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==}
+
   rimraf@3.0.2:
     resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
     deprecated: Rimraf versions prior to v4 are no longer supported
@@ -9281,6 +9432,9 @@ packages:
     resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
     engines: {node: '>= 0.4'}
 
+  safe-regex2@5.0.0:
+    resolution: {integrity: sha512-YwJwe5a51WlK7KbOJREPdjNrpViQBI3p4T50lfwPuDhZnE3XGVTlGvi+aolc5+RvxDD6bnUmjVsU9n1eboLUYw==}
+
   safe-stable-stringify@2.5.0:
     resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
     engines: {node: '>=10'}
@@ -9311,6 +9465,9 @@ packages:
     resolution: {integrity: sha512-Gf9qqc58SpCA/xdziiHz35F4GNIWYWZrEshUc/G/r5BnLph6xpKuLeoJoQuj5WfBIx/eQLf+hmVPYHaxJu7V2g==}
     engines: {node: '>= 10.13.0'}
 
+  secure-json-parse@4.0.0:
+    resolution: {integrity: sha512-dxtLJO6sc35jWidmLxo7ij+Eg48PM/kleBsxpC8QJE0qJICe+KawkDQmvCMZUr9u7WKVHgMW6vy3fQ7zMiFZMA==}
+
   semantic-release@24.2.6:
     resolution: {integrity: sha512-D0cwjlO5RZzHHxAcsoF1HxiRLfC3ehw+ay+zntzFs6PNX6aV0JzKNG15mpxPipBYa/l4fHly88dHvgDyqwb1Ww==}
     engines: {node: '>=20.8.1'}
@@ -9363,6 +9520,9 @@ packages:
   serialize-javascript@6.0.2:
     resolution: {integrity: sha512-Saa1xPByTTq2gdeFZYLLo+RFE35NHZkAbqZeWNd3BpzppeVisAqpDjcp8dyf6uIvEqJRd46jemmyA4iFIeVk8g==}
 
+  set-cookie-parser@2.7.1:
+    resolution: {integrity: sha512-IOc8uWeOZgnb3ptbCURJWNjWUPcO3ZnTTdzsurqERrP6nPyv+paC55vJM0LpOlT2ne+Ix+9+CRG1MNLlyZ4GjQ==}
+
   set-function-length@1.2.2:
     resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
     engines: {node: '>= 0.4'}
@@ -9489,6 +9649,9 @@ packages:
     resolution: {integrity: sha512-l5x7VUUWbjVFbafGLxPWkYsHIhEvmF85tbIeFZWc8ZPtoMyybuEhL7Jye/ooC4/d48FgOjSJXgsF/AJPYCW8Zw==}
     engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
+  sonic-boom@4.2.0:
+    resolution: {integrity: sha512-INb7TM37/mAcsGmc9hyyI6+QR3rR1zVRu36B0NeGXKnOOLiZOfER5SA+N7X7k3yUYRzLWafduTDvJAfDswwEww==}
+
   sort-object-keys@1.1.3:
     resolution: {integrity: sha512-855pvK+VkU7PaKYPc+Jjnmt4EzejQHyhhF33q31qG8x7maDzkeFhAAThdCYay11CISO+qAMwjOBP+fPZe0IPyg==}
 
@@ -9535,6 +9698,10 @@ packages:
   split2@1.0.0:
     resolution: {integrity: sha512-NKywug4u4pX/AZBB1FCPzZ6/7O+Xhz1qMVbzTvvKvikjO99oPN87SkK08mEY9P63/5lWjK+wgOOgApnTg5r6qg==}
 
+  split2@4.2.0:
+    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
+    engines: {node: '>= 10.x'}
+
   sprintf-js@1.0.3:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
@@ -9727,6 +9894,9 @@ packages:
     resolution: {integrity: sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==}
     engines: {node: '>= 0.4'}
 
+  svgson@5.3.1:
+    resolution: {integrity: sha512-qdPgvUNWb40gWktBJnbJRelWcPzkLed/ShhnRsjbayXz8OtdPOzbil9jtiZdrYvSDumAz/VNQr6JaNfPx/gvPA==}
+
   swagger-client@3.35.5:
     resolution: {integrity: sha512-ayCrpDAgm5jIdq1kmcVWJRfp27cqU9tSRiAfKg3BKeplOmvu3+lKTPPtz4x1uI8v5l5/92Aopvq0EzRkXEr7Rw==}
 
@@ -9818,6 +9988,9 @@ packages:
   thenify@3.3.1:
     resolution: {integrity: sha512-RVZSIV5IG10Hk3enotrhvz0T9em6cyHBLkH/YAZuKqd8hRkKhSfCGIcP2KUY0EPxndzANBmNllzWPwak+bheSw==}
 
+  thread-stream@3.1.0:
+    resolution: {integrity: sha512-OqyPZ9u96VohAyMfJykzmivOrY2wfMSf3C5TtFJVgN+Hm6aj+voFhlK+kZEIv2FBh1X6Xp3DlnCOfEQ3B2J86A==}
+
   through2@2.0.5:
     resolution: {integrity: sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==}
 
@@ -10634,10 +10807,16 @@ packages:
     resolution: {integrity: sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g==}
     hasBin: true
 
+  xml-lexer@0.2.2:
+    resolution: {integrity: sha512-G0i98epIwiUEiKmMcavmVdhtymW+pCAohMRgybyIME9ygfVu8QheIi+YoQh3ngiThsT0SQzJT4R0sKDEv8Ou0w==}
+
   xml-name-validator@5.0.0:
     resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
     engines: {node: '>=18'}
 
+  xml-reader@2.4.3:
+    resolution: {integrity: sha512-xWldrIxjeAMAu6+HSf9t50ot1uL5M+BtOidRCWHXIeewvSeIpscWCsp4Zxjk8kHHhdqFBrfK8U0EJeCcnyQ/gA==}
+
   xml2js@0.6.2:
     resolution: {integrity: sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==}
     engines: {node: '>=4.0.0'}
@@ -11512,6 +11691,29 @@ snapshots:
     transitivePeerDependencies:
       - encoding
 
+  '@fastify/ajv-compiler@4.0.2':
+    dependencies:
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      fast-uri: 3.0.6
+
+  '@fastify/error@4.2.0': {}
+
+  '@fastify/fast-json-stringify-compiler@5.0.3':
+    dependencies:
+      fast-json-stringify: 6.0.1
+
+  '@fastify/forwarded@3.0.0': {}
+
+  '@fastify/merge-json-schemas@0.2.1':
+    dependencies:
+      dequal: 2.0.3
+
+  '@fastify/proxy-addr@5.0.0':
+    dependencies:
+      '@fastify/forwarded': 3.0.0
+      ipaddr.js: 2.2.0
+
   '@floating-ui/core@1.6.8':
     dependencies:
       '@floating-ui/utils': 0.2.8
@@ -13759,6 +13961,8 @@ snapshots:
     dependencies:
       event-target-shim: 5.0.1
 
+  abstract-logging@2.0.1: {}
+
   accepts@1.3.8:
     dependencies:
       mime-types: 2.1.35
@@ -13807,6 +14011,10 @@ snapshots:
     optionalDependencies:
       ajv: 8.17.1
 
+  ajv-formats@3.0.1(ajv@8.17.1):
+    optionalDependencies:
+      ajv: 8.17.1
+
   ajv-keywords@3.5.2(ajv@6.12.6):
     dependencies:
       ajv: 6.12.6
@@ -14040,6 +14248,8 @@ snapshots:
 
   asynckit@0.4.0: {}
 
+  atomic-sleep@1.0.0: {}
+
   attr-accept@2.2.5: {}
 
   autolinker@3.16.2:
@@ -14050,6 +14260,11 @@ snapshots:
     dependencies:
       possible-typed-array-names: 1.0.0
 
+  avvio@9.1.0:
+    dependencies:
+      '@fastify/error': 4.2.0
+      fastq: 1.17.1
+
   aws-ssl-profiles@1.1.2: {}
 
   axe-core@4.10.0: {}
@@ -14742,6 +14957,11 @@ snapshots:
 
   deep-is@0.1.4: {}
 
+  deep-rename-keys@0.2.1:
+    dependencies:
+      kind-of: 3.2.2
+      rename-keys: 1.2.0
+
   deepmerge@4.3.1: {}
 
   defaults@1.0.4:
@@ -15540,6 +15760,8 @@ snapshots:
 
   eventemitter2@6.4.9: {}
 
+  eventemitter3@2.0.3: {}
+
   eventemitter3@4.0.7: {}
 
   events@3.3.0: {}
@@ -15601,6 +15823,8 @@ snapshots:
 
   fast-content-type-parse@3.0.0: {}
 
+  fast-decode-uri-component@1.0.1: {}
+
   fast-deep-equal@3.1.3: {}
 
   fast-equals@5.2.2: {}
@@ -15627,8 +15851,23 @@ snapshots:
 
   fast-json-stable-stringify@2.1.0: {}
 
+  fast-json-stringify@6.0.1:
+    dependencies:
+      '@fastify/merge-json-schemas': 0.2.1
+      ajv: 8.17.1
+      ajv-formats: 3.0.1(ajv@8.17.1)
+      fast-uri: 3.0.6
+      json-schema-ref-resolver: 2.0.1
+      rfdc: 1.4.1
+
   fast-levenshtein@2.0.6: {}
 
+  fast-querystring@1.1.2:
+    dependencies:
+      fast-decode-uri-component: 1.0.1
+
+  fast-redact@3.5.0: {}
+
   fast-uri@3.0.6: {}
 
   fast-xml-parser@5.2.5:
@@ -15639,6 +15878,24 @@ snapshots:
     dependencies:
       '@babel/types': 7.26.0
 
+  fastify@5.4.0:
+    dependencies:
+      '@fastify/ajv-compiler': 4.0.2
+      '@fastify/error': 4.2.0
+      '@fastify/fast-json-stringify-compiler': 5.0.3
+      '@fastify/proxy-addr': 5.0.0
+      abstract-logging: 2.0.1
+      avvio: 9.1.0
+      fast-json-stringify: 6.0.1
+      find-my-way: 9.3.0
+      light-my-request: 6.6.0
+      pino: 9.7.0
+      process-warning: 5.0.0
+      rfdc: 1.4.1
+      secure-json-parse: 4.0.0
+      semver: 7.7.1
+      toad-cache: 3.7.0
+
   fastq@1.17.1:
     dependencies:
       reusify: 1.0.4
@@ -15685,6 +15942,12 @@ snapshots:
     dependencies:
       to-regex-range: 5.0.1
 
+  find-my-way@9.3.0:
+    dependencies:
+      fast-deep-equal: 3.1.3
+      fast-querystring: 1.1.2
+      safe-regex2: 5.0.0
+
   find-up-simple@1.0.0: {}
 
   find-up@2.1.0:
@@ -16289,6 +16552,8 @@ snapshots:
       jsbn: 1.1.0
       sprintf-js: 1.1.3
 
+  ipaddr.js@2.2.0: {}
+
   iron-webcrypto@1.2.1: {}
 
   is-alphabetical@1.0.4: {}
@@ -16342,6 +16607,8 @@ snapshots:
       call-bound: 1.0.4
       has-tostringtag: 1.0.2
 
+  is-buffer@1.1.6: {}
+
   is-callable@1.2.7: {}
 
   is-ci@2.0.0:
@@ -16666,6 +16933,10 @@ snapshots:
 
   json-parse-even-better-errors@2.3.1: {}
 
+  json-schema-ref-resolver@2.0.1:
+    dependencies:
+      dequal: 2.0.3
+
   json-schema-traverse@0.4.1: {}
 
   json-schema-traverse@1.0.0: {}
@@ -16705,6 +16976,10 @@ snapshots:
     dependencies:
       json-buffer: 3.0.1
 
+  kind-of@3.2.2:
+    dependencies:
+      is-buffer: 1.1.6
+
   kleur@4.1.5: {}
 
   klona@2.0.6: {}
@@ -16737,6 +17012,12 @@ snapshots:
       prelude-ls: 1.2.1
       type-check: 0.4.0
 
+  light-my-request@6.6.0:
+    dependencies:
+      cookie: 1.0.2
+      process-warning: 4.0.1
+      set-cookie-parser: 2.7.1
+
   lines-and-columns@1.2.4: {}
 
   linkify-it@5.0.0:
@@ -17547,6 +17828,8 @@ snapshots:
 
   ohash@1.1.4: {}
 
+  on-exit-leak-free@2.1.2: {}
+
   once@1.4.0:
     dependencies:
       wrappy: 1.0.2
@@ -17792,6 +18075,26 @@ snapshots:
 
   pify@3.0.0: {}
 
+  pino-abstract-transport@2.0.0:
+    dependencies:
+      split2: 4.2.0
+
+  pino-std-serializers@7.0.0: {}
+
+  pino@9.7.0:
+    dependencies:
+      atomic-sleep: 1.0.0
+      fast-redact: 3.5.0
+      on-exit-leak-free: 2.1.2
+      pino-abstract-transport: 2.0.0
+      pino-std-serializers: 7.0.0
+      process-warning: 5.0.0
+      quick-format-unescaped: 4.0.4
+      real-require: 0.2.0
+      safe-stable-stringify: 2.5.0
+      sonic-boom: 4.2.0
+      thread-stream: 3.1.0
+
   piscina@4.6.1:
     optionalDependencies:
       nice-napi: 1.0.2
@@ -17916,6 +18219,10 @@ snapshots:
 
   process-nextick-args@2.0.1: {}
 
+  process-warning@4.0.1: {}
+
+  process-warning@5.0.0: {}
+
   process@0.11.10: {}
 
   prop-types@15.8.1:
@@ -18102,6 +18409,8 @@ snapshots:
 
   queue-microtask@1.2.3: {}
 
+  quick-format-unescaped@4.0.4: {}
+
   radix3@1.1.2: {}
 
   ramda-adjunct@5.1.0(ramda@0.30.1):
@@ -18337,6 +18646,8 @@ snapshots:
 
   readdirp@4.0.1: {}
 
+  real-require@0.2.0: {}
+
   recast@0.23.11:
     dependencies:
       ast-types: 0.16.1
@@ -18457,6 +18768,8 @@ snapshots:
 
   remove-accents@0.5.0: {}
 
+  rename-keys@1.2.0: {}
+
   repeat-string@1.6.1: {}
 
   require-directory@2.1.1: {}
@@ -18492,12 +18805,16 @@ snapshots:
 
   ret@0.2.2: {}
 
+  ret@0.5.0: {}
+
   retry@0.12.0: {}
 
   reusify@1.0.4: {}
 
   rfc4648@1.5.3: {}
 
+  rfdc@1.4.1: {}
+
   rimraf@3.0.2:
     dependencies:
       glob: 7.2.3
@@ -18608,6 +18925,10 @@ snapshots:
       es-errors: 1.3.0
       is-regex: 1.2.1
 
+  safe-regex2@5.0.0:
+    dependencies:
+      ret: 0.5.0
+
   safe-stable-stringify@2.5.0: {}
 
   safer-buffer@2.1.2: {}
@@ -18641,6 +18962,8 @@ snapshots:
       ajv-formats: 2.1.1(ajv@8.17.1)
       ajv-keywords: 5.1.0(ajv@8.17.1)
 
+  secure-json-parse@4.0.0: {}
+
   semantic-release@24.2.6(typescript@5.8.3):
     dependencies:
       '@semantic-release/commit-analyzer': 13.0.1(semantic-release@24.2.6(typescript@5.8.3))
@@ -18711,6 +19034,8 @@ snapshots:
     dependencies:
       randombytes: 2.1.0
 
+  set-cookie-parser@2.7.1: {}
+
   set-function-length@1.2.2:
     dependencies:
       define-data-property: 1.1.4
@@ -18906,6 +19231,10 @@ snapshots:
       ip-address: 9.0.5
       smart-buffer: 4.2.0
 
+  sonic-boom@4.2.0:
+    dependencies:
+      atomic-sleep: 1.0.0
+
   sort-object-keys@1.1.3: {}
 
   sort-package-json@3.3.1:
@@ -18953,6 +19282,8 @@ snapshots:
     dependencies:
       through2: 2.0.5
 
+  split2@4.2.0: {}
+
   sprintf-js@1.0.3: {}
 
   sprintf-js@1.1.3: {}
@@ -19169,6 +19500,11 @@ snapshots:
 
   supports-preserve-symlinks-flag@1.0.0: {}
 
+  svgson@5.3.1:
+    dependencies:
+      deep-rename-keys: 0.2.1
+      xml-reader: 2.4.3
+
   swagger-client@3.35.5:
     dependencies:
       '@babel/runtime-corejs3': 7.27.1
@@ -19355,6 +19691,10 @@ snapshots:
     dependencies:
       any-promise: 1.3.0
 
+  thread-stream@3.1.0:
+    dependencies:
+      real-require: 0.2.0
+
   through2@2.0.5:
     dependencies:
       readable-stream: 2.3.8
@@ -19806,7 +20146,7 @@ snapshots:
       pupa: 2.1.1
       registry-auth-token: 5.0.2
       registry-url: 5.1.0
-      semver: 7.6.3
+      semver: 7.7.1
       semver-diff: 3.1.1
       xdg-basedir: 4.0.0
     transitivePeerDependencies:
@@ -20259,8 +20599,17 @@ snapshots:
     dependencies:
       sax: 1.4.1
 
+  xml-lexer@0.2.2:
+    dependencies:
+      eventemitter3: 2.0.3
+
   xml-name-validator@5.0.0: {}
 
+  xml-reader@2.4.3:
+    dependencies:
+      eventemitter3: 2.0.3
+      xml-lexer: 0.2.2
+
   xml2js@0.6.2:
     dependencies:
       sax: 1.4.1

scripts/run.sh

@@ -13,6 +13,8 @@ fi
 
 # Auth secret is generated every time the container starts as it is required, but not used because we don't need JWTs or Mail hashing
 export AUTH_SECRET=$(openssl rand -base64 32)
+# Cron job API key is generated every time the container starts as it is required for communication between nextjs-api and tasks-api
+export CRON_JOB_API_KEY=$(openssl rand -base64 32)
 
 # Start nginx proxy
 # 1. Replace the HOSTNAME in the nginx template file