style: auto-fix lint and format

Reuse a shared TLS agent with timeouts, parallelize list calls, dedupe
detail fetches, and cap concurrency to reduce cron job duration.

apps/nextjs/src/app/[locale]/_client-providers/mantine.tsx

@@ -2,7 +2,7 @@
 
 import type { PropsWithChildren } from "react";
 import type { MantineColorScheme, MantineColorSchemeManager } from "@mantine/core";
-import { DirectionProvider, MantineProvider, v8CssVariablesResolver } from "@mantine/core";
+import { DirectionProvider, MantineProvider } from "@mantine/core";
 import dayjs from "dayjs";
 
 import { clientApi } from "@homarr/api/client";
@@ -18,12 +18,7 @@ export const CustomMantineProvider = ({
   const manager = useColorSchemeManager();
   return (
     <DirectionProvider>
-      <MantineProvider
-        defaultColorScheme={defaultColorScheme}
-        colorSchemeManager={manager}
-        theme={theme}
-        cssVariablesResolver={v8CssVariablesResolver}
-      >
+      <MantineProvider defaultColorScheme={defaultColorScheme} colorSchemeManager={manager} theme={theme}>
         {children}
       </MantineProvider>
     </DirectionProvider>

apps/nextjs/src/app/[locale]/boards/(content)/_creator.tsx

@@ -1,4 +1,3 @@
-import { cache } from "react";
 import type { Metadata } from "next";
 import { TRPCError } from "@trpc/server";
 
@@ -35,20 +34,17 @@ interface Props<TParams extends Params> {
 export const createBoardContentPage = <TParams extends Record<string, unknown>>({
   getInitialBoardAsync: getInitialBoard,
 }: Props<TParams>) => {
-  const getCachedBoard = cache((_paramsKey: string, params: TParams) => getInitialBoard(params));
-  const getBoardForParams = (params: TParams) => getCachedBoard(JSON.stringify(params), params);
-
   return {
     layout: createBoardLayout({
       headerActions: <BoardContentHeaderActions />,
-      getInitialBoardAsync: getBoardForParams,
+      getInitialBoardAsync: getInitialBoard,
     }),
     // eslint-disable-next-line no-restricted-syntax
     page: async ({ params }: { params: Promise<TParams> }) => {
       const resolvedParams = await params;
       const queryClient = getQueryClient();
 
-      const [board, session] = await Promise.all([getBoardForParams(resolvedParams), auth()]);
+      const [board, session] = await Promise.all([getInitialBoard(resolvedParams), auth()]);
 
       const itemsMap = board.items.reduce((acc, item) => {
         const existing = acc.get(item.kind);
@@ -85,7 +81,7 @@ export const createBoardContentPage = <TParams extends Record<string, unknown>>(
     },
     generateMetadataAsync: async ({ params }: { params: Promise<TParams> }): Promise<Metadata> => {
       try {
-        const board = await getBoardForParams(await params);
+        const board = await getInitialBoard(await params);
         const t = await getI18n();
 
         return {
@@ -101,6 +97,7 @@ export const createBoardContentPage = <TParams extends Record<string, unknown>>(
           },
         };
       } catch (error) {
+        // Ignore not found errors and return empty metadata
         if (error instanceof TRPCError && error.code === "NOT_FOUND") {
           return {};
         }

apps/nextjs/src/app/[locale]/boards/(content)/_theme.tsx

@@ -2,7 +2,7 @@
 
 import type { PropsWithChildren } from "react";
 import type { MantineColorsTuple } from "@mantine/core";
-import { colorsTuple, createTheme, darken, lighten, MantineProvider, rem, v8CssVariablesResolver } from "@mantine/core";
+import { colorsTuple, createTheme, darken, lighten, MantineProvider, rem } from "@mantine/core";
 
 import { useRequiredBoard } from "@homarr/boards/context";
 import type { ColorScheme } from "@homarr/definitions";
@@ -33,12 +33,7 @@ export const BoardMantineProvider = ({
   });
 
   return (
-    <MantineProvider
-      defaultColorScheme={defaultColorScheme}
-      theme={theme}
-      colorSchemeManager={colorSchemeManager}
-      cssVariablesResolver={v8CssVariablesResolver}
-    >
+    <MantineProvider defaultColorScheme={defaultColorScheme} theme={theme} colorSchemeManager={colorSchemeManager}>
       {children}
     </MantineProvider>
   );

apps/nextjs/src/app/[locale]/init/_steps/user/init-user-form.tsx

@@ -1,15 +1,15 @@
 "use client";
 
-import { Button, Stack, TextInput } from "@mantine/core";
+import { Button, PasswordInput, Stack, TextInput } from "@mantine/core";
 import type { z } from "zod/v4";
 
 import { clientApi } from "@homarr/api/client";
 import { signIn } from "@homarr/auth/client";
 import { revalidatePathActionAsync } from "@homarr/common/client";
 import { useZodForm } from "@homarr/form";
-import { UserCreatePasswordFields } from "@homarr/forms-collection";
 import { showErrorNotification, showSuccessNotification } from "@homarr/notifications";
 import { useScopedI18n } from "@homarr/translation/client";
+import { CustomPasswordInput } from "@homarr/ui";
 import { userInitSchema } from "@homarr/validation/user";
 
 export const InitUserForm = () => {
@@ -59,10 +59,12 @@ export const InitUserForm = () => {
       >
         <Stack gap="lg">
           <TextInput label={t("field.username.label")} {...form.getInputProps("username")} />
-          <UserCreatePasswordFields
-            passwordInputProps={form.getInputProps("password")}
-            confirmPasswordInputProps={form.getInputProps("confirmPassword")}
+          <CustomPasswordInput
+            withPasswordRequirements
+            label={t("field.password.label")}
+            {...form.getInputProps("password")}
           />
+          <PasswordInput label={t("field.passwordConfirm.label")} {...form.getInputProps("confirmPassword")} />
           <Button type="submit" fullWidth loading={isPending}>
             {t("action.create")}
           </Button>

apps/nextjs/src/app/[locale]/manage/integrations/new/_integration-new-form.tsx

@@ -148,7 +148,9 @@ export const NewIntegrationForm = ({ searchParams }: NewIntegrationFormProps) =>
     );
   };
 
-  const supportsSearchEngine = integrationDefs[searchParams.kind].category.flat().includes("search");
+  const integrationCategories = integrationDefs[searchParams.kind].category.flat();
+  const supportsSearchEngine =
+    integrationCategories.includes("search") && !integrationCategories.includes("mediaSearch");
 
   return (
     <form onSubmit={form.onSubmit((value) => void handleSubmitAsync(value))}>

apps/nextjs/src/app/[locale]/manage/tools/docker/docker-table.tsx

@@ -107,23 +107,6 @@ export function DockerTable(initialData: RouterOutputs["docker"]["getContainers"
     refetchOnReconnect: false,
   });
   const relativeTime = useTimeAgo(data.timestamp);
-  const utils = clientApi.useUtils();
-  const { mutate, isPending } = clientApi.docker.invalidate.useMutation({
-    async onSuccess() {
-      await utils.docker.getContainers.invalidate();
-      showSuccessNotification({
-        title: tDocker("action.refresh.notification.success.title"),
-        message: tDocker("action.refresh.notification.success.message"),
-      });
-    },
-    onError() {
-      showErrorNotification({
-        title: tDocker("action.refresh.notification.error.title"),
-        message: tDocker("action.refresh.notification.error.message"),
-      });
-    },
-  });
-
   const table = useTranslatedMantineReactTable({
     data: data.containers,
     enableDensityToggle: false,
@@ -142,11 +125,35 @@ export function DockerTable(initialData: RouterOutputs["docker"]["getContainers"
     },
 
     initialState: { density: "xs", showGlobalFilter: true },
-    renderTopToolbarCustomActions: () => (
-      <Button variant="default" rightSection={<IconRefresh size="1rem" />} onClick={() => mutate()} loading={isPending}>
-        {tDocker("action.refresh.label")}
-      </Button>
-    ),
+    renderTopToolbarCustomActions: () => {
+      const utils = clientApi.useUtils();
+      const { mutate, isPending } = clientApi.docker.invalidate.useMutation({
+        async onSuccess() {
+          await utils.docker.getContainers.invalidate();
+          showSuccessNotification({
+            title: tDocker("action.refresh.notification.success.title"),
+            message: tDocker("action.refresh.notification.success.message"),
+          });
+        },
+        onError() {
+          showErrorNotification({
+            title: tDocker("action.refresh.notification.error.title"),
+            message: tDocker("action.refresh.notification.error.message"),
+          });
+        },
+      });
+
+      return (
+        <Button
+          variant="default"
+          rightSection={<IconRefresh size="1rem" />}
+          onClick={() => mutate()}
+          loading={isPending}
+        >
+          {tDocker("action.refresh.label")}
+        </Button>
+      );
+    },
     renderToolbarAlertBannerContent: ({ groupedAlert, table }) => {
       const dockerContainers = table.getSelectedRowModel().rows.map((row) => row.original);
       return (

apps/nextjs/src/app/[locale]/manage/users/create/_components/create-user-stepper.tsx

@@ -1,7 +1,20 @@
 "use client";
 
 import { startTransition, useCallback, useState } from "react";
-import { Badge, Button, Card, Group, Stack, Stepper, Table, Text, TextInput, Title, Tooltip } from "@mantine/core";
+import {
+  Badge,
+  Button,
+  Card,
+  Group,
+  PasswordInput,
+  Stack,
+  Stepper,
+  Table,
+  Text,
+  TextInput,
+  Title,
+  Tooltip,
+} from "@mantine/core";
 import { useListState } from "@mantine/hooks";
 import { IconPlus, IconUserCheck } from "@tabler/icons-react";
 import { z } from "zod/v4";
@@ -11,11 +24,10 @@ import type { GroupPermissionKey } from "@homarr/definitions";
 import { everyoneGroup, groupPermissions } from "@homarr/definitions";
 import type { IsValid } from "@homarr/form";
 import { useZodForm } from "@homarr/form";
-import { UserCreatePasswordFields } from "@homarr/forms-collection";
 import { useModalAction } from "@homarr/modals";
 import { showErrorNotification } from "@homarr/notifications";
 import { useI18n, useScopedI18n } from "@homarr/translation/client";
-import { UserAvatar } from "@homarr/ui";
+import { CustomPasswordInput, UserAvatar } from "@homarr/ui";
 import { createCustomErrorParams } from "@homarr/validation/form/i18n";
 import { userPasswordSchema } from "@homarr/validation/user";
 
@@ -155,10 +167,18 @@ export const UserCreateStepperComponent = ({ initialGroups }: UserCreateStepperC
           <form>
             <Card p="xl">
               <Stack gap="md">
-                <UserCreatePasswordFields
+                <CustomPasswordInput
+                  withPasswordRequirements
+                  label={tUserField("password.label")}
                   variant="filled"
-                  passwordInputProps={securityForm.getInputProps("password")}
-                  confirmPasswordInputProps={securityForm.getInputProps("confirmPassword")}
+                  withAsterisk
+                  {...securityForm.getInputProps("password")}
+                />
+                <PasswordInput
+                  label={tUserField("passwordConfirm.label")}
+                  variant="filled"
+                  withAsterisk
+                  {...securityForm.getInputProps("confirmPassword")}
                 />
               </Stack>
             </Card>

deployments/prebuilt-debian/package.json

@@ -6,9 +6,9 @@
   },
   "engines": {
     "node": ">=24.16.0",
-    "pnpm": ">=10.34.1"
+    "pnpm": ">=10.33.4"
   },
-  "packageManager": "pnpm@10.34.1",
+  "packageManager": "pnpm@10.33.4",
   "pnpm": {
     "onlyBuiltDependencies": [
       "better-sqlite3"

package.json

@@ -60,9 +60,9 @@
   },
   "engines": {
     "node": ">=24.16.0",
-    "pnpm": ">=10.34.1"
+    "pnpm": ">=10.33.4"
   },
-  "packageManager": "pnpm@10.34.1",
+  "packageManager": "pnpm@10.33.4",
   "pnpm": {
     "onlyBuiltDependencies": [
       "@tree-sitter-grammars/tree-sitter-yaml",
@@ -76,14 +76,14 @@
       "tree-sitter-json"
     ],
     "overrides": {
-      "@babel/helpers@<7.26.10": ">=7.29.7",
-      "@babel/runtime@<7.26.10": ">=7.29.7",
+      "@babel/helpers@<7.26.10": ">=7.29.2",
+      "@babel/runtime@<7.26.10": ">=7.29.2",
       "axios@>=1.0.0 <1.8.2": ">=1.16.1",
       "brace-expansion@>=2.0.0 <=2.0.1": ">=5.0.6",
       "brace-expansion@>=1.0.0 <=1.1.11": ">=5.0.6",
       "esbuild@<=0.24.2": ">=0.28.0",
       "form-data@>=4.0.0 <4.0.4": ">=4.0.5",
-      "hono@<4.6.5": ">=4.12.23",
+      "hono@<4.6.5": ">=4.12.22",
       "linkifyjs@<4.3.2": ">=4.3.3",
       "nanoid@>=4.0.0 <5.0.9": ">=5.1.11",
       "prismjs@<1.30.0": ">=1.30.0",
@@ -93,7 +93,7 @@
       "sha.js@<=2.4.11": ">=2.4.12",
       "tar-fs@>=3.0.0 <3.0.9": ">=3.1.2",
       "tar-fs@>=2.0.0 <2.1.3": ">=3.1.2",
-      "tmp@<=0.2.3": ">=0.2.7",
+      "tmp@<=0.2.3": ">=0.2.5",
       "vite@>=5.0.0 <=5.4.18": ">=8.0.14"
     },
     "patchedDependencies": {

packages/api/src/router/integration/integration-router.ts

@@ -1,6 +1,8 @@
 import { TRPCError } from "@trpc/server";
 import { z } from "zod/v4";
 
+import { hasQueryAccessToIntegrationsAsync } from "@homarr/auth/server";
+import { constructIntegrationPermissions } from "@homarr/auth/shared";
 import { createId, objectEntries } from "@homarr/common";
 import { decryptSecret, encryptSecret } from "@homarr/common/server";
 import { createLogger } from "@homarr/core/infrastructure/logs";
@@ -14,11 +16,9 @@ import {
   integrations,
   integrationSecrets,
   integrationUserPermissions,
-  searchEngines,
 } from "@homarr/db/schema";
 import type { IntegrationSecretKind } from "@homarr/definitions";
 import {
-  getIconUrl,
   getIntegrationKindsByCategory,
   getPermissionsWithParents,
   integrationCategories,
@@ -33,6 +33,7 @@ import {
   integrationSavePermissionsSchema,
   integrationUpdateSchema,
 } from "@homarr/validation/integration";
+import { mediaRequestOptionsSchema, mediaRequestRequestSchema } from "@homarr/validation/widgets/media-request";
 
 import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, permissionRequiredProcedure, protectedProcedure, publicProcedure } from "../../trpc";
@@ -41,6 +42,7 @@ import { MissingSecretError, testConnectionAsync } from "./integration-test-conn
 import { mapTestConnectionError } from "./map-test-connection-error";
 
 const logger = createLogger({ module: "integrationRouter" });
+const mediaRequestSearchKinds = getIntegrationKindsByCategory("mediaSearch");
 
 export const integrationRouter = createTRPCRouter({
   all: protectedProcedure.query(async ({ ctx }) => {
@@ -80,7 +82,7 @@ export const integrationRouter = createTRPCRouter({
           },
         };
       })
-      .sort(
+      .toSorted(
         (integrationA, integrationB) =>
           integrationKinds.indexOf(integrationA.kind) - integrationKinds.indexOf(integrationB.kind),
       );
@@ -128,7 +130,7 @@ export const integrationRouter = createTRPCRouter({
           },
         };
       })
-      .sort(
+      .toSorted(
         (integrationA, integrationB) =>
           integrationKinds.indexOf(integrationA.kind) - integrationKinds.indexOf(integrationB.kind),
       );
@@ -179,7 +181,7 @@ export const integrationRouter = createTRPCRouter({
             },
           };
         })
-        .sort(
+        .toSorted(
           (integrationA, integrationB) =>
             integrationKinds.indexOf(integrationA.kind) - integrationKinds.indexOf(integrationB.kind),
         );
@@ -314,20 +316,7 @@ export const integrationRouter = createTRPCRouter({
         url: input.url,
       });
 
-      if (
-        input.attemptSearchEngineCreation &&
-        integrationDefs[input.kind].category.flatMap((category) => category).includes("search")
-      ) {
-        const icon = getIconUrl(input.kind);
-        await ctx.db.insert(searchEngines).values({
-          id: createId(),
-          name: input.name,
-          integrationId,
-          type: "fromIntegration",
-          iconUrl: icon,
-          short: await getNextValidShortNameForSearchEngineAsync(ctx.db, input.name),
-        });
-      }
+      // Media request search is a first-class Spotlight action. Do not create a search engine for it.
     }),
   update: protectedProcedure.input(integrationUpdateSchema).mutation(async ({ ctx, input }) => {
     await throwIfActionForbiddenAsync(ctx, eq(integrations.id, input.id), "full");
@@ -495,7 +484,7 @@ export const integrationRouter = createTRPCRouter({
     });
 
     return {
-      inherited: dbGroupPermissions.sort((permissionA, permissionB) => {
+      inherited: dbGroupPermissions.toSorted((permissionA, permissionB) => {
         return permissionA.group.name.localeCompare(permissionB.group.name);
       }),
       users: userPermissions
@@ -503,7 +492,7 @@ export const integrationRouter = createTRPCRouter({
           user,
           permission,
         }))
-        .sort((permissionA, permissionB) => {
+        .toSorted((permissionA, permissionB) => {
           return (permissionA.user.name ?? "").localeCompare(permissionB.user.name ?? "");
         }),
       groups: dbGroupIntegrationPermission
@@ -514,7 +503,7 @@ export const integrationRouter = createTRPCRouter({
           },
           permission,
         }))
-        .sort((permissionA, permissionB) => {
+        .toSorted((permissionA, permissionB) => {
           return permissionA.group.name.localeCompare(permissionB.group.name);
         }),
     };
@@ -618,8 +607,149 @@ export const integrationRouter = createTRPCRouter({
       const integrationInstance = await createIntegrationAsync(ctx.integration);
       return await integrationInstance.searchAsync(encodeURI(input.query));
     }),
+  mediaRequestSearchTargets: protectedProcedure.query(async ({ ctx }) => {
+    const integrationsWithAccess = await getAccessibleMediaRequestSearchIntegrationsAsync(ctx);
+
+    return integrationsWithAccess.map((integration) => {
+      const permissions = constructIntegrationPermissions(integration, ctx.session);
+
+      return {
+        id: integration.id,
+        name: integration.name,
+        kind: integration.kind,
+        url: integration.url,
+        permissions: {
+          hasInteractAccess: permissions.hasInteractAccess,
+        },
+      };
+    });
+  }),
+  searchMediaRequests: protectedProcedure
+    .input(
+      z.object({
+        query: z.string(),
+        integrationIds: z.array(z.string()).optional(),
+      }),
+    )
+    .query(async ({ ctx, input }) => {
+      const query = input.query.trim();
+      if (query.length === 0) return [];
+
+      const integrationsWithAccess = await getAccessibleMediaRequestSearchIntegrationsAsync(ctx, input.integrationIds);
+
+      const results = await Promise.all(
+        integrationsWithAccess.map(async (integration) => {
+          const integrationInstance = await createIntegrationAsync({
+            id: integration.id,
+            name: integration.name,
+            url: integration.url,
+            kind: integration.kind as (typeof mediaRequestSearchKinds)[number],
+            externalUrl: integration.app?.href ?? null,
+            decryptedSecrets: integration.secrets.map((secret) => ({
+              ...secret,
+              value: decryptSecret(secret.value),
+            })),
+          });
+          const permissions = constructIntegrationPermissions(integration, ctx.session);
+
+          return await integrationInstance.searchAsync(encodeURI(query)).then((searchResults) =>
+            searchResults.map((result) => ({
+              ...result,
+              integration: {
+                id: integration.id,
+                name: integration.name,
+                kind: integration.kind,
+                url: integration.url,
+                permissions: {
+                  hasInteractAccess: permissions.hasInteractAccess,
+                },
+              },
+            })),
+          );
+        }),
+      );
+
+      return results.flat();
+    }),
+  getMediaRequestOptions: protectedProcedure
+    .concat(createOneIntegrationMiddleware("query", "jellyseerr", "overseerr", "seerr"))
+    .input(mediaRequestOptionsSchema)
+    .query(async ({ ctx, input }) => {
+      const integration = await createIntegrationAsync(ctx.integration);
+      return await integration.getSeriesInformationAsync(input.mediaType, input.mediaId);
+    }),
+  requestMedia: protectedProcedure
+    .concat(createOneIntegrationMiddleware("interact", "jellyseerr", "overseerr", "seerr"))
+    .input(mediaRequestRequestSchema)
+    .mutation(async ({ ctx, input }) => {
+      const integration = await createIntegrationAsync(ctx.integration);
+      return await integration.requestMediaAsync(input.mediaType, input.mediaId, input.seasons);
+    }),
 });
 
+interface IntegrationRouterContext {
+  db: Database;
+  session: Parameters<typeof hasQueryAccessToIntegrationsAsync>[2];
+}
+
+const getAccessibleMediaRequestSearchIntegrationsAsync = async (
+  ctx: IntegrationRouterContext,
+  integrationIds?: string[],
+) => {
+  const groupsOfCurrentUser = await ctx.db.query.groupMembers.findMany({
+    where: eq(groupMembers.userId, ctx.session?.user.id ?? ""),
+  });
+
+  const integrationsFromDb = await ctx.db.query.integrations.findMany({
+    where:
+      integrationIds && integrationIds.length > 0
+        ? and(inArray(integrations.id, integrationIds), inArray(integrations.kind, mediaRequestSearchKinds))
+        : inArray(integrations.kind, mediaRequestSearchKinds),
+    orderBy: asc(integrations.name),
+    with: {
+      app: true,
+      secrets: true,
+      items: {
+        with: {
+          item: true,
+        },
+      },
+      userPermissions: {
+        where: eq(integrationUserPermissions.userId, ctx.session?.user.id ?? ""),
+      },
+      groupPermissions: {
+        where: inArray(
+          integrationGroupPermissions.groupId,
+          groupsOfCurrentUser.map((group) => group.groupId),
+        ),
+      },
+    },
+  });
+
+  if (integrationIds && integrationsFromDb.length !== integrationIds.length) {
+    throw new TRPCError({
+      code: "NOT_FOUND",
+      message: "One or more media request search integrations were not found",
+    });
+  }
+
+  const integrationsWithAccess = await Promise.all(
+    integrationsFromDb.map(async (integration) => ({
+      integration,
+      hasAccess: await hasQueryAccessToIntegrationsAsync(ctx.db, [integration], ctx.session),
+    })),
+  );
+
+  if (integrationIds && integrationsWithAccess.some(({ hasAccess }) => !hasAccess)) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "User does not have permission to query one or more media request search integrations",
+    });
+  }
+
+  return integrationsWithAccess.filter(({ hasAccess }) => hasAccess).map(({ integration }) => integration);
+};
+
 interface UpdateSecretInput {
   integrationId: string;
   value: string;
@@ -640,35 +770,6 @@ interface AddSecretInput {
   kind: IntegrationSecretKind;
 }
 
-const getNextValidShortNameForSearchEngineAsync = async (db: Database, integrationName: string) => {
-  const searchEngines = await db.query.searchEngines.findMany({
-    columns: {
-      short: true,
-    },
-  });
-
-  const usedShortNames = searchEngines.flatMap((searchEngine) => searchEngine.short.toLowerCase());
-  const nameByIntegrationName = integrationName.slice(0, 1).toLowerCase();
-
-  if (!usedShortNames.includes(nameByIntegrationName)) {
-    return nameByIntegrationName;
-  }
-
-  // 8 is max length constraint
-  for (let i = 2; i < 9999999; i++) {
-    const generatedName = `${nameByIntegrationName}${i}`;
-    if (usedShortNames.includes(generatedName)) {
-      continue;
-    }
-
-    return generatedName;
-  }
-
-  throw new Error(
-    "Unable to automatically generate a short name. All possible variations were exhausted. Please disable the automatic creation and choose one later yourself.",
-  );
-};
-
 const addSecretAsync = async (db: Database, input: AddSecretInput) => {
   await db.insert(integrationSecrets).values({
     kind: input.kind,

packages/api/src/router/search-engine/search-engine-router.ts

@@ -6,12 +6,9 @@ import { createLogger } from "@homarr/core/infrastructure/logs";
 import { asc, eq, like } from "@homarr/db";
 import { getServerSettingByKeyAsync, updateServerSettingByKeyAsync } from "@homarr/db/queries";
 import { searchEngines, users } from "@homarr/db/schema";
-import { createIntegrationAsync } from "@homarr/integrations";
 import { byIdSchema, paginatedSchema, searchSchema } from "@homarr/validation/common";
 import { searchEngineEditSchema, searchEngineManageSchema } from "@homarr/validation/search-engine";
-import { mediaRequestOptionsSchema, mediaRequestRequestSchema } from "@homarr/validation/widgets/media-request";
 
-import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, permissionRequiredProcedure, protectedProcedure, publicProcedure } from "../../trpc";
 
 const logger = createLogger({ module: "searchEngineRouter" });
@@ -148,20 +145,6 @@ export const searchEngineRouter = createTRPCRouter({
       limit: input.limit,
     });
   }),
-  getMediaRequestOptions: protectedProcedure
-    .concat(createOneIntegrationMiddleware("query", "jellyseerr", "overseerr"))
-    .input(mediaRequestOptionsSchema)
-    .query(async ({ ctx, input }) => {
-      const integration = await createIntegrationAsync(ctx.integration);
-      return await integration.getSeriesInformationAsync(input.mediaType, input.mediaId);
-    }),
-  requestMedia: protectedProcedure
-    .concat(createOneIntegrationMiddleware("interact", "jellyseerr", "overseerr"))
-    .input(mediaRequestRequestSchema)
-    .mutation(async ({ ctx, input }) => {
-      const integration = await createIntegrationAsync(ctx.integration);
-      return await integration.requestMediaAsync(input.mediaType, input.mediaId, input.seasons);
-    }),
   create: permissionRequiredProcedure
     .requiresPermission("search-engine-create")
     .input(searchEngineManageSchema)

packages/api/src/router/test/integration/integration-router.spec.ts

@@ -4,7 +4,7 @@ import { describe, expect, test, vi } from "vitest";
 import type { Session } from "@homarr/auth";
 import { createId } from "@homarr/common";
 import { encryptSecret } from "@homarr/common/server";
-import { apps, integrations, integrationSecrets } from "@homarr/db/schema";
+import { apps, integrations, integrationSecrets, integrationUserPermissions, users } from "@homarr/db/schema";
 import { createDb } from "@homarr/db/test";
 import type { GroupPermissionKey } from "@homarr/definitions";
 
@@ -59,6 +59,127 @@ describe("all should return all integrations", () => {
   });
 });
 
+describe("mediaRequestSearchTargets should return accessible media search integrations", () => {
+  test("with integration use access should only return media request search integrations", async () => {
+    const db = createDb();
+    const caller = integrationRouter.createCaller({
+      db,
+      deviceType: undefined,
+      session: defaultSessionWithPermissions(["integration-use-all"]),
+    });
+
+    await db.insert(integrations).values([
+      {
+        id: "1",
+        name: "Jellyseerr",
+        kind: "jellyseerr",
+        url: "http://jellyseerr.local",
+      },
+      {
+        id: "2",
+        name: "Jellyfin",
+        kind: "jellyfin",
+        url: "http://jellyfin.local",
+      },
+    ]);
+
+    const result = await caller.mediaRequestSearchTargets();
+
+    expect(result).toHaveLength(1);
+    expect(result[0]!.id).toBe("1");
+    expect(result[0]!.kind).toBe("jellyseerr");
+  });
+
+  test("without access should not return media request search integrations", async () => {
+    const db = createDb();
+    const caller = integrationRouter.createCaller({
+      db,
+      deviceType: undefined,
+      session: defaultSessionWithPermissions(),
+    });
+
+    await db.insert(integrations).values({
+      id: "1",
+      name: "Jellyseerr",
+      kind: "jellyseerr",
+      url: "http://jellyseerr.local",
+    });
+
+    const result = await caller.mediaRequestSearchTargets();
+
+    expect(result).toHaveLength(0);
+  });
+
+  test("with direct integration use access should return media request search integrations", async () => {
+    const db = createDb();
+    const caller = integrationRouter.createCaller({
+      db,
+      deviceType: undefined,
+      session: defaultSessionWithPermissions(),
+    });
+
+    await db.insert(integrations).values({
+      id: "1",
+      name: "Jellyseerr",
+      kind: "jellyseerr",
+      url: "http://jellyseerr.local",
+    });
+    await db.insert(users).values({ id: defaultUserId });
+    await db.insert(integrationUserPermissions).values({
+      integrationId: "1",
+      userId: defaultUserId,
+      permission: "use",
+    });
+
+    const result = await caller.mediaRequestSearchTargets();
+
+    expect(result).toHaveLength(1);
+    expect(result[0]!.id).toBe("1");
+  });
+});
+
+describe("searchMediaRequests should validate scoped integrations", () => {
+  test("with a non media search integration should throw not found", async () => {
+    const db = createDb();
+    const caller = integrationRouter.createCaller({
+      db,
+      deviceType: undefined,
+      session: defaultSessionWithPermissions(["integration-use-all"]),
+    });
+
+    await db.insert(integrations).values({
+      id: "1",
+      name: "Jellyfin",
+      kind: "jellyfin",
+      url: "http://jellyfin.local",
+    });
+
+    await expect(caller.searchMediaRequests({ query: "matrix", integrationIds: ["1"] })).rejects.toThrow(
+      "One or more media request search integrations were not found",
+    );
+  });
+
+  test("without query access to a scoped media search integration should throw forbidden", async () => {
+    const db = createDb();
+    const caller = integrationRouter.createCaller({
+      db,
+      deviceType: undefined,
+      session: defaultSessionWithPermissions(),
+    });
+
+    await db.insert(integrations).values({
+      id: "1",
+      name: "Jellyseerr",
+      kind: "jellyseerr",
+      url: "http://jellyseerr.local",
+    });
+
+    await expect(caller.searchMediaRequests({ query: "matrix", integrationIds: ["1"] })).rejects.toThrow(
+      "User does not have permission to query one or more media request search integrations",
+    );
+  });
+});
+
 describe("byId should return an integration by id", () => {
   test("with full access should return an integration by id", async () => {
     const db = createDb();
@@ -208,7 +329,7 @@ describe("create should create a new integration", () => {
     expect(dbSecret!.updatedAt).toEqual(fakeNow);
   });
 
-  test("with create integration access should create a new integration when creating search engine", async () => {
+  test("with create integration access should not create a search engine for media request search integrations", async () => {
     const db = createDb();
     const caller = integrationRouter.createCaller({
       db,
@@ -243,12 +364,7 @@ describe("create should create a new integration", () => {
     expect(dbSecret!.value).toMatch(/^[a-f0-9]+.[a-f0-9]+$/);
     expect(dbSecret!.updatedAt).toEqual(fakeNow);
 
-    expect(dbSearchEngine!.integrationId).toBe(dbIntegration!.id);
-    expect(dbSearchEngine!.short).toBe("j");
-    expect(dbSearchEngine!.name).toBe(input.name);
-    expect(dbSearchEngine!.iconUrl).toBe(
-      "https://cdn.jsdelivr.net/gh/homarr-labs/dashboard-icons@master/svg/jellyseerr.svg",
-    );
+    expect(dbSearchEngine).toBeUndefined();
   });
 
   test("with create integration access should create a new integration with new linked app", async () => {

packages/api/src/router/test/user.spec.ts

@@ -81,7 +81,13 @@ describe("initUser should initialize the first user", () => {
     await expect(actAsync()).rejects.toThrow("passwordsDoNotMatch");
   });
 
-  it.each([["aB2%"], ["short"]])("should reject passwords shorter than 8 characters for '%s'", async (password) => {
+  it.each([
+    ["aB2%"], // too short
+    ["abc123DEF"], // does not contain special characters
+    ["abcDEFghi+"], // does not contain numbers
+    ["ABC123+/-"], // does not contain lowercase
+    ["abc123+/-"], // does not contain uppercase
+  ])("should throw error that password requirements do not match for '%s' as password", async (password) => {
     const db = createDb();
     await createOnboardingStepAsync(db, "user");
     const caller = userRouter.createCaller({
@@ -97,55 +103,7 @@ describe("initUser should initialize the first user", () => {
         confirmPassword: password,
       });
 
-    await expect(actAsync()).rejects.toThrow();
-  });
-
-  it("should accept passwords without complexity requirements", async () => {
-    const db = createDb();
-    await createOnboardingStepAsync(db, "user");
-    const caller = userRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: null,
-    });
-
-    await caller.initUser({
-      username: "test",
-      password: "abc123DEF",
-      confirmPassword: "abc123DEF",
-    });
-
-    const user = await db.query.users.findFirst({
-      columns: {
-        id: true,
-      },
-    });
-
-    expect(user).toBeDefined();
-  });
-
-  it("should accept passwords with special characters like LoveHomarr<3", async () => {
-    const db = createDb();
-    await createOnboardingStepAsync(db, "user");
-    const caller = userRouter.createCaller({
-      db,
-      deviceType: undefined,
-      session: null,
-    });
-
-    await caller.initUser({
-      username: "test",
-      password: "LoveHomarr<3",
-      confirmPassword: "LoveHomarr<3",
-    });
-
-    const user = await db.query.users.findFirst({
-      columns: {
-        id: true,
-      },
-    });
-
-    expect(user).toBeDefined();
+    await expect(actAsync()).rejects.toThrow("passwordRequirements");
   });
 });
 

packages/cron-jobs/src/jobs/integrations/media-requests.ts

@@ -14,7 +14,9 @@ export const mediaRequestStatsJob = createCronJob("mediaRequestStats", EVERY_MIN
   }),
 );
 
-export const mediaRequestListJob = createCronJob("mediaRequestList", EVERY_MINUTE).withCallback(
+export const mediaRequestListJob = createCronJob("mediaRequestList", EVERY_MINUTE, {
+  expectedMaximumDurationInMillis: 15_000,
+}).withCallback(
   createRequestIntegrationJobHandler(mediaRequestListRequestHandler.handler, {
     widgetKinds: ["mediaRequests-requestList"],
     getInput: {

packages/forms-collection/src/index.tsx

@@ -5,5 +5,3 @@ export * from "./icon-picker/icon-picker";
 export * from "./new-app/icon-matcher";
 
 export * from "./upload-media/upload-media";
-
-export * from "./user-create/user-create-password-fields";

packages/forms-collection/src/user-create/user-create-password-fields.tsx

@@ -1,33 +0,0 @@
-"use client";
-
-import { PasswordInput, Stack } from "@mantine/core";
-import type { PasswordInputProps } from "@mantine/core";
-
-import { useScopedI18n } from "@homarr/translation/client";
-import { CustomPasswordInput } from "@homarr/ui";
-
-interface UserCreatePasswordFieldsProps {
-  passwordInputProps: PasswordInputProps;
-  confirmPasswordInputProps: PasswordInputProps;
-  variant?: PasswordInputProps["variant"];
-}
-
-export const UserCreatePasswordFields = ({
-  passwordInputProps,
-  confirmPasswordInputProps,
-  variant,
-}: UserCreatePasswordFieldsProps) => {
-  const t = useScopedI18n("user.field");
-
-  return (
-    <Stack gap="md">
-      <CustomPasswordInput
-        withPasswordRequirements
-        label={t("password.label")}
-        variant={variant}
-        {...passwordInputProps}
-      />
-      <PasswordInput label={t("passwordConfirm.label")} variant={variant} {...confirmPasswordInputProps} />
-    </Stack>
-  );
-};

packages/integrations/src/interfaces/media-requests/media-request-types.ts

@@ -12,12 +12,14 @@ interface SeriesInformation {
   overview: string;
   seasons: SerieSeason[];
   posterPath: string;
+  requestedSeasons: number[];
 }
 
 interface MovieInformation {
   id: number;
   overview: string;
   posterPath: string;
+  requestedSeasons: number[];
 }
 
 export type MediaInformation = SeriesInformation | MovieInformation;

packages/integrations/src/overseerr/overseerr-integration.ts

@@ -1,6 +1,10 @@
 import { z } from "zod/v4";
+import type { RequestInit, Response } from "undici";
+import { fetch } from "undici";
 
-import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http";
+import { splitToChunksWithNItems } from "@homarr/common";
+import { createCertificateAgentAsync } from "@homarr/core/infrastructure/http";
+import { withTimeoutAsync } from "@homarr/core/infrastructure/http/timeout";
 import { createLogger } from "@homarr/core/infrastructure/logs";
 import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
 
@@ -24,6 +28,14 @@ import {
 
 const logger = createLogger({ module: "overseerrIntegration" });
 
+const REQUEST_TIMEOUT_MS = 10_000;
+const DETAIL_FETCH_BATCH_SIZE = 5;
+
+interface OverseerrFetchClient {
+  fetchAsync: (url: URL, init?: RequestInit) => Promise<Response>;
+  fetchUncheckedAsync: (url: URL, init?: RequestInit) => Promise<Response>;
+}
+
 interface OverseerrSearchResult {
   id: number;
   name: string;
@@ -40,12 +52,43 @@ export class OverseerrIntegration
   extends Integration
   implements IMediaRequestIntegration, ISearchableIntegration<OverseerrSearchResult>
 {
-  public async searchAsync(query: string) {
-    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/v1/search", { query }), {
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
+  private async createFetchClientAsync(): Promise<OverseerrFetchClient> {
+    const agent = await createCertificateAgentAsync(undefined);
+    const apiKey = this.getSecretValue("apiKey");
+
+    const requestAsync = async (url: URL, init?: RequestInit) => {
+      return await withTimeoutAsync(
+        (signal) =>
+          fetch(url, {
+            ...init,
+            signal,
+            dispatcher: agent,
+            headers: {
+              "X-Api-Key": apiKey,
+              ...init?.headers,
+            },
+          }),
+        REQUEST_TIMEOUT_MS,
+      );
+    };
+
+    return {
+      fetchAsync: async (url, init) => {
+        const response = await requestAsync(url, init);
+
+        if (!response.ok) {
+          throw new Error(`Overseerr request failed: ${response.status} ${response.statusText} (${url.toString()})`);
+        }
+
+        return response;
       },
-    });
+      fetchUncheckedAsync: requestAsync,
+    };
+  }
+
+  public async searchAsync(query: string) {
+    const client = await this.createFetchClientAsync();
+    const response = await client.fetchAsync(this.url("/api/v1/search", { query }));
     const schemaData = await searchSchema.parseAsync(await response.json());
 
     if (!schemaData.results) {
@@ -60,17 +103,22 @@ export class OverseerrIntegration
       text: "overview" in result ? result.overview : undefined,
       type: result.mediaType,
       inLibrary: result.mediaInfo !== undefined,
+      availability: result.mediaInfo
+        ? this.mapAvailability(result.mediaInfo.status as UpstreamMediaAvailability, false)
+        : undefined,
     }));
   }
 
   public async getSeriesInformationAsync(mediaType: "movie" | "tv", id: number) {
+    const client = await this.createFetchClientAsync();
     const url = mediaType === "tv" ? this.url(`/api/v1/tv/${id}`) : this.url(`/api/v1/movie/${id}`);
-    const response = await fetchWithTrustedCertificatesAsync(url, {
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    });
-    return await mediaInformationSchema.parseAsync(await response.json());
+    const response = await client.fetchAsync(url);
+    const data = await mediaInformationSchema.parseAsync(await response.json());
+    const requestedSeasons = [
+      ...new Set(data.mediaInfo?.requests?.flatMap((req) => req.seasons.map((s) => s.seasonNumber)) ?? []),
+    ];
+    const { mediaInfo: _strip, ...rest } = data;
+    return { ...rest, requestedSeasons };
   }
 
   /**
@@ -80,8 +128,9 @@ export class OverseerrIntegration
    * @param seasons A list of the seasons that should be requested.
    */
   public async requestMediaAsync(mediaType: "movie" | "tv", id: number, seasons?: number[]): Promise<void> {
+    const client = await this.createFetchClientAsync();
     const url = this.url("/api/v1/request");
-    const response = await fetchWithTrustedCertificatesAsync(url, {
+    const response = await client.fetchUncheckedAsync(url, {
       method: "POST",
       body: JSON.stringify({
         mediaType,
@@ -89,7 +138,6 @@ export class OverseerrIntegration
         seasons,
       }),
       headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
         "Content-Type": "application/json",
       },
     });
@@ -115,25 +163,16 @@ export class OverseerrIntegration
   }
 
   public async getRequestsAsync(): Promise<MediaRequest[]> {
-    const pendingRequests = await fetchWithTrustedCertificatesAsync(
-      this.url("/api/v1/request", { take: 20, filter: "pending" }),
-      {
-        headers: {
-          "X-Api-Key": this.getSecretValue("apiKey"),
-        },
-      },
-    );
+    const client = await this.createFetchClientAsync();
 
-    const allRequests = await fetchWithTrustedCertificatesAsync(this.url("/api/v1/request", { take: 20 }), {
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    });
+    const [pendingResponse, allResponse] = await Promise.all([
+      client.fetchAsync(this.url("/api/v1/request", { take: 20, filter: "pending" })),
+      client.fetchAsync(this.url("/api/v1/request", { take: 20 })),
+    ]);
 
-    const pendingResults = (await getRequestsSchema.parseAsync(await pendingRequests.json())).results;
-    const allResults = (await getRequestsSchema.parseAsync(await allRequests.json())).results;
+    const pendingResults = (await getRequestsSchema.parseAsync(await pendingResponse.json())).results;
+    const allResults = (await getRequestsSchema.parseAsync(await allResponse.json())).results;
 
-    //Concat the 2 lists while remove any duplicate pending from the all items list
     let requests;
 
     if (pendingResults.length > 0 && allResults.length > 0) {
@@ -142,37 +181,53 @@ export class OverseerrIntegration
       );
     } else if (pendingResults.length > 0) requests = pendingResults;
     else if (allResults.length > 0) requests = allResults;
-    else return Promise.all([]);
+    else return [];
 
-    return await Promise.all(
-      requests.map(async (request): Promise<MediaRequest> => {
-        const information = await this.getItemInformationAsync(request.media.tmdbId, request.type);
+    const uniqueKeys = [...new Set(requests.map((request) => `${request.type}:${request.media.tmdbId}`))];
+    const informationByKey = new Map<string, MediaInformation>();
 
-        // See https://github.com/seerr-team/seerr/blob/af083a3cd5c3e3d5d7917fdf4fdd67fe3f39c46b/src/components/StatusBadge/index.tsx#L40
-        const inProgress = (request.media.downloadStatus ?? []).length >= 1;
+    for (const batch of splitToChunksWithNItems(uniqueKeys, DETAIL_FETCH_BATCH_SIZE)) {
+      const batchResults = await Promise.all(
+        batch.map(async (key) => {
+          const separatorIndex = key.indexOf(":");
+          const type = key.slice(0, separatorIndex) as MediaRequest["type"];
+          const tmdbId = Number(key.slice(separatorIndex + 1));
+          const information = await this.getItemInformationAsync(client, type, tmdbId);
+          return [key, information] as const;
+        }),
+      );
 
-        return {
-          id: request.id,
-          name: information.name,
-          status: this.mapRequestStatus(request.status),
-          availability: this.mapAvailability(request.media.status, inProgress),
-          backdropImageUrl: `https://image.tmdb.org/t/p/original/${information.backdropPath}`,
-          posterImagePath: `https://image.tmdb.org/t/p/w600_and_h900_bestv2/${information.posterPath}`,
-          href: this.externalUrl(`/${request.type}/${request.media.tmdbId}`).toString(),
-          type: request.type,
-          createdAt: request.createdAt,
-          airDate: new Date(information.airDate),
-          requestedBy: request.requestedBy
-            ? ({
-                ...request.requestedBy,
-                displayName: request.requestedBy.displayName,
-                link: this.externalUrl(`/users/${request.requestedBy.id}`).toString(),
-                avatar: this.constructAvatarUrl(request.requestedBy.avatar).toString(),
-              } satisfies Omit<RequestUser, "requestCount">)
-            : undefined,
-        };
-      }),
-    );
+      for (const [key, information] of batchResults) {
+        informationByKey.set(key, information);
+      }
+    }
+
+    return requests.map((request): MediaRequest => {
+      const information = informationByKey.get(`${request.type}:${request.media.tmdbId}`)!;
+
+      const inProgress = (request.media.downloadStatus ?? []).length >= 1;
+
+      return {
+        id: request.id,
+        name: information.name,
+        status: this.mapRequestStatus(request.status),
+        availability: this.mapAvailability(request.media.status, inProgress),
+        backdropImageUrl: `https://image.tmdb.org/t/p/original/${information.backdropPath}`,
+        posterImagePath: `https://image.tmdb.org/t/p/w600_and_h900_bestv2/${information.posterPath}`,
+        href: this.externalUrl(`/${request.type}/${request.media.tmdbId}`).toString(),
+        type: request.type,
+        createdAt: request.createdAt,
+        airDate: new Date(information.airDate),
+        requestedBy: request.requestedBy
+          ? ({
+              ...request.requestedBy,
+              displayName: request.requestedBy.displayName,
+              link: this.externalUrl(`/users/${request.requestedBy.id}`).toString(),
+              avatar: this.constructAvatarUrl(request.requestedBy.avatar).toString(),
+            } satisfies Omit<RequestUser, "requestCount">)
+          : undefined,
+      };
+    });
   }
 
   protected mapRequestStatus(status: UpstreamMediaRequestStatus): MediaRequestStatus {
@@ -212,20 +267,14 @@ export class OverseerrIntegration
   }
 
   public async getStatsAsync(): Promise<RequestStats> {
-    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/v1/request/count"), {
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    });
+    const client = await this.createFetchClientAsync();
+    const response = await client.fetchAsync(this.url("/api/v1/request/count"));
     return await getStatsSchema.parseAsync(await response.json());
   }
 
   public async getUsersAsync(): Promise<RequestUser[]> {
-    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/v1/user", { take: 10, sort: "requests" }), {
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    });
+    const client = await this.createFetchClientAsync();
+    const response = await client.fetchAsync(this.url("/api/v1/user", { take: 10, sort: "requests" }));
     const users = (await getUsersSchema.parseAsync(await response.json())).results;
     return users.map((user): RequestUser => {
       return {
@@ -238,75 +287,58 @@ export class OverseerrIntegration
 
   public async approveRequestAsync(requestId: number): Promise<void> {
     logger.info("Approving media request", { requestId, integration: this.integration.name });
-    await fetchWithTrustedCertificatesAsync(this.url(`/api/v1/request/${requestId}/approve`), {
-      method: "POST",
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    }).then((response) => {
-      if (!response.ok) {
-        logger.error(
-          new ErrorWithMetadata("Failed to approve media request", {
-            requestId,
-            integration: this.integration.name,
-            reason: `${response.status} ${response.statusText}`,
-            url: response.url,
-          }),
-        );
-      }
+    const client = await this.createFetchClientAsync();
+    await client
+      .fetchUncheckedAsync(this.url(`/api/v1/request/${requestId}/approve`), {
+        method: "POST",
+      })
+      .then((response) => {
+        if (!response.ok) {
+          logger.error(
+            new ErrorWithMetadata("Failed to approve media request", {
+              requestId,
+              integration: this.integration.name,
+              reason: `${response.status} ${response.statusText}`,
+              url: response.url,
+            }),
+          );
+        }
 
-      logger.info("Successfully approved media request", { requestId, integration: this.integration.name });
-    });
+        logger.info("Successfully approved media request", { requestId, integration: this.integration.name });
+      });
   }
 
   public async declineRequestAsync(requestId: number): Promise<void> {
     logger.info("Declining media request", { requestId, integration: this.integration.name });
+    const client = await this.createFetchClientAsync();
+    await client
+      .fetchUncheckedAsync(this.url(`/api/v1/request/${requestId}/decline`), {
+        method: "POST",
+      })
+      .then((response) => {
+        if (!response.ok) {
+          logger.error(
+            new ErrorWithMetadata("Failed to decline media request", {
+              requestId,
+              integration: this.integration.name,
+              reason: `${response.status} ${response.statusText}`,
+              url: response.url,
+            }),
+          );
+        }
 
-    await fetchWithTrustedCertificatesAsync(this.url(`/api/v1/request/${requestId}/decline`), {
-      method: "POST",
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    }).then((response) => {
-      if (!response.ok) {
-        logger.error(
-          new ErrorWithMetadata("Failed to decline media request", {
-            requestId,
-            integration: this.integration.name,
-            reason: `${response.status} ${response.statusText}`,
-            url: response.url,
-          }),
-        );
-      }
-
-      logger.info("Successfully declined media request", { requestId, integration: this.integration.name });
-    });
+        logger.info("Successfully declined media request", { requestId, integration: this.integration.name });
+      });
   }
 
-  private async getItemInformationAsync(id: number, type: MediaRequest["type"]): Promise<MediaInformation> {
-    const response = await fetchWithTrustedCertificatesAsync(this.url(`/api/v1/${type}/${id}`), {
-      headers: {
-        "X-Api-Key": this.getSecretValue("apiKey"),
-      },
-    });
-
-    if (type === "tv") {
-      const series = (await response.json()) as TvInformation;
-      return {
-        name: series.name,
-        backdropPath: series.backdropPath ?? series.posterPath,
-        posterPath: series.posterPath ?? series.backdropPath,
-        airDate: series.firstAirDate,
-      } satisfies MediaInformation;
-    }
-
-    const movie = (await response.json()) as MovieInformation;
-    return {
-      name: movie.title,
-      backdropPath: movie.backdropPath ?? movie.posterPath,
-      posterPath: movie.posterPath ?? movie.backdropPath,
-      airDate: movie.releaseDate,
-    } satisfies MediaInformation;
+  private async getItemInformationAsync(
+    client: OverseerrFetchClient,
+    type: MediaRequest["type"],
+    id: number,
+  ): Promise<MediaInformation> {
+    const response = await client.fetchAsync(this.url(`/api/v1/${type}/${id}`));
+    const rawData = (await response.json()) as TvInformation | MovieInformation;
+    return mediaInformationFromResponse[type](rawData as never);
   }
 
   private constructAvatarUrl(avatar: string) {
@@ -341,6 +373,37 @@ interface MovieInformation {
   releaseDate: string;
 }
 
+const mediaInformationFromResponse = {
+  tv: (series: TvInformation): MediaInformation => ({
+    name: series.name,
+    backdropPath: series.backdropPath ?? series.posterPath,
+    posterPath: series.posterPath ?? series.backdropPath,
+    airDate: series.firstAirDate,
+  }),
+  movie: (movie: MovieInformation): MediaInformation => ({
+    name: movie.title,
+    backdropPath: movie.backdropPath ?? movie.posterPath,
+    posterPath: movie.posterPath ?? movie.backdropPath,
+    airDate: movie.releaseDate,
+  }),
+} satisfies Record<MediaRequest["type"], (data: TvInformation | MovieInformation) => MediaInformation>;
+
+const mediaInfoRequestsSchema = z
+  .object({
+    requests: z
+      .array(
+        z.object({
+          seasons: z.array(
+            z.object({
+              seasonNumber: z.number(),
+            }),
+          ),
+        }),
+      )
+      .optional(),
+  })
+  .optional();
+
 const mediaInformationSchema = z.union([
   z.object({
     id: z.number(),
@@ -355,14 +418,22 @@ const mediaInformationSchema = z.union([
     ),
     numberOfSeasons: z.number(),
     posterPath: z.string().startsWith("/"),
+    mediaInfo: mediaInfoRequestsSchema,
   }),
   z.object({
     id: z.number(),
     overview: z.string(),
     posterPath: z.string().startsWith("/"),
+    mediaInfo: mediaInfoRequestsSchema,
   }),
 ]);
 
+const searchMediaInfoSchema = z
+  .object({
+    status: z.number(),
+  })
+  .optional();
+
 const searchSchema = z.object({
   results: z
     .array(
@@ -373,7 +444,7 @@ const searchSchema = z.object({
           name: z.string(),
           posterPath: z.string().startsWith("/").endsWith(".jpg").nullable(),
           overview: z.string(),
-          mediaInfo: z.object({}).optional(),
+          mediaInfo: searchMediaInfoSchema,
         }),
         z.object({
           id: z.number(),
@@ -381,14 +452,14 @@ const searchSchema = z.object({
           title: z.string(),
           posterPath: z.string().startsWith("/").endsWith(".jpg").nullable(),
           overview: z.string(),
-          mediaInfo: z.object({}).optional(),
+          mediaInfo: searchMediaInfoSchema,
         }),
         z.object({
           id: z.number(),
           mediaType: z.literal("person"),
           name: z.string(),
           profilePath: z.string().startsWith("/").endsWith(".jpg").nullable(),
-          mediaInfo: z.object({}).optional(),
+          mediaInfo: searchMediaInfoSchema,
         }),
       ]),
     )

packages/modals-collection/src/search-engines/request-media-modal.tsx

@@ -1,6 +1,6 @@
 import { useMemo } from "react";
-import { Button, Group, Image, LoadingOverlay, Stack, Text } from "@mantine/core";
-import type { MRT_ColumnDef } from "mantine-react-table";
+import { Badge, Button, Group, Image, LoadingOverlay, Stack, Text } from "@mantine/core";
+import type { MRT_ColumnDef, MRT_Row } from "mantine-react-table";
 import { MRT_Table } from "mantine-react-table";
 
 import { clientApi } from "@homarr/api/client";
@@ -16,13 +16,13 @@ interface RequestMediaModalProps {
 }
 
 export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions, innerProps }) => {
-  const { data, isPending: isPendingQuery } = clientApi.searchEngine.getMediaRequestOptions.useQuery({
+  const { data, isPending: isPendingQuery } = clientApi.integration.getMediaRequestOptions.useQuery({
     integrationId: innerProps.integrationId,
     mediaId: innerProps.mediaId,
     mediaType: innerProps.mediaType,
   });
 
-  const { mutate, isPending: isPendingMutation } = clientApi.searchEngine.requestMedia.useMutation({
+  const { mutate, isPending: isPendingMutation } = clientApi.integration.requestMedia.useMutation({
     onSuccess() {
       actions.closeModal();
       showSuccessNotification({
@@ -33,6 +33,7 @@ export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions,
 
   const isPending = isPendingQuery || isPendingMutation;
   const t = useI18n();
+  const requestedSeasons = new Set(data?.requestedSeasons ?? []);
 
   const columns = useMemo<MRT_ColumnDef<Season>[]>(
     () => [
@@ -44,8 +45,18 @@ export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions,
         accessorKey: "episodeCount",
         header: t("search.engine.media.request.modal.table.header.episodes"),
       },
+      {
+        id: "status",
+        header: t("search.engine.media.request.modal.table.header.status"),
+        Cell: ({ row }) =>
+          requestedSeasons.has(row.original.seasonNumber) ? (
+            <Badge size="xs" color="violet" variant="light">
+              {t("search.engine.media.request.modal.table.status.requested")}
+            </Badge>
+          ) : null,
+      },
     ],
-    [],
+    [data?.requestedSeasons],
   );
 
   const table = useTranslatedMantineReactTable({
@@ -56,7 +67,7 @@ export const RequestMediaModal = createModal<RequestMediaModalProps>(({ actions,
     enablePagination: false,
     enableSorting: false,
     enableSelectAll: true,
-    enableRowSelection: true,
+    enableRowSelection: (row: MRT_Row<Season>) => !requestedSeasons.has(row.original.seasonNumber),
     mantineTableProps: {
       highlightOnHover: false,
       striped: "odd",

packages/old-import/src/widgets/options.ts

@@ -44,7 +44,6 @@ const optionMapping: OptionMapping = {
     hideIcon: (oldOptions) => oldOptions.items.some((item) => item.hideIcon),
     hideHostname: (oldOptions) => oldOptions.items.some((item) => item.hideHostname),
     openNewTab: (oldOptions) => oldOptions.items.some((item) => item.openNewTab),
-    withBorder: () => undefined,
   },
   calendar: {
     releaseType: (oldOptions) => [oldOptions.radarrReleaseType],

packages/spotlight/src/components/actions/items/group-action-item.tsx

@@ -44,6 +44,9 @@ export const SpotlightGroupActionItem = <TOption extends Record<string, unknown>
       setQuery(interaction.query);
       setTimeout(() => selectAction(0, spotlightStore));
     } else if (interaction.type === "mode") {
+      if (interaction.query !== undefined) {
+        setQuery(interaction.query);
+      }
       setMode(interaction.mode);
     } else if (interaction.type === "children") {
       setChildrenOptions(interaction);

packages/spotlight/src/components/spotlight.tsx

@@ -1,20 +1,28 @@
 "use client";
 
 import type { Dispatch, SetStateAction } from "react";
-import { useMemo, useRef, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { ActionIcon, Center, Group, Kbd } from "@mantine/core";
 import { Spotlight as MantineSpotlight } from "@mantine/spotlight";
 import { IconSearch, IconX } from "@tabler/icons-react";
+import { useSetAtom } from "jotai";
 
 import { hotkeys } from "@homarr/definitions";
 import type { TranslationObject } from "@homarr/translation";
 import { useI18n } from "@homarr/translation/client";
 
+import type { OpenMediaRequestSearchOptions } from "../index";
 import type { inferSearchInteractionOptions } from "../lib/interaction";
 import type { SearchMode } from "../lib/mode";
 import { searchModes } from "../modes";
 import { useHomeEmptyGroups } from "../modes/help/home-empty-groups";
-import { selectAction, spotlightStore } from "../spotlight-store";
+import {
+  mediaRequestSearchEvent,
+  mediaRequestSearchScopeAtom,
+  selectAction,
+  spotlightActions,
+  spotlightStore,
+} from "../spotlight-store";
 import { SpotlightChildrenActions } from "./actions/children-actions";
 import { SpotlightActionGroups } from "./actions/groups/action-group";
 
@@ -49,10 +57,35 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
   const [childrenOptions, setChildrenOptions] = useState<inferSearchInteractionOptions<"children"> | null>(null);
   const t = useI18n();
   const inputRef = useRef<HTMLInputElement>(null);
+  const setMediaRequestSearchScope = useSetAtom(mediaRequestSearchScopeAtom);
   // Works as always the same amount of hooks are executed
   const useGroups = "groups" in activeMode ? () => activeMode.groups : activeMode.useGroups;
   const groups = useGroups();
   const homeEmptyGroups = useHomeEmptyGroups();
+  const hasModeCharacter = activeMode.modeKey !== defaultMode && activeMode.character !== undefined;
+
+  useEffect(() => {
+    const handleMediaRequestSearch = (event: Event) => {
+      const { integrationIds, query } = (event as CustomEvent<OpenMediaRequestSearchOptions>).detail ?? {};
+      setMediaRequestSearchScope({ integrationIds });
+      setMode("media");
+      setChildrenOptions(null);
+      setQuery(query ?? "");
+      spotlightActions.open();
+      setTimeout(() => selectAction(0, spotlightStore));
+    };
+
+    window.addEventListener(mediaRequestSearchEvent, handleMediaRequestSearch);
+    return () => {
+      window.removeEventListener(mediaRequestSearchEvent, handleMediaRequestSearch);
+    };
+  }, [setMediaRequestSearchScope, setMode, setQuery]);
+
+  useEffect(() => {
+    if (mode !== "media") {
+      setMediaRequestSearchScope({});
+    }
+  }, [mode, setMediaRequestSearchScope]);
 
   return (
     <MantineSpotlight.Root
@@ -87,13 +120,13 @@ const SpotlightWithActiveMode = ({ modeState, queryState, activeMode }: Spotligh
       <MantineSpotlight.Search
         placeholder={`${t("search.placeholder")}...`}
         ref={inputRef}
-        leftSectionWidth={activeMode.modeKey !== defaultMode ? 80 : 48}
+        leftSectionWidth={hasModeCharacter ? 80 : 48}
         leftSection={
           <Group align="center" wrap="nowrap" gap="xs" w="100%" h="100%">
             <Center w={48} h="100%">
               <IconSearch stroke={1.5} />
             </Center>
-            {activeMode.modeKey !== defaultMode ? <Kbd size="sm">{activeMode.character}</Kbd> : null}
+            {hasModeCharacter ? <Kbd size="sm">{activeMode.character}</Kbd> : null}
           </Group>
         }
         styles={{

packages/spotlight/src/index.ts

@@ -1,9 +1,9 @@
 "use client";
 
-import { spotlightActions } from "./spotlight-store";
+import { mediaRequestSearchEvent, spotlightActions } from "./spotlight-store";
 
 export { Spotlight } from "./components/spotlight";
-export { openSpotlight };
+export { openSpotlight, openMediaRequestSearch };
 export {
   SpotlightProvider,
   useRegisterSpotlightContextResults,
@@ -11,3 +11,18 @@ export {
 } from "./modes/home/context";
 
 const openSpotlight = spotlightActions.open;
+
+export interface OpenMediaRequestSearchOptions {
+  integrationIds?: string[];
+  query?: string;
+}
+
+const openMediaRequestSearch = (options: OpenMediaRequestSearchOptions = {}) => {
+  if (typeof window !== "undefined") {
+    window.dispatchEvent(new CustomEvent<OpenMediaRequestSearchOptions>(mediaRequestSearchEvent, { detail: options }));
+  }
+
+  spotlightActions.open();
+};
+
+export { mediaRequestSearchEvent };

packages/spotlight/src/lib/interaction.ts

@@ -12,7 +12,7 @@ const searchInteractions = [
   createSearchInteraction("link").optionsType<{ href: string; newTab?: boolean }>(),
   createSearchInteraction("javaScript").optionsType<{ onSelect: () => MaybePromise<void> }>(),
   createSearchInteraction("setQuery").optionsType<{ query: string }>(),
-  createSearchInteraction("mode").optionsType<{ mode: keyof TranslationObject["search"]["mode"] }>(),
+  createSearchInteraction("mode").optionsType<{ mode: keyof TranslationObject["search"]["mode"]; query?: string }>(),
   createSearchInteraction("children").optionsType<{
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     useActions: CreateChildrenOptionsProps<any>["useActions"];

packages/spotlight/src/modes/external/search-engines-search-group.tsx

@@ -64,6 +64,36 @@ type MediaRequestChildrenProps = {
     kind: IntegrationKind;
     url: string;
     id: string;
+    permissions?: {
+      hasInteractAccess: boolean;
+    };
+  };
+};
+
+export const useMediaRequestSearchInteraction = (
+  integration: MediaRequestChildrenProps["integration"],
+  searchResult: FromIntegrationSearchResult,
+): inferSearchInteractionDefinition<"link" | "children"> => {
+  const { openSearchInNewTab } = useSettings();
+
+  const type = searchResult.type;
+  if (type === "person") {
+    return {
+      type: "link",
+      href: searchResult.link,
+      newTab: openSearchInNewTab,
+    };
+  }
+
+  return {
+    type: "children",
+    ...mediaRequestsChildrenOptions({
+      result: {
+        ...searchResult,
+        type,
+      },
+      integration,
+    }),
   };
 };
 
@@ -71,8 +101,6 @@ export const useFromIntegrationSearchInteraction = (
   searchEngine: SearchEngine,
   searchResult: FromIntegrationSearchResult,
 ): inferSearchInteractionDefinition<"link" | "javaScript" | "children"> => {
-  const { openSearchInNewTab } = useSettings();
-
   if (searchEngine.type !== "fromIntegration") {
     throw new Error("Invalid search engine type");
   }
@@ -87,25 +115,7 @@ export const useFromIntegrationSearchInteraction = (
     ) &&
     "type" in searchResult
   ) {
-    const type = searchResult.type;
-    if (type === "person") {
-      return {
-        type: "link",
-        href: searchResult.link,
-        newTab: openSearchInNewTab,
-      };
-    }
-
-    return {
-      type: "children",
-      ...mediaRequestsChildrenOptions({
-        result: {
-          ...searchResult,
-          type,
-        },
-        integration: searchEngine.integration,
-      }),
-    };
+    return useMediaRequestSearchInteraction(searchEngine.integration, searchResult);
   }
 
   return {
@@ -115,13 +125,15 @@ export const useFromIntegrationSearchInteraction = (
   };
 };
 
-const mediaRequestsChildrenOptions = createChildrenOptions<MediaRequestChildrenProps>({
+export const mediaRequestsChildrenOptions = createChildrenOptions<MediaRequestChildrenProps>({
   useActions() {
     const { openModal } = useModalAction(RequestMediaModal);
     return [
       {
         key: "request",
-        hide: (option) => option.result.inLibrary,
+        hide: (option) =>
+          (option.result.type === "movie" && option.result.inLibrary) ||
+          option.integration.permissions?.hasInteractAccess === false,
         Component(option) {
           const t = useScopedI18n("search.mode.media");
           return (

packages/spotlight/src/modes/help/home-empty-groups.tsx

@@ -19,6 +19,7 @@ import type { SearchMode } from "../../lib/mode";
 import { appIntegrationBoardMode } from "../app-integration-board";
 import { commandMode } from "../command";
 import { externalMode } from "../external";
+import { mediaMode } from "../media";
 import { pageMode } from "../page";
 import { userGroupMode } from "../user-group";
 
@@ -33,7 +34,7 @@ type QuickLinkOption = {
 export const useHomeEmptyGroups = () => {
   const { data: session } = useSession();
   const tPages = useScopedI18n("search.mode.page.group.page.option");
-  const visibleSearchModes: SearchMode[] = [appIntegrationBoardMode, externalMode, commandMode, pageMode];
+  const visibleSearchModes: SearchMode[] = [appIntegrationBoardMode, externalMode, mediaMode, commandMode, pageMode];
 
   if (session?.user.permissions.includes("admin")) {
     visibleSearchModes.unshift(userGroupMode);
@@ -87,7 +88,7 @@ export const useHomeEmptyGroups = () => {
       useInteraction: interaction.link(({ path }) => ({ href: path })),
     }),
     createGroup({
-      keyPath: "character",
+      keyPath: "modeKey",
       title: (t) => t("search.mode.help.group.mode.title"),
       options: visibleSearchModes.map(({ character, modeKey }) => ({ character, modeKey })),
       Component: ({ modeKey, character }) => {
@@ -96,7 +97,7 @@ export const useHomeEmptyGroups = () => {
         return (
           <Group px="md" py="xs" w="100%" wrap="nowrap" align="center" justify="space-between">
             <Text>{t("help")}</Text>
-            <Kbd size="sm">{character}</Kbd>
+            {character && <Kbd size="sm">{character}</Kbd>}
           </Group>
         );
       },

packages/spotlight/src/modes/home/home-search-engine-group.tsx

@@ -20,6 +20,7 @@ type GroupItem = {
   name: string;
   description?: string;
   icon: TablerIcon | string;
+  disabled?: boolean;
   useInteraction: (query: string) => inferSearchInteractionDefinition<SearchInteraction>;
 };
 
@@ -37,7 +38,7 @@ export const homeSearchEngineGroup = createGroup<GroupItem>({
       );
 
     return (
-      <Group w="100%" wrap="nowrap" align="center" px="md" py="xs">
+      <Group w="100%" wrap="nowrap" align="center" px="md" py="xs" opacity={item.disabled ? 0.55 : 1}>
         {icon}
         <Stack gap={0}>
           <Text>{item.name}</Text>
@@ -91,9 +92,7 @@ const createDefaultSearchEntries = (
   query: string,
   t: TranslationFunction,
 ): GroupItem[] => {
-  if (!session?.user && !defaultSearchEngine) {
-    return [];
-  }
+  if (!session?.user && !defaultSearchEngine) return [];
 
   if (!defaultSearchEngine) {
     return [

packages/spotlight/src/modes/index.tsx

@@ -2,6 +2,7 @@ import { appIntegrationBoardMode } from "./app-integration-board";
 import { commandMode } from "./command";
 import { externalMode } from "./external";
 import { homeMode } from "./home";
+import { mediaMode } from "./media";
 import { pageMode } from "./page";
 import { userGroupMode } from "./user-group";
 
@@ -11,5 +12,6 @@ export const searchModes = [
   externalMode,
   commandMode,
   pageMode,
+  mediaMode,
   homeMode,
 ] as const;

packages/spotlight/src/modes/media/index.tsx

@@ -0,0 +1,8 @@
+import type { SearchMode } from "../../lib/mode";
+import { mediaRequestSearchGroup } from "./media-request-search-group";
+
+export const mediaMode = {
+  modeKey: "media",
+  character: undefined,
+  groups: [mediaRequestSearchGroup],
+} satisfies SearchMode;

packages/spotlight/src/modes/media/media-request-search-group.tsx

@@ -0,0 +1,172 @@
+import { Badge, Group, Image, Stack, Text } from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
+import { IconMovie, IconSearch } from "@tabler/icons-react";
+import { keepPreviousData } from "@tanstack/react-query";
+import { useAtomValue } from "jotai";
+
+import type { RouterOutputs } from "@homarr/api";
+import { clientApi } from "@homarr/api/client";
+import { getIntegrationName } from "@homarr/definitions";
+import type { MediaAvailability } from "@homarr/integrations/types";
+import { mediaAvailabilityConfiguration } from "@homarr/integrations/types";
+import { useScopedI18n } from "@homarr/translation/client";
+
+import { createGroup } from "../../lib/group";
+import { mediaRequestSearchScopeAtom } from "../../spotlight-store";
+import { useMediaRequestSearchInteraction } from "../external/search-engines-search-group";
+
+const availabilityLabels: Partial<Record<MediaAvailability, string>> = {
+  available: "Available",
+  partiallyAvailable: "Partial",
+  processing: "Processing",
+  requested: "Requested",
+  pending: "Requested",
+};
+
+type MediaRequestSearchResult = RouterOutputs["integration"]["searchMediaRequests"][number];
+
+type MediaRequestSearchOption =
+  | {
+      key: string;
+      kind: "disabled" | "hint";
+      label: string;
+      description: string;
+    }
+  | {
+      key: string;
+      kind: "result";
+      result: MediaRequestSearchResult;
+    };
+
+export const mediaRequestSearchGroup = createGroup<MediaRequestSearchOption>({
+  keyPath: "key",
+  title: (t) => t("search.mode.media.group.title"),
+  Component(option) {
+    if (option.kind !== "result") {
+      return (
+        <Group w="100%" wrap="nowrap" align="center" px="md" py="xs" opacity={option.kind === "disabled" ? 0.55 : 1}>
+          {option.kind === "disabled" ? <IconMovie stroke={1.5} /> : <IconSearch stroke={1.5} />}
+          <Stack gap={0}>
+            <Text size="sm">{option.label}</Text>
+            <Text size="xs" c="gray.6">
+              {option.description}
+            </Text>
+          </Stack>
+        </Group>
+      );
+    }
+
+    const { result } = option;
+    const badgeLabel = result.availability ? availabilityLabels[result.availability as MediaAvailability] : undefined;
+    const badgeColor = result.availability
+      ? mediaAvailabilityConfiguration[result.availability as MediaAvailability]?.color
+      : undefined;
+
+    return (
+      <Group w="100%" wrap="nowrap" align="center" px="md" py="xs">
+        {result.image ? (
+          <Image src={result.image} w={35} h={50} fit="cover" radius="md" />
+        ) : (
+          <IconSearch stroke={1.5} size={35} />
+        )}
+        <Stack gap={2} style={{ flex: 1 }}>
+          <Group gap="xs" wrap="nowrap">
+            <Text>{result.name}</Text>
+            {badgeLabel && (
+              <Badge size="xs" color={badgeColor} variant="light">
+                {badgeLabel}
+              </Badge>
+            )}
+          </Group>
+          <Text c="dimmed" size="sm" lineClamp={2}>
+            {result.text ?? getIntegrationName(result.integration.kind)}
+          </Text>
+        </Stack>
+      </Group>
+    );
+  },
+  useInteraction(option) {
+    if (option.kind !== "result") {
+      return {
+        type: "none",
+      };
+    }
+
+    return useMediaRequestSearchInteraction(option.result.integration, option.result);
+  },
+  useQueryOptions(query) {
+    const tMedia = useScopedI18n("search.mode.media");
+    const scope = useAtomValue(mediaRequestSearchScopeAtom);
+    const [debouncedQuery] = useDebouncedValue(query.trim(), 150);
+    const targetsQuery = clientApi.integration.mediaRequestSearchTargets.useQuery();
+
+    const scopedTargets = (targetsQuery.data ?? []).filter((target) =>
+      scope.integrationIds ? scope.integrationIds.includes(target.id) : true,
+    );
+    const hasScopedTargets = scopedTargets.length > 0;
+    const shouldSearch = debouncedQuery.length > 0 && hasScopedTargets;
+    const integrationIds = scope.integrationIds ? scopedTargets.map((target) => target.id) : undefined;
+
+    const resultsQuery = clientApi.integration.searchMediaRequests.useQuery(
+      { query: debouncedQuery, integrationIds },
+      {
+        enabled: shouldSearch,
+        placeholderData: keepPreviousData,
+        select: (data) => data.slice(0, 10),
+      },
+    );
+
+    const isLoading = targetsQuery.isLoading || (shouldSearch && resultsQuery.isLoading);
+    const isError = targetsQuery.isError || (shouldSearch && resultsQuery.isError);
+
+    if (!targetsQuery.data) {
+      return {
+        isLoading,
+        isError,
+        data: [],
+      };
+    }
+
+    if (!hasScopedTargets) {
+      return {
+        isLoading,
+        isError,
+        data: [
+          {
+            key: "disabled",
+            kind: "disabled",
+            label: tMedia("action.search.label"),
+            description: scope.integrationIds
+              ? tMedia("action.search.disabled.scoped")
+              : tMedia("action.search.disabled.noIntegration"),
+          },
+        ],
+      };
+    }
+
+    if (debouncedQuery.length === 0) {
+      return {
+        isLoading,
+        isError,
+        data: [
+          {
+            key: "hint",
+            kind: "hint",
+            label: tMedia("action.search.label"),
+            description: tMedia("action.search.description"),
+          },
+        ],
+      };
+    }
+
+    return {
+      isLoading,
+      isError,
+      data: (resultsQuery.data ?? []).map((result) => ({
+        key: `result-${result.integration.id}-${result.type}-${result.id}`,
+        kind: "result",
+        result,
+      })),
+    };
+  },
+});

packages/spotlight/src/spotlight-store.ts

@@ -3,9 +3,17 @@
 import { clamp } from "@mantine/hooks";
 import type { SpotlightStore } from "@mantine/spotlight";
 import { createSpotlight } from "@mantine/spotlight";
+import { atom } from "jotai";
 
 export const [spotlightStore, spotlightActions] = createSpotlight();
 
+export interface MediaRequestSearchScope {
+  integrationIds?: string[];
+}
+
+export const mediaRequestSearchScopeAtom = atom<MediaRequestSearchScope>({});
+export const mediaRequestSearchEvent = "homarr:spotlight:media-request-search";
+
 export const setSelectedAction = (index: number, store: SpotlightStore) => {
   store.updateState((state) => ({ ...state, selected: index }));
 };

packages/translation/src/lang/ca.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Contrasenya",
-        "suggestion": {
+        "requirement": {
           "length": "Inclou com a mínim 8 caràcters",
           "lowercase": "Inclou minúscules",
           "uppercase": "Inclou majúscules",

packages/translation/src/lang/cn.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "密码",
-        "suggestion": {
+        "requirement": {
           "length": "至少包含 8 个字符",
           "lowercase": "包含小写字母",
           "uppercase": "包含大写字母",

packages/translation/src/lang/cr.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "crwdns26:0crwdne26:0",
-        "suggestion": {
+        "requirement": {
           "length": "crwdns28:0crwdne28:0",
           "lowercase": "crwdns30:0crwdne30:0",
           "uppercase": "crwdns32:0crwdne32:0",

packages/translation/src/lang/cs.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Heslo",
-        "suggestion": {
+        "requirement": {
           "length": "Obsahuje alespoň 8 znaků",
           "lowercase": "Obsahuje malé písmeno",
           "uppercase": "Obsahuje velké písmeno",

packages/translation/src/lang/da.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Adgangskode",
-        "suggestion": {
+        "requirement": {
           "length": "Inkluderer mindst 8 tegn",
           "lowercase": "Inkluderer små bogstaver",
           "uppercase": "Inkluderer store bogstaver",

packages/translation/src/lang/de-CH.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Passwort",
-        "suggestion": {
+        "requirement": {
           "length": "Enthält mindestens 8 Zeichen",
           "lowercase": "Enthält Kleinbuchstaben",
           "uppercase": "Enthält Großbuchstaben",

packages/translation/src/lang/de.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Passwort",
-        "suggestion": {
+        "requirement": {
           "length": "Enthält mindestens 8 Zeichen",
           "lowercase": "Enthält Kleinbuchstaben",
           "uppercase": "Enthält Großbuchstaben",

packages/translation/src/lang/el.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Κωδικός",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "Περιλαμβάνει πεζό γράμμα",
           "uppercase": "Περιλαμβάνει κεφαλαίο γράμμα",

packages/translation/src/lang/en-gb.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Password",
-        "suggestion": {
+        "requirement": {
           "length": "Includes a minimum of 8 characters",
           "lowercase": "Includes a lower-case letter",
           "uppercase": "Includes an upper-case letter",
@@ -4551,9 +4551,23 @@
         }
       },
       "media": {
+        "help": "Search for movies or shows to request",
         "requestMovie": "",
         "requestSeries": "",
-        "openIn": ""
+        "openIn": "",
+        "group": {
+          "title": "Movies and shows"
+        },
+        "action": {
+          "search": {
+            "label": "Search for movies or shows",
+            "description": "Start typing to search your media request integrations",
+            "disabled": {
+              "noIntegration": "Add an Overseerr, Jellyseerr, or Seerr integration to enable media search.",
+              "scoped": "This widget does not have an accessible media request integration."
+            }
+          }
+        }
       },
       "external": {
         "help": "",
@@ -4829,7 +4843,11 @@
             "table": {
               "header": {
                 "season": "Season",
-                "episodes": "Episodes"
+                "episodes": "Episodes",
+                "status": "Status"
+              },
+              "status": {
+                "requested": "Requested"
               }
             },
             "button": {

packages/translation/src/lang/en.json

@@ -132,9 +132,8 @@
       },
       "password": {
         "label": "Password",
-        "suggestionsTitle": "Password suggestions",
-        "suggestion": {
-          "length": "At least 8 characters",
+        "requirement": {
+          "length": "Includes at least 8 characters",
           "lowercase": "Includes lowercase letter",
           "uppercase": "Includes uppercase letter",
           "number": "Includes number",
@@ -1406,9 +1405,6 @@
         "openNewTab": {
           "label": "Open in new tab"
         },
-        "withBorder": {
-          "label": "Show border"
-        },
         "items": {
           "label": "Bookmarks",
           "add": "Add bookmark"
@@ -4555,9 +4551,23 @@
         }
       },
       "media": {
+        "help": "Search for movies or shows to request",
         "requestMovie": "Request movie",
         "requestSeries": "Request series",
-        "openIn": "Open in {kind}"
+        "openIn": "Open in {kind}",
+        "group": {
+          "title": "Movies and shows"
+        },
+        "action": {
+          "search": {
+            "label": "Search for movies or shows",
+            "description": "Start typing to search your media request integrations",
+            "disabled": {
+              "noIntegration": "Add an Overseerr, Jellyseerr, or Seerr integration to enable media search.",
+              "scoped": "This widget does not have an accessible media request integration."
+            }
+          }
+        }
       },
       "external": {
         "help": "Use an external search engine",
@@ -4833,7 +4843,11 @@
             "table": {
               "header": {
                 "season": "Season",
-                "episodes": "Episodes"
+                "episodes": "Episodes",
+                "status": "Status"
+              },
+              "status": {
+                "requested": "Requested"
               }
             },
             "button": {

packages/translation/src/lang/es.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Contraseña",
-        "suggestion": {
+        "requirement": {
           "length": "Incluye al menos 8 caracteres",
           "lowercase": "Incluye al menos una letra minúscula",
           "uppercase": "Incluye al menos una letra mayúscula",

packages/translation/src/lang/et.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "",
           "uppercase": "",

packages/translation/src/lang/fr.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Mot de passe",
-        "suggestion": {
+        "requirement": {
           "length": "Contient au moins 8 caractères",
           "lowercase": "Inclut une lettre minuscule",
           "uppercase": "Inclut une lettre majuscule",

packages/translation/src/lang/he.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "סיסמה",
-        "suggestion": {
+        "requirement": {
           "length": "כולל לפחות 8 תווים",
           "lowercase": "אפשר אותיות קטנות",
           "uppercase": "אפשר אותיות גדולות",

packages/translation/src/lang/hr.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Lozinka",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "Uključuje mala slova",
           "uppercase": "Uključuje veliko slovo",

packages/translation/src/lang/hu.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Jelszó",
-        "suggestion": {
+        "requirement": {
           "length": "Tartalmazzon legalább 8 karaktert",
           "lowercase": "Tartalmazzon kisbetűt",
           "uppercase": "Tartalmazzon nagybetűt",

packages/translation/src/lang/it.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Password",
-        "suggestion": {
+        "requirement": {
           "length": "Include almeno 8 caratteri",
           "lowercase": "Include lettera minuscola",
           "uppercase": "Include lettera maiuscola",
@@ -1056,7 +1056,7 @@
       }
     },
     "noResults": {
-      "title": "Nessun media caricato"
+      "title": ""
     }
   },
   "common": {
@@ -1088,8 +1088,8 @@
       "checkLogs": "Controlla i log per maggiori dettagli",
       "tryAgain": "Riprova",
       "loading": "Caricamento",
-      "show": "Visualizza",
-      "hide": "Nascondi"
+      "show": "",
+      "hide": ""
     },
     "here": "qui",
     "iconPicker": {
@@ -1255,7 +1255,7 @@
         "label": {
           "create": "Nuova categoria",
           "changePosition": "Cambia posizione",
-          "settings": "Impostazioni"
+          "settings": ""
         }
       },
       "openAllInNewTabs": {
@@ -3459,7 +3459,7 @@
           "private": "Questa board è privata"
         },
         "noResults": {
-          "title": "Ancora nessuna board"
+          "title": ""
         },
         "modal": {
           "createBoard": {

packages/translation/src/lang/ja.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "パスワード",
-        "suggestion": {
+        "requirement": {
           "length": "少なくとも 8 文字以上を含む",
           "lowercase": "小文字を含む",
           "uppercase": "大文字を含む",

packages/translation/src/lang/ko.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "비밀번호",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "소문자 포함",
           "uppercase": "대문자 포함",

packages/translation/src/lang/lt.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Slaptažodis",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "",
           "uppercase": "",

packages/translation/src/lang/lv.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Parole",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "Ietver mazo burtu",
           "uppercase": "Ietver lielo burtu",

packages/translation/src/lang/nl.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Wachtwoord",
-        "suggestion": {
+        "requirement": {
           "length": "Bevat ten minste 8 tekens",
           "lowercase": "Inclusief kleine letter",
           "uppercase": "Inclusief hoofdletter",

packages/translation/src/lang/no.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Passord",
-        "suggestion": {
+        "requirement": {
           "length": "Inkluderer minst 8 tegn",
           "lowercase": "Inkluderer liten bokstav",
           "uppercase": "Inkluderer stor bokstav",

packages/translation/src/lang/pl.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Hasło",
-        "suggestion": {
+        "requirement": {
           "length": "Zawiera co najmniej 8 znaków",
           "lowercase": "Zawiera małą literę",
           "uppercase": "Zawiera wielką literę",

packages/translation/src/lang/pt-br.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Senha",
-        "suggestion": {
+        "requirement": {
           "length": "Inclua pelo menos 8 caracteres",
           "lowercase": "Inclui letras minúsculas",
           "uppercase": "Inclui letras maiúsculas",

packages/translation/src/lang/pt.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "",
           "uppercase": "",

packages/translation/src/lang/ro.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Parola",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "Să includă litere mici",
           "uppercase": "Să includă litere mari",

packages/translation/src/lang/ru.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Пароль",
-        "suggestion": {
+        "requirement": {
           "length": "Содержит не менее 8 символов",
           "lowercase": "Содержит строчную букву",
           "uppercase": "Содержит заглавную букву",

packages/translation/src/lang/sk.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Heslo",
-        "suggestion": {
+        "requirement": {
           "length": "Obsahuje aspoň 8 znakov",
           "lowercase": "Zahŕňa malé písmeno",
           "uppercase": "Zahŕňa veľké písmená",

packages/translation/src/lang/sl.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Geslo",
-        "suggestion": {
+        "requirement": {
           "length": "",
           "lowercase": "Vključuje male črke",
           "uppercase": "Vključuje velike tiskane črke",

packages/translation/src/lang/sv.json

@@ -82,7 +82,7 @@
         "form": {
           "name": {
             "label": "Gruppens namn",
-            "description": "Namnet måste matcha admin-grupp i extern tjänst"
+            "description": ""
           }
         }
       },
@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Lösenord",
-        "suggestion": {
+        "requirement": {
           "length": "Använd minst 8 tecken",
           "lowercase": "Använd liten bokstav",
           "uppercase": "Använd stor bokstav",
@@ -159,7 +159,7 @@
         "label": "Visa sökresultat i ny flik"
       },
       "ddgBangs": {
-        "label": "Aktivera DuckDuckGo bangs"
+        "label": ""
       }
     },
     "error": {
@@ -252,10 +252,10 @@
       "changeDdgBangs": {
         "notification": {
           "success": {
-            "message": "DuckDuckGo bangs inställningen ändrad"
+            "message": ""
           },
           "error": {
-            "message": "DuckDuckGo bangs inställningen kunde inte ändras"
+            "message": ""
           }
         }
       },
@@ -350,12 +350,12 @@
             "description": "Tillåt medlemmar att addera valfri applikation på sina tavlor"
           },
           "modify-all": {
-            "label": "Modifiera alla appar",
-            "description": "Tillåt att medlemmar modifierar alla appar"
+            "label": "",
+            "description": ""
           },
           "full-all": {
-            "label": "Fullständiga rättigheter till appar",
-            "description": "Tillåt att medlemmar hanterar, använder och raderar alla appar"
+            "label": "",
+            "description": ""
           }
         }
       },
@@ -363,20 +363,20 @@
         "title": "Tavlor",
         "item": {
           "create": {
-            "label": "Skapa tavlor",
-            "description": "Tillåt att medlemmar skapar tavlor"
+            "label": "",
+            "description": ""
           },
           "view-all": {
-            "label": "Se alla tavlor",
-            "description": "Tillåt att medlemmar ser alla tavlor"
+            "label": "",
+            "description": ""
           },
           "modify-all": {
-            "label": "Modifiera alla tavlor",
-            "description": "Tillåt att medlemmar modifierar alla tavlor (Detta inkluderar inte åtkomstkontroll eller farozonen)"
+            "label": "",
+            "description": ""
           },
           "full-all": {
-            "label": "Fullständiga rättigheter till tavlor",
-            "description": "Tillåt att medlemmar ser, modifierar och tar bort alla tavlor (detta inkluderar åtkomstkontroll och farozonen)"
+            "label": "",
+            "description": ""
           }
         }
       },
@@ -392,38 +392,38 @@
             "description": "Tillåter medlemmar att addera valfri integration till sina tavlor"
           },
           "interact-all": {
-            "label": "Interagera med alla integrationer",
-            "description": "Tillåt att medlemmar interagerar med alla integrationer"
+            "label": "",
+            "description": ""
           },
           "full-all": {
-            "label": "Fullständiga rättigheter till integrationer",
-            "description": "Tillåt att medlemmar hanterar, använder och interagerar med alla integrationer"
+            "label": "",
+            "description": ""
           }
         }
       },
       "media": {
-        "title": "Media",
+        "title": "",
         "item": {
           "upload": {
-            "label": "Ladda upp media",
-            "description": "Tillåt att medlemmar laddar upp media"
+            "label": "",
+            "description": ""
           },
           "view-all": {
-            "label": "Se all media",
-            "description": "Tillåt att medlemmar ser all media"
+            "label": "",
+            "description": ""
           },
           "full-all": {
-            "label": "Fullständiga rättigheter till media",
-            "description": "Tillåt att medlemmar hanterar och raderar all media"
+            "label": "",
+            "description": ""
           }
         }
       },
       "other": {
-        "title": "Annat",
+        "title": "",
         "item": {
           "view-logs": {
-            "label": "Se loggar",
-            "description": "Tillåt att medlemmar ser loggar"
+            "label": "",
+            "description": ""
           }
         }
       },
@@ -435,32 +435,32 @@
             "description": "Tillåt medlemmar att skapa sökmotorer"
           },
           "modify-all": {
-            "label": "Modifiera alla sökmotorer",
-            "description": "Tillåt att medlemmar modifierar alla sökmotorer"
+            "label": "",
+            "description": ""
           },
           "full-all": {
-            "label": "Fullständiga rättigheter till sökmotorer",
-            "description": "Tillåt att medlemmar hanterar och raderar alla sökmotorer"
+            "label": "",
+            "description": ""
           }
         }
       }
     },
     "memberNotice": {
-      "mixed": "Vissa medlemmar är från externa tjänster och kan inte hantera här",
-      "external": "Alla medlemmar är från externa tjänster och kan inte hanteras här"
+      "mixed": "",
+      "external": ""
     },
     "reservedNotice": {
-      "message": "Denna grupp är reserverad för systemet så vissa åtgärder är begränsade. <checkoutDocs></checkoutDocs>"
+      "message": ""
     },
     "action": {
       "create": {
         "label": "Addera en grupp",
         "notification": {
           "success": {
-            "message": "Gruppen har skapats"
+            "message": ""
           },
           "error": {
-            "message": "Gruppen kunde inte skapas"
+            "message": ""
           }
         }
       },
@@ -470,7 +470,7 @@
         "confirm": "Är du säker på att du vill överföra ägarskapet för gruppen {name} till {username}?",
         "notification": {
           "success": {
-            "message": "Överfört grupp {group} till {user}"
+            "message": ""
           },
           "error": {
             "message": "Kunde inte överföra ägarskap"
@@ -501,38 +501,38 @@
         "notification": {
           "success": {
             "title": "Behörigheter sparade",
-            "message": "Rättigheterna sparade"
+            "message": ""
           },
           "error": {
-            "title": "Rättigheterna ej sparade",
-            "message": "Rättigheterna har inte sparats"
+            "title": "",
+            "message": ""
           }
         }
       },
       "update": {
         "notification": {
           "success": {
-            "message": "Gruppen {name} har sparats"
+            "message": ""
           },
           "error": {
-            "message": "Kunde inte spara gruppen {name}"
+            "message": ""
           }
         }
       },
       "select": {
         "label": "Välj en grupp",
-        "notFound": "Ingen grupp hittad"
+        "notFound": ""
       },
       "settings": {
         "board": {
           "notification": {
             "success": {
               "title": "Inställningarna sparades",
-              "message": "Inställningarna för tavlan har sparats"
+              "message": ""
             },
             "error": {
               "title": "Kunde inte spara inställningarna",
-              "message": "Kunde inte spara inställningarna för tavlan"
+              "message": ""
             }
           }
         }
@@ -540,10 +540,10 @@
       "changePosition": {
         "notification": {
           "success": {
-            "message": "Ordning ändrad"
+            "message": ""
           },
           "error": {
-            "message": "Ordningen kunde ändras"
+            "message": ""
           }
         }
       }
@@ -559,20 +559,20 @@
       "list": {
         "title": "Applikationer",
         "noResults": {
-          "title": "Det finns inga appar ännu",
-          "action": "Skapa din första app"
+          "title": "",
+          "action": ""
         }
       },
       "create": {
         "title": "Addera applikation",
         "notification": {
           "success": {
-            "title": "Skapandet lyckades",
-            "message": "Appen skapades framgångsrikt"
+            "title": "",
+            "message": ""
           },
           "error": {
-            "title": "Skapandet misslyckades",
-            "message": "Appen kunde inte skapas"
+            "title": "",
+            "message": ""
           }
         }
       },
@@ -581,11 +581,11 @@
         "notification": {
           "success": {
             "title": "Ändringarna har sparats",
-            "message": "Appen sparades"
+            "message": ""
           },
           "error": {
             "title": "Misslyckades med att spara ändringarna",
-            "message": "Appen kunde inte sparas"
+            "message": ""
           }
         }
       },
@@ -594,12 +594,12 @@
         "message": "Är du säker på att du vill ta bort applikationen {name}?",
         "notification": {
           "success": {
-            "title": "Borttagning lyckades",
-            "message": "Appen har tagits bort"
+            "title": "",
+            "message": ""
           },
           "error": {
-            "title": "Borttagning misslyckades",
-            "message": "Kunde inte ta bort appen"
+            "title": "",
+            "message": ""
           }
         }
       }
@@ -612,21 +612,21 @@
         "label": "Beskrivning"
       },
       "url": {
-        "label": "URL"
+        "label": ""
       },
       "useDifferentUrlForPing": {
         "checkbox": {
-          "label": "Använd annan URL för ping",
-          "description": "Användbart om Homarr kan komma åt appen direkt via ett internt host-namn eller nätverk för att undvika bandbreddsanvändning hos internetleverantör"
+          "label": "",
+          "description": ""
         }
       }
     },
     "action": {
       "select": {
-        "label": "Välj app",
-        "notFound": "Ingen app hittades",
+        "label": "",
+        "notFound": "",
         "search": "Sök efter en applikation",
-        "noResults": "Inga resultat",
+        "noResults": "",
         "action": "Välj {app}",
         "title": "Välj en applikation att lägga till på tavlan"
       },
@@ -642,56 +642,56 @@
     "page": {
       "list": {
         "title": "Integrationer",
-        "search": "Sök integrationer",
+        "search": "",
         "noResults": {
-          "title": "Det finns inga integrationer ännu"
+          "title": ""
         }
       },
       "create": {
-        "title": "Ny {name} integration",
+        "title": "",
         "notification": {
           "success": {
-            "title": "Skapandet lyckades",
-            "message": "Integrationen har skapats"
+            "title": "",
+            "message": ""
           },
           "error": {
-            "title": "Skapandet misslyckades",
-            "message": "Integrationen kunde inte skapas"
+            "title": "",
+            "message": ""
           }
         },
         "app": {
           "option": {
             "existing": {
-              "title": "Befintlig",
-              "label": "Välj befintlig app"
+              "title": "",
+              "label": ""
             },
             "new": {
-              "title": "Ny",
+              "title": "",
               "url": {
-                "label": "App URL",
-                "description": "URL:en som appen kommer att öppna när den används från tavlan"
+                "label": "",
+                "description": ""
               }
             }
           }
         }
       },
       "edit": {
-        "title": "Redigera {name} integration",
+        "title": "",
         "notification": {
           "success": {
             "title": "Ändringarna har sparats",
-            "message": "Integrationen sparad"
+            "message": ""
           },
           "error": {
-            "title": "Kunde inte tillämpa ändringar",
-            "message": "Integrationen kunde inte sparas"
+            "title": "",
+            "message": ""
           }
         },
         "app": {
           "action": {
-            "add": "Länka en app",
-            "remove": "Ta bort länk",
-            "select": "Välj en app att länka till"
+            "add": "",
+            "remove": "",
+            "select": ""
           }
         }
       },
@@ -700,12 +700,12 @@
         "message": "Är du säker på att du vill ta bort integrationen {name}?",
         "notification": {
           "success": {
-            "title": "Borttagning lyckades",
-            "message": "Integrationen har tagits bort"
+            "title": "",
+            "message": ""
           },
           "error": {
-            "title": "Borttagning misslyckades",
-            "message": "Kunde inte ta bort integrationen"
+            "title": "",
+            "message": ""
           }
         }
       }
@@ -715,44 +715,44 @@
         "label": "Namn"
       },
       "url": {
-        "label": "URL"
+        "label": ""
       },
       "attemptSearchEngineCreation": {
-        "label": "Skapa sökmotor",
-        "description": "Integrationen \"{kind}\" kan inte användas med sökmotorer. Markera detta för att automatiskt konfigurera sökmotorn."
+        "label": "",
+        "description": ""
       },
       "app": {
-        "sectionTitle": "Länkad app"
+        "sectionTitle": ""
       },
       "createApp": {
-        "label": "Skapa app",
-        "description": "Skapa en app med samma namn och ikon som integrationen. Lämna fältet nedan tomt för att skapa en app med integrationens URL."
+        "label": "",
+        "description": ""
       },
       "appHref": {
-        "placeholder": "Egen app-URL"
+        "placeholder": ""
       }
     },
     "action": {
-      "create": "Ny integration"
+      "create": ""
     },
     "testConnection": {
       "action": {
-        "create": "Testa anslutningen och skapa",
-        "edit": "Testa anslutningen och skapa"
+        "create": "",
+        "edit": ""
       },
       "error": {
         "common": {
           "cause": {
-            "title": "Orsak med mer detaljer"
+            "title": ""
           }
         },
         "unknown": {
-          "title": "Okänt fel",
-          "description": "Ett okänt fel inträffade, öppna orsaken nedan för att se mer detaljer"
+          "title": "",
+          "description": ""
         },
         "parse": {
-          "title": "Parsningsfel",
-          "description": "Svaret kunde inte analyseras. Verifiera att URL pekar på bas-URL för tjänsten."
+          "title": "",
+          "description": ""
         },
         "authorization": {
           "title": "",

packages/translation/src/lang/tr.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Şifre",
-        "suggestion": {
+        "requirement": {
           "length": "En az 8 karakter içermeli",
           "lowercase": "Küçük harf içermeli",
           "uppercase": "Büyük harf içermeli",

packages/translation/src/lang/uk.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Пароль",
-        "suggestion": {
+        "requirement": {
           "length": "Включає принаймні 8 символів",
           "lowercase": "Включає малу літеру",
           "uppercase": "Включає велику літеру",

packages/translation/src/lang/vi.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "Mật khẩu",
-        "suggestion": {
+        "requirement": {
           "length": "Bao gồm ít nhất 8 kí tự",
           "lowercase": "Bao gồm chữ thường",
           "uppercase": "Bao gồm chữ in hoa",

packages/translation/src/lang/zh.json

@@ -132,7 +132,7 @@
       },
       "password": {
         "label": "密碼",
-        "suggestion": {
+        "requirement": {
           "length": "至少包含 8 個字符",
           "lowercase": "包含小寫字母",
           "uppercase": "包含大寫字母",

packages/ui/src/components/password-input/password-input.tsx

@@ -20,15 +20,15 @@ export const CustomPasswordInput = ({ withPasswordRequirements, ...props }: Cust
 };
 
 const WithPasswordRequirements = (props: PasswordInputProps) => {
-  const [password, setPassword] = useState("");
+  const [value, setValue] = useState("");
 
   const onChange = (event: ChangeEvent<HTMLInputElement>) => {
-    setPassword(event.currentTarget.value);
+    setValue(event.currentTarget.value);
     props.onChange?.(event);
   };
 
   return (
-    <PasswordRequirementsPopover password={password}>
+    <PasswordRequirementsPopover password={value}>
       <PasswordInput {...props} onChange={onChange} />
     </PasswordRequirementsPopover>
   );

packages/ui/src/components/password-input/password-requirement.tsx

@@ -1,19 +1,14 @@
 import { rem, Text } from "@mantine/core";
-import { IconCheck, IconPoint } from "@tabler/icons-react";
-
-const getRequirementDisplay = (meets: boolean) =>
-  ({
-    true: { color: "teal", Icon: IconCheck },
-    false: { color: "dimmed", Icon: IconPoint },
-  })[String(meets) as "true" | "false"];
+import { IconCheck, IconX } from "@tabler/icons-react";
 
 export function PasswordRequirement({ meets, label }: { meets: boolean; label: string }) {
-  const display = getRequirementDisplay(meets);
-  const Icon = display.Icon;
-
   return (
-    <Text c={display.color} display="flex" style={{ alignItems: "center" }} size="sm">
-      <Icon style={{ width: rem(14), height: rem(14) }} />
+    <Text c={meets ? "teal" : "red"} display="flex" style={{ alignItems: "center" }} size="sm">
+      {meets ? (
+        <IconCheck style={{ width: rem(14), height: rem(14) }} />
+      ) : (
+        <IconX style={{ width: rem(14), height: rem(14) }} />
+      )}
       <Text span ml={10}>
         {label}
       </Text>

packages/ui/src/components/password-input/password-requirements-popover.tsx

@@ -1,24 +1,16 @@
 import type { PropsWithChildren } from "react";
 import { useState } from "react";
-import { Popover, Progress, Text } from "@mantine/core";
+import { Popover, Progress } from "@mantine/core";
 
 import { useScopedI18n } from "@homarr/translation/client";
 import { passwordRequirements } from "@homarr/validation/user";
 
 import { PasswordRequirement } from "./password-requirement";
 
-const strengthColorMap = [
-  { min: 100, color: "teal" },
-  { min: 51, color: "yellow" },
-  { min: 0, color: "dimmed" },
-] as const;
-
 export const PasswordRequirementsPopover = ({ password, children }: PropsWithChildren<{ password: string }>) => {
-  const tPassword = useScopedI18n("user.field.password");
   const requirements = useRequirements();
   const strength = useStrength(password);
   const [popoverOpened, setPopoverOpened] = useState(false);
-  const strengthColor = strengthColorMap.find(({ min }) => strength >= min)?.color ?? "dimmed";
   const checks = (
     <>
       {requirements.map((requirement) => (
@@ -27,6 +19,8 @@ export const PasswordRequirementsPopover = ({ password, children }: PropsWithChi
     </>
   );
 
+  const color = strength === 100 ? "teal" : strength > 50 ? "yellow" : "red";
+
   return (
     <Popover opened={popoverOpened} position="bottom" width="target" transitionProps={{ transition: "pop" }}>
       <Popover.Target>
@@ -35,10 +29,7 @@ export const PasswordRequirementsPopover = ({ password, children }: PropsWithChi
         </div>
       </Popover.Target>
       <Popover.Dropdown>
-        <Progress color={strengthColor} value={strength} size={5} mb="xs" />
-        <Text size="sm" c="dimmed" mb="xs">
-          {tPassword("suggestionsTitle")}
-        </Text>
+        <Progress color={color} value={strength} size={5} mb="xs" />
         {checks}
       </Popover.Dropdown>
     </Popover>
@@ -46,7 +37,7 @@ export const PasswordRequirementsPopover = ({ password, children }: PropsWithChi
 };
 
 const useRequirements = () => {
-  const t = useScopedI18n("user.field.password.suggestion");
+  const t = useScopedI18n("user.field.password.requirement");
 
   return passwordRequirements.map(({ check, value }) => ({ check, label: t(value) }));
 };

packages/validation/src/user.ts

@@ -19,10 +19,24 @@ export const passwordRequirements = [
   { check: regexCheck(/[$&+,:;=?@#|'<>.^*()%!\-~`"_/\\[\]{}]/), value: "special" },
 ] satisfies {
   check: (value: string) => boolean;
-  value: keyof TranslationObject["user"]["field"]["password"]["suggestion"];
+  value: keyof TranslationObject["user"]["field"]["password"]["requirement"];
 }[];
 
-export const userPasswordSchema = z.string().min(8).max(255);
+export const userPasswordSchema = z
+  .string()
+  .min(8)
+  .max(255)
+  .refine(
+    (value) => {
+      return passwordRequirements.every((requirement) => requirement.check(value));
+    },
+    {
+      params: createCustomErrorParams({
+        key: "passwordRequirements",
+        params: {},
+      }),
+    },
+  );
 
 const addConfirmPasswordRefinement = <
   TSchema extends z.ZodObject<{ password: z.core.$ZodString; confirmPassword: z.core.$ZodString }, z.core.$strip>,

packages/widgets/src/bookmarks/component.tsx

@@ -16,7 +16,7 @@ export default function BookmarksWidget({ options, itemId }: WidgetComponentProp
   const board = useRequiredBoard();
   const [data] = clientApi.app.byIds.useSuspenseQuery(options.items, {
     select(data) {
-      return data.toSorted((appA, appB) => options.items.indexOf(appA.id) - options.items.indexOf(appB.id));
+      return data.sort((appA, appB) => options.items.indexOf(appA.id) - options.items.indexOf(appB.id));
     },
   });
 
@@ -56,7 +56,6 @@ export default function BookmarksWidget({ options, itemId }: WidgetComponentProp
           hideIcon={options.hideIcon}
           hideHostname={options.hideHostname}
           openNewTab={options.openNewTab}
-          withBorder={options.withBorder}
           hasIconColor={board.iconColor !== null}
         />
       )}
@@ -68,7 +67,6 @@ export default function BookmarksWidget({ options, itemId }: WidgetComponentProp
           hideIcon={options.hideIcon}
           hideHostname={options.hideHostname}
           openNewTab={options.openNewTab}
-          withBorder={options.withBorder}
           hasIconColor={board.iconColor !== null}
         />
       )}
@@ -83,7 +81,6 @@ interface FlexLayoutProps {
   hideIcon: boolean;
   hideHostname: boolean;
   openNewTab: boolean;
-  withBorder: boolean;
   hasIconColor: boolean;
 }
 
@@ -94,7 +91,6 @@ const FlexLayout = ({
   hideIcon,
   hideHostname,
   openNewTab,
-  withBorder,
   hasIconColor,
 }: FlexLayoutProps) => {
   const board = useRequiredBoard();
@@ -110,15 +106,7 @@ const FlexLayout = ({
             key={app.id}
             w="100%"
           >
-            <Card
-              radius={board.itemRadius}
-              className={classes.card}
-              w="100%"
-              display="flex"
-              p={4}
-              h="100%"
-              withBorder={withBorder}
-            >
+            <Card radius={board.itemRadius} className={classes.card} w="100%" display="flex" p={4} h="100%">
               {direction === "row" ? (
                 <VerticalItem
                   app={app}
@@ -150,7 +138,6 @@ interface GridLayoutProps {
   hideIcon: boolean;
   hideHostname: boolean;
   openNewTab: boolean;
-  withBorder: boolean;
   itemDirection: "horizontal" | "vertical";
   hasIconColor: boolean;
 }
@@ -161,7 +148,6 @@ const GridLayout = ({
   hideIcon,
   hideHostname,
   openNewTab,
-  withBorder,
   itemDirection,
   hasIconColor,
 }: GridLayoutProps) => {
@@ -182,7 +168,6 @@ const GridLayout = ({
             h="100%"
             className={combineClasses(classes.card, classes["card-grid"])}
             radius={board.itemRadius}
-            withBorder={withBorder}
             p="xs"
           >
             {itemDirection === "horizontal" ? (

packages/widgets/src/bookmarks/index.tsx

@@ -24,7 +24,6 @@ export const { definition, componentLoader } = createWidgetDefinition("bookmarks
       hideIcon: factory.switch({ defaultValue: false }),
       hideHostname: factory.switch({ defaultValue: false }),
       openNewTab: factory.switch({ defaultValue: true }),
-      withBorder: factory.switch({ defaultValue: false }),
       items: factory.sortableItemList<RouterOutputs["app"]["all"][number], string>({
         ItemComponent: ({ item, handle: Handle, removeItem, rootAttributes }) => {
           return (

packages/widgets/src/immich/server-stats/component.module.css

@@ -1,10 +1,20 @@
 .statItem {
   padding: 12px;
   border-radius: var(--mantine-radius-md);
-  background-color: light-dark(var(--mantine-color-gray-0), var(--mantine-color-dark-6));
+  background-color: var(--mantine-color-gray-0);
   transition: all 0.2s ease;
 
   &:hover {
-    background-color: light-dark(var(--mantine-color-gray-1), var(--mantine-color-dark-5));
+    background-color: var(--mantine-color-gray-1);
+  }
+}
+
+@media (prefers-color-scheme: dark) {
+  .statItem {
+    background-color: var(--mantine-color-dark-6);
+
+    &:hover {
+      background-color: var(--mantine-color-dark-5);
+    }
   }
 }

packages/widgets/src/media-requests/list/component.tsx

@@ -1,17 +1,32 @@
 "use client";
 
-import { ActionIcon, Anchor, Avatar, Badge, Card, Group, Image, ScrollArea, Stack, Text, Tooltip } from "@mantine/core";
-import { IconThumbDown, IconThumbUp } from "@tabler/icons-react";
+import {
+  ActionIcon,
+  Anchor,
+  Avatar,
+  Badge,
+  Box,
+  Card,
+  Group,
+  Image,
+  ScrollArea,
+  Stack,
+  Text,
+  Tooltip,
+} from "@mantine/core";
+import { IconSearch, IconThumbDown, IconThumbUp } from "@tabler/icons-react";
 
 import type { RouterInputs, RouterOutputs } from "@homarr/api";
 import { clientApi } from "@homarr/api/client";
 import { useRequiredBoard } from "@homarr/boards/context";
 import type { MediaRequestStatus } from "@homarr/integrations/types";
 import { mediaAvailabilityConfiguration, mediaRequestStatusConfiguration } from "@homarr/integrations/types";
+import { openMediaRequestSearch } from "@homarr/spotlight";
 import { useScopedI18n } from "@homarr/translation/client";
 
 import type { WidgetComponentProps } from "../../definition";
 import { NoIntegrationDataError } from "../../errors/no-data-integration";
+import classes from "../search-button.module.css";
 
 export default function MediaServerWidget({
   integrationIds,
@@ -43,7 +58,7 @@ export default function MediaServerWidget({
           const newData = filteredData.concat(
             data.requests.map((request) => ({ ...request, integrationId: data.integrationId })),
           );
-          return newData.sort((dataA, dataB) => {
+          return newData.toSorted((dataA, dataB) => {
             if (dataA.status === dataB.status) {
               return dataB.createdAt.getTime() - dataA.createdAt.getTime();
             }
@@ -61,25 +76,46 @@ export default function MediaServerWidget({
   if (mediaRequests.length === 0) throw new NoIntegrationDataError();
 
   return (
-    <ScrollArea
-      className="mediaRequests-list-scrollArea"
-      scrollbarSize="md"
-      style={{ pointerEvents: isEditMode ? "none" : undefined }}
-    >
-      <Stack className="mediaRequests-list-list" gap="xs" p="sm">
-        {mediaRequests.map((mediaRequest) => (
-          <MediaRequestCard
-            key={`${mediaRequest.integrationId}-${mediaRequest.id}`}
-            request={mediaRequest}
-            isTiny={width <= 256}
-            options={options}
-          />
-        ))}
-      </Stack>
-    </ScrollArea>
+    <Box className={classes.searchRoot}>
+      {!isEditMode && <MediaRequestSearchButton integrationIds={integrationIds} />}
+      <ScrollArea
+        className="mediaRequests-list-scrollArea"
+        scrollbarSize="md"
+        style={{ pointerEvents: isEditMode ? "none" : undefined }}
+      >
+        <Stack className="mediaRequests-list-list" gap="xs" p="sm">
+          {mediaRequests.map((mediaRequest) => (
+            <MediaRequestCard
+              key={`${mediaRequest.integrationId}-${mediaRequest.id}`}
+              request={mediaRequest}
+              isTiny={width <= 256}
+              options={options}
+            />
+          ))}
+        </Stack>
+      </ScrollArea>
+    </Box>
   );
 }
 
+const MediaRequestSearchButton = ({ integrationIds }: { integrationIds: string[] }) => {
+  const t = useScopedI18n("search.mode.media");
+
+  return (
+    <Tooltip label={t("action.search.label")}>
+      <ActionIcon
+        className={classes.searchButton}
+        variant="light"
+        size="sm"
+        aria-label={t("action.search.label")}
+        onClick={() => openMediaRequestSearch({ integrationIds })}
+      >
+        <IconSearch size={16} />
+      </ActionIcon>
+    </Tooltip>
+  );
+};
+
 interface MediaRequestCardProps {
   request: RouterOutputs["widget"]["mediaRequests"]["getLatestRequests"][number];
   isTiny: boolean;

packages/widgets/src/media-requests/search-button.module.css

@@ -0,0 +1,24 @@
+.searchRoot {
+  position: relative;
+  height: 100%;
+}
+
+.searchButton {
+  position: absolute;
+  top: var(--mantine-spacing-xs);
+  right: var(--mantine-spacing-xs);
+  z-index: 2;
+  opacity: 0;
+  transition: opacity 120ms ease;
+}
+
+.searchRoot:hover .searchButton,
+.searchRoot:focus-within .searchButton {
+  opacity: 1;
+}
+
+@media (hover: none) {
+  .searchButton {
+    opacity: 1;
+  }
+}

packages/widgets/src/media-requests/stats/component.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { Avatar, Card, Grid, Group, Stack, Text, Tooltip } from "@mantine/core";
+import { ActionIcon, Avatar, Box, Card, Grid, Group, Stack, Text, Tooltip } from "@mantine/core";
 import type { Icon } from "@tabler/icons-react";
 import {
   IconDeviceTv,
@@ -9,6 +9,7 @@ import {
   IconMovie,
   IconPlayerPlay,
   IconReceipt,
+  IconSearch,
   IconThumbDown,
   IconThumbUp,
 } from "@tabler/icons-react";
@@ -17,11 +18,13 @@ import combineClasses from "clsx";
 import { clientApi } from "@homarr/api/client";
 import { useRequiredBoard } from "@homarr/boards/context";
 import type { RequestStats } from "@homarr/integrations/types";
+import { openMediaRequestSearch } from "@homarr/spotlight";
 import { useScopedI18n } from "@homarr/translation/client";
 
 import type { WidgetComponentProps } from "../../definition";
 import { NoIntegrationDataError } from "../../errors/no-data-integration";
 import classes from "./component.module.css";
+import searchClasses from "../search-button.module.css";
 
 const OVERSEERR_COLOR = "#ECB000";
 const JELLYSEERR_COLOR = "#6677CC";
@@ -93,83 +96,104 @@ export default function MediaServerWidget({
   const isTiny = width < 256;
 
   return (
-    <Stack
-      className="mediaRequests-stats-layout"
-      h="100%"
-      gap="xs"
-      p="sm"
-      align="center"
-      justify="space-between"
-      style={{ pointerEvents: isEditMode ? "none" : undefined }}
-    >
-      <Stack gap={4} w="100%">
-        <Text className="mediaRequests-stats-stats-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
-          {t("titles.stats.main")}
-        </Text>
-        <Grid className="mediaRequests-stats-stats-grid" gap={4} w="100%">
-          {data.map((stat) => (
-            <Grid.Col
-              className={combineClasses("mediaRequests-stats-stat-wrapper", `mediaRequests-stats-stat-${stat.name}`)}
-              key={stat.name}
-              span={isTiny ? 6 : 3}
-            >
-              <Tooltip label={t(`titles.stats.${stat.name}`)}>
-                <Card p={0} radius={board.itemRadius} className={classes.card}>
-                  <Group className="mediaRequests-stats-stat-stack" justify="center" align="center" gap="xs" w="100%">
-                    <stat.icon className="mediaRequests-stats-stat-icon" size={16} />
-                    <Text className="mediaRequests-stats-stat-value" size="md">
-                      {stat.number}
+    <Box className={searchClasses.searchRoot}>
+      {!isEditMode && <MediaRequestSearchButton integrationIds={integrationIds} />}
+      <Stack
+        className="mediaRequests-stats-layout"
+        h="100%"
+        gap="xs"
+        p="sm"
+        align="center"
+        justify="space-between"
+        style={{ pointerEvents: isEditMode ? "none" : undefined }}
+      >
+        <Stack gap={4} w="100%">
+          <Text className="mediaRequests-stats-stats-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
+            {t("titles.stats.main")}
+          </Text>
+          <Grid className="mediaRequests-stats-stats-grid" gap={4} w="100%">
+            {data.map((stat) => (
+              <Grid.Col
+                className={combineClasses("mediaRequests-stats-stat-wrapper", `mediaRequests-stats-stat-${stat.name}`)}
+                key={stat.name}
+                span={isTiny ? 6 : 3}
+              >
+                <Tooltip label={t(`titles.stats.${stat.name}`)}>
+                  <Card p={0} radius={board.itemRadius} className={classes.card}>
+                    <Group className="mediaRequests-stats-stat-stack" justify="center" align="center" gap="xs" w="100%">
+                      <stat.icon className="mediaRequests-stats-stat-icon" size={16} />
+                      <Text className="mediaRequests-stats-stat-value" size="md">
+                        {stat.number}
+                      </Text>
+                    </Group>
+                  </Card>
+                </Tooltip>
+              </Grid.Col>
+            ))}
+          </Grid>
+        </Stack>
+        <Stack gap={4} w="100%">
+          <Text className="mediaRequests-stats-users-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
+            {t("titles.users.main")} ({t("titles.users.requests")})
+          </Text>
+          <Stack className="mediaRequests-stats-users-wrapper" flex={1} w="100%" gap={4} style={{ overflow: "hidden" }}>
+            {requestStats.users.slice(0, 10).map((user) => (
+              <Card
+                component="a"
+                href={user.link}
+                target="_blank"
+                rel="noopener noreferrer"
+                className={combineClasses(
+                  "mediaRequests-stats-users-user-wrapper",
+                  `mediaRequests-stats-users-user-${user.id}`,
+                  classes.card,
+                )}
+                key={user.id}
+                p="xs"
+                radius={board.itemRadius}
+              >
+                <Group className="mediaRequests-stats-users-user-group" h="100%" p={0} gap="sm" justify="space-between">
+                  <Group gap={4}>
+                    <Tooltip label={user.integration.name}>
+                      <Avatar
+                        className="mediaRequests-stats-users-user-avatar"
+                        size={20}
+                        src={user.avatar}
+                        bd={`2px solid ${user.integration.kind === "overseerr" ? OVERSEERR_COLOR : JELLYSEERR_COLOR}`}
+                      />
+                    </Tooltip>
+                    <Text className="mediaRequests-stats-users-user-userName" size="sm">
+                      {user.displayName}
                     </Text>
                   </Group>
-                </Card>
-              </Tooltip>
-            </Grid.Col>
-          ))}
-        </Grid>
-      </Stack>
-      <Stack gap={4} w="100%">
-        <Text className="mediaRequests-stats-users-title" fw="bold" ta="center" size={isTiny ? "xs" : "sm"}>
-          {t("titles.users.main")} ({t("titles.users.requests")})
-        </Text>
-        <Stack className="mediaRequests-stats-users-wrapper" flex={1} w="100%" gap={4} style={{ overflow: "hidden" }}>
-          {requestStats.users.slice(0, 10).map((user) => (
-            <Card
-              component="a"
-              href={user.link}
-              target="_blank"
-              rel="noopener noreferrer"
-              className={combineClasses(
-                "mediaRequests-stats-users-user-wrapper",
-                `mediaRequests-stats-users-user-${user.id}`,
-                classes.card,
-              )}
-              key={user.id}
-              p="xs"
-              radius={board.itemRadius}
-            >
-              <Group className="mediaRequests-stats-users-user-group" h="100%" p={0} gap="sm" justify="space-between">
-                <Group gap={4}>
-                  <Tooltip label={user.integration.name}>
-                    <Avatar
-                      className="mediaRequests-stats-users-user-avatar"
-                      size={20}
-                      src={user.avatar}
-                      bd={`2px solid ${user.integration.kind === "overseerr" ? OVERSEERR_COLOR : JELLYSEERR_COLOR}`}
-                    />
-                  </Tooltip>
-                  <Text className="mediaRequests-stats-users-user-userName" size="sm">
-                    {user.displayName}
+
+                  <Text className="mediaRequests-stats-users-user-request-count" size="md" fw={500}>
+                    {user.requestCount}
                   </Text>
                 </Group>
-
-                <Text className="mediaRequests-stats-users-user-request-count" size="md" fw={500}>
-                  {user.requestCount}
-                </Text>
-              </Group>
-            </Card>
-          ))}
+              </Card>
+            ))}
+          </Stack>
         </Stack>
       </Stack>
-    </Stack>
+    </Box>
   );
 }
+
+const MediaRequestSearchButton = ({ integrationIds }: { integrationIds: string[] }) => {
+  const t = useScopedI18n("search.mode.media");
+
+  return (
+    <Tooltip label={t("action.search.label")}>
+      <ActionIcon
+        className={searchClasses.searchButton}
+        variant="light"
+        size="sm"
+        aria-label={t("action.search.label")}
+        onClick={() => openMediaRequestSearch({ integrationIds })}
+      >
+        <IconSearch size={16} />
+      </ActionIcon>
+    </Tooltip>
+  );
+};

pnpm-workspace.yaml

@@ -6,7 +6,7 @@ catalog:
   "@auth/core": ^0.41.2
   "@auth/drizzle-adapter": ^1.11.2
   "@ctrl/deluge": ^8.0.0
-  "@ctrl/qbittorrent": ^9.12.2
+  "@ctrl/qbittorrent": ^9.12.1
   "@ctrl/transmission": ^7.4.0
   "@dnd-kit/core": ^6.3.1
   "@dnd-kit/modifiers": ^9.0.0
@@ -20,17 +20,17 @@ catalog:
   "@immich/sdk": ^2.7.5
   "@jellyfin/sdk": ^0.13.0
   "@kubernetes/client-node": ^1.4.0
-  "@mantine/charts": ^9.2.2
-  "@mantine/colors-generator": ^9.2.2
-  "@mantine/core": ^9.2.2
-  "@mantine/dates": ^9.2.2
-  "@mantine/dropzone": ^9.2.2
-  "@mantine/form": ^9.2.2
-  "@mantine/hooks": ^9.2.2
-  "@mantine/modals": ^9.2.2
-  "@mantine/notifications": ^9.2.2
-  "@mantine/spotlight": ^9.2.2
-  "@mantine/tiptap": ^9.2.2
+  "@mantine/charts": ^9.2.1
+  "@mantine/colors-generator": ^9.2.1
+  "@mantine/core": ^9.2.1
+  "@mantine/dates": ^9.2.1
+  "@mantine/dropzone": ^9.2.1
+  "@mantine/form": ^9.2.1
+  "@mantine/hooks": ^9.2.1
+  "@mantine/modals": ^9.2.1
+  "@mantine/notifications": ^9.2.1
+  "@mantine/spotlight": ^9.2.1
+  "@mantine/tiptap": ^9.2.1
   "@next/eslint-plugin-next": 16.2.6
   "@octokit/auth-app": ^8.2.0
   "@paralleldrive/cuid2": ^3.3.0
@@ -43,34 +43,34 @@ catalog:
   "@semantic-release/release-notes-generator": ^14.1.1
   "@t3-oss/env-nextjs": ^0.13.11
   "@tabler/icons-react": ^3.44.0
-  "@tanstack/react-query": ^5.100.14
-  "@tanstack/react-query-devtools": ^5.100.14
-  "@tanstack/react-query-next-experimental": ^5.100.14
-  "@testcontainers/mysql": ^12.0.1
-  "@testcontainers/postgresql": ^12.0.1
-  "@testcontainers/redis": ^12.0.1
-  "@tiptap/extension-color": 3.24.0
-  "@tiptap/extension-highlight": 3.24.0
-  "@tiptap/extension-image": 3.24.0
-  "@tiptap/extension-link": ^3.24.0
-  "@tiptap/extension-placeholder": ^3.24.0
-  "@tiptap/extension-table": 3.24.0
-  "@tiptap/extension-table-cell": 3.24.0
-  "@tiptap/extension-table-header": 3.24.0
-  "@tiptap/extension-table-row": 3.24.0
-  "@tiptap/extension-task-item": 3.24.0
-  "@tiptap/extension-task-list": 3.24.0
-  "@tiptap/extension-text-align": 3.24.0
-  "@tiptap/extension-text-style": 3.24.0
-  "@tiptap/extension-underline": 3.24.0
-  "@tiptap/react": ^3.24.0
-  "@tiptap/starter-kit": ^3.24.0
+  "@tanstack/react-query": ^5.100.13
+  "@tanstack/react-query-devtools": ^5.100.13
+  "@tanstack/react-query-next-experimental": ^5.100.13
+  "@testcontainers/mysql": ^12.0.0
+  "@testcontainers/postgresql": ^12.0.0
+  "@testcontainers/redis": ^12.0.0
+  "@tiptap/extension-color": 3.23.6
+  "@tiptap/extension-highlight": 3.23.6
+  "@tiptap/extension-image": 3.23.6
+  "@tiptap/extension-link": ^3.23.6
+  "@tiptap/extension-placeholder": ^3.23.6
+  "@tiptap/extension-table": 3.23.6
+  "@tiptap/extension-table-cell": 3.23.6
+  "@tiptap/extension-table-header": 3.23.6
+  "@tiptap/extension-table-row": 3.23.6
+  "@tiptap/extension-task-item": 3.23.6
+  "@tiptap/extension-task-list": 3.23.6
+  "@tiptap/extension-text-align": 3.23.6
+  "@tiptap/extension-text-style": 3.23.6
+  "@tiptap/extension-underline": 3.23.6
+  "@tiptap/react": ^3.23.6
+  "@tiptap/starter-kit": ^3.23.6
   "@trpc/client": ^11.17.0
   "@trpc/next": ^11.17.0
   "@trpc/react-query": ^11.17.0
   "@trpc/server": ^11.17.0
   "@trpc/tanstack-react-query": ^11.17.0
-  "@turbo/gen": ^2.9.16
+  "@turbo/gen": ^2.9.14
   "@types/adm-zip": 0.5.8
   "@types/bcrypt": 6.0.0
   "@types/better-sqlite3": 7.6.13
@@ -109,7 +109,7 @@ catalog:
   croner: 10.0.1
   cross-env: ^10.1.0
   crypto-js: ^4.2.0
-  dayjs: ^1.11.21
+  dayjs: ^1.11.20
   deepmerge: 4.3.1
   dns-caching: ^0.2.9
   dockerode: ^5.0.0
@@ -124,30 +124,30 @@ catalog:
   flag-icons: ^7.5.0
   glob: ^13.0.6
   ical.js: ^2.2.1
-  ioredis: 5.11.0
-  isomorphic-dompurify: ^3.15.0
+  ioredis: 5.10.1
+  isomorphic-dompurify: ^3.14.0
   jotai: ^2.20.0
   jsdom: ^29.1.1
   json5: ^2.2.3
   ldapts: 8.1.8
   lodash.clonedeep: ^4.5.0
-  mantine-react-table: npm:mantine-react-table-open@9.0.3
+  mantine-react-table: 2.0.0-beta.9
   maria2: ^0.4.1
-  mysql2: 3.22.4
+  mysql2: 3.22.3
   next: 16.2.6
   next-auth: 5.0.0-beta.31
-  next-intl: 4.13.0
+  next-intl: 4.12.0
   node-loader: ^2.1.0
   octokit: ^5.0.5
-  oxfmt: ^0.52.0
-  oxlint: ^1.67.0
+  oxfmt: ^0.51.0
+  oxlint: ^1.66.0
   pg: ^8.21.0
   postcss-preset-mantine: ^1.18.0
   prismjs: ^1.30.0
   proxmox-api: 1.1.1
   react: 19.2.6
   react-dom: 19.2.6
-  react-error-boundary: ^6.1.2
+  react-error-boundary: ^6.1.1
   react-markdown: ^10.1.0
   react-quill-new: ^3.8.3
   react-simple-code-editor: ^0.14.1
@@ -158,12 +158,12 @@ catalog:
   superjson: 2.2.6
   svgson: ^5.3.1
   swagger-ui-react: ^5.32.6
-  testcontainers: ^12.0.1
+  testcontainers: ^12.0.0
   timezones-ical-library: ^2.2.0
   trpc-to-openapi: ^3.3.0
   tsdav: ^2.2.2
   tsx: 4.20.4
-  turbo: ^2.9.16
+  turbo: ^2.9.14
   typescript: ^5.9.3
   undici: 7.24.6
   use-deep-compare-effect: ^1.8.1