refactor: trim v2 hardening scaffolding

This commit is contained in:
ajnart committed 2026-07-30 15:19:17 +02:00
1 parent ecfb9d59e0
commit 2eb0baf17e
75 files changed
+334 -2067

No files matched your search

-4
View File
@@ -21,8 +21,6 @@ export const env = createEnv({
KUBERNETES_SERVICE_ACCOUNT_NAME: z.string().optional(),
DEMO_MODE: createBooleanSchema(false),
DEMO_READ_ONLY: createBooleanSchema(true),
CUSTOM_WIDGETS_ENABLED: createBooleanSchema(true),
WORKSHOP_ENABLED: createBooleanSchema(true),
HOMARR_WEBSITE_URL: publicHttpUrl("HOMARR_WEBSITE_URL").default("https://homarr.dev"),
WORKSHOP_API_URL: publicHttpUrl("WORKSHOP_API_URL").optional(),
},
@@ -30,8 +28,6 @@ export const env = createEnv({
KUBERNETES_SERVICE_ACCOUNT_NAME: process.env.KUBERNETES_SERVICE_ACCOUNT_NAME,
DEMO_MODE: process.env.DEMO_MODE,
DEMO_READ_ONLY: process.env.DEMO_READ_ONLY,
CUSTOM_WIDGETS_ENABLED: process.env.CUSTOM_WIDGETS_ENABLED,
WORKSHOP_ENABLED: process.env.WORKSHOP_ENABLED,
HOMARR_WEBSITE_URL: process.env.HOMARR_WEBSITE_URL,
WORKSHOP_API_URL: process.env.WORKSHOP_API_URL,
},
+1 -8
View File
@@ -59,7 +59,6 @@ import { zodUnionFromArray } from "@homarr/validation/enums";
import type { BoardItemAdvancedOptions } from "@homarr/validation/shared";
import { sectionSchema, sharedItemSchema } from "@homarr/validation/shared";
import { env } from "../env";
import { createTRPCRouter, permissionRequiredProcedure, protectedProcedure, publicProcedure } from "../trpc";
import { throwIfActionForbiddenAsync } from "./board/board-access";
import {
@@ -377,11 +376,7 @@ export const boardRouter = createTRPCRouter({
}
const { sections: boardSections, items: boardItems, layouts: boardLayouts, ...boardProps } = board;
throwIfCustomWidgetBoardDuplicationForbidden(
ctx.session.user.permissions.includes("admin"),
env.CUSTOM_WIDGETS_ENABLED !== false,
boardItems,
);
throwIfCustomWidgetBoardDuplicationForbidden(ctx.session.user.permissions.includes("admin"), boardItems);
const newBoardId = createId();
@@ -867,7 +862,6 @@ export const boardRouter = createTRPCRouter({
const dbBoard = await getFullBoardWithWhereAsync(ctx.db, eq(boards.id, input.id), ctx.session.user.id);
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: ctx.session.user.permissions.includes("admin"),
customWidgetsEnabled: env.CUSTOM_WIDGETS_ENABLED !== false,
submittedItems: input.items,
storedItems: dbBoard.items,
});
@@ -1458,7 +1452,6 @@ export const boardRouter = createTRPCRouter({
await throwIfActionForbiddenAsync(ctx, eq(boards.id, input.boardId), "modify");
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: ctx.session.user.permissions.includes("admin"),
customWidgetsEnabled: env.CUSTOM_WIDGETS_ENABLED !== false,
submittedItems: [{ id: "", kind: input.kind, options: input.options }],
storedItems: [],
});
@@ -10,7 +10,6 @@ interface BoardPlacement {
interface CustomWidgetPlacementGuardInput {
isAdmin: boolean;
customWidgetsEnabled: boolean;
submittedItems: readonly BoardPlacement[];
storedItems: readonly BoardPlacement[];
}
@@ -22,15 +21,7 @@ const throwAdminRequired = () => {
});
};
const throwFeatureDisabled = () => {
throw new TRPCError({
code: "SERVICE_UNAVAILABLE",
message: "Custom Widgets are temporarily disabled by the server administrator",
});
};
const assertAuthoringAllowed = (isAdmin: boolean, customWidgetsEnabled: boolean) => {
if (!customWidgetsEnabled) throwFeatureDisabled();
const assertAuthoringAllowed = (isAdmin: boolean) => {
if (!isAdmin) throwAdminRequired();
};
@@ -41,7 +32,6 @@ const assertAuthoringAllowed = (isAdmin: boolean, customWidgetsEnabled: boolean)
*/
export const throwIfCustomWidgetPlacementChangeForbidden = ({
isAdmin,
customWidgetsEnabled,
submittedItems,
storedItems,
}: CustomWidgetPlacementGuardInput) => {
@@ -50,14 +40,14 @@ export const throwIfCustomWidgetPlacementChangeForbidden = ({
const stored = storedById.get(submitted.id);
if (!stored) {
if (submitted.kind === "customApi") assertAuthoringAllowed(isAdmin, customWidgetsEnabled);
if (submitted.kind === "customApi") assertAuthoringAllowed(isAdmin);
continue;
}
const wasCustomWidget = stored.kind === "customApi";
const isCustomWidget = submitted.kind === "customApi";
if (wasCustomWidget !== isCustomWidget) {
if (isCustomWidget) assertAuthoringAllowed(isAdmin, customWidgetsEnabled);
if (isCustomWidget) assertAuthoringAllowed(isAdmin);
else if (!isAdmin) throwAdminRequired();
continue;
}
@@ -65,17 +55,16 @@ export const throwIfCustomWidgetPlacementChangeForbidden = ({
wasCustomWidget &&
!isDeepStrictEqual(normalizeCustomWidgetOptions(submitted.options), normalizeCustomWidgetOptions(stored.options))
) {
assertAuthoringAllowed(isAdmin, customWidgetsEnabled);
assertAuthoringAllowed(isAdmin);
}
}
};
export const throwIfCustomWidgetBoardDuplicationForbidden = (
isAdmin: boolean,
customWidgetsEnabled: boolean,
items: readonly Pick<BoardPlacement, "kind">[],
) => {
if (items.some((item) => item.kind === "customApi")) assertAuthoringAllowed(isAdmin, customWidgetsEnabled);
if (items.some((item) => item.kind === "customApi")) assertAuthoringAllowed(isAdmin);
};
function normalizeCustomWidgetOptions(options: Record<string, unknown>) {
@@ -20,7 +20,6 @@ describe("Custom Widget placement access", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: false,
customWidgetsEnabled: true,
submittedItems: [{ ...placement, options: { ...placement.options, configurationVersion: 1 } }],
storedItems: [],
}),
@@ -39,7 +38,6 @@ describe("Custom Widget placement access", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: false,
customWidgetsEnabled: true,
submittedItems: [submitted],
storedItems: [placement],
}),
@@ -55,7 +53,6 @@ describe("Custom Widget placement access", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: false,
customWidgetsEnabled: true,
submittedItems: [submitted],
storedItems: [placement],
}),
@@ -66,7 +63,6 @@ describe("Custom Widget placement access", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: false,
customWidgetsEnabled: true,
submittedItems: [],
storedItems: [placement],
}),
@@ -77,7 +73,6 @@ describe("Custom Widget placement access", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: true,
customWidgetsEnabled: true,
submittedItems: [{ ...placement, options: { definitionId: "definition-2" } }],
storedItems: [],
}),
@@ -85,18 +80,17 @@ describe("Custom Widget placement access", () => {
});
test("duplicating a board with Custom Widgets requires admin", () => {
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(false, true, [placement])).toThrowError(
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(false, [placement])).toThrowError(
"Only administrators can add or configure Custom Widgets",
);
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(true, true, [placement])).not.toThrow();
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(false, true, [{ kind: "weather" }])).not.toThrow();
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(true, [placement])).not.toThrow();
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(false, [{ kind: "weather" }])).not.toThrow();
});
test("treats missing persisted v2 defaults as equivalent during presentation-only edits", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: false,
customWidgetsEnabled: true,
submittedItems: [placement],
storedItems: [
{
@@ -112,26 +106,4 @@ describe("Custom Widget placement access", () => {
}),
).not.toThrow();
});
test("blocks authoring but still allows removal while the emergency switch is off", () => {
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: true,
customWidgetsEnabled: false,
submittedItems: [placement],
storedItems: [],
}),
).toThrowError("temporarily disabled");
expect(() =>
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: false,
customWidgetsEnabled: false,
submittedItems: [],
storedItems: [placement],
}),
).not.toThrow();
expect(() => throwIfCustomWidgetBoardDuplicationForbidden(true, false, [placement])).toThrowError(
"temporarily disabled",
);
});
});
@@ -14,7 +14,7 @@ import {
import { createTRPCRouter } from "../../trpc";
import { insertCustomWidgetDefinition } from "./definition-insert";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import { managementQueryProcedures } from "./management-queries";
import { metadataProcedures } from "./metadata-procedures";
import { previewActionProcedures } from "./preview-action-procedures";
@@ -37,7 +37,8 @@ export const customWidgetRouter = createTRPCRouter({
...metadataProcedures,
...managementQueryProcedures,
create: customWidgetAdminProcedure
create: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Create one validated Custom JSX widget." } })
.input(customWidgetCreateSchema)
.mutation(async ({ ctx, input }) => {
@@ -49,7 +50,8 @@ export const customWidgetRouter = createTRPCRouter({
return { id };
}),
update: customWidgetAdminProcedure
update: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Update one Custom JSX widget." } })
.input(customWidgetUpdateSchema)
.mutation(async ({ ctx, input }) => {
@@ -182,7 +184,8 @@ export const customWidgetRouter = createTRPCRouter({
...secretProcedures,
...workshopProcedures,
toggleEnabled: customWidgetAdminProcedure
toggleEnabled: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ id: z.string(), enabled: z.boolean() }))
.mutation(async ({ ctx, input }) => {
if (input.enabled) {
@@ -204,7 +207,8 @@ export const customWidgetRouter = createTRPCRouter({
.where(eq(customWidgetDefinitions.id, input.id));
}),
delete: customWidgetAdminProcedure
delete: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Delete one Custom JSX widget." } })
.input(z.object({ id: z.string() }))
.mutation(async ({ ctx, input }) => {
@@ -212,20 +216,23 @@ export const customWidgetRouter = createTRPCRouter({
logger.info("Deleted custom widget definition", { id: input.id });
}),
duplicate: customWidgetAdminProcedure.input(z.object({ id: z.string() })).mutation(async ({ ctx, input }) => {
const existing = await ctx.db.query.customWidgetDefinitions.findFirst({
where: eq(customWidgetDefinitions.id, input.id),
});
if (!existing) throw new TRPCError({ code: "NOT_FOUND" });
const current = parseStoredCustomWidgetDefinition(existing);
const id = createId();
await ctx.db.insert(customWidgetDefinitions).values({
id,
...serializeCustomWidgetDefinition({ ...current, name: `${current.name} (copy)` }),
creatorId: ctx.session.user.id,
});
return { id, name: `${current.name} (copy)` };
}),
duplicate: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ id: z.string() }))
.mutation(async ({ ctx, input }) => {
const existing = await ctx.db.query.customWidgetDefinitions.findFirst({
where: eq(customWidgetDefinitions.id, input.id),
});
if (!existing) throw new TRPCError({ code: "NOT_FOUND" });
const current = parseStoredCustomWidgetDefinition(existing);
const id = createId();
await ctx.db.insert(customWidgetDefinitions).values({
id,
...serializeCustomWidgetDefinition({ ...current, name: `${current.name} (copy)` }),
creatorId: ctx.session.user.id,
});
return { id, name: `${current.name} (copy)` };
}),
...templateProcedures,
...transferProcedures,
@@ -1,32 +0,0 @@
import { TRPCError } from "@trpc/server";
import { env } from "../../env";
import { permissionRequiredProcedure } from "../../trpc";
export function assertCustomWidgetsEnabled(): void {
// Environment validation is intentionally skipped in some build and test
// processes, where unset defaulted values are exposed as undefined.
if (env.CUSTOM_WIDGETS_ENABLED !== false) return;
throw new TRPCError({
code: "SERVICE_UNAVAILABLE",
message: "Custom Widgets are temporarily disabled by the server administrator",
});
}
export function assertWorkshopEnabled(): void {
if (env.WORKSHOP_ENABLED !== false) return;
throw new TRPCError({
code: "SERVICE_UNAVAILABLE",
message: "Workshop is temporarily disabled by the server administrator",
});
}
export const customWidgetAdminProcedure = permissionRequiredProcedure.requiresPermission("admin").use(({ next }) => {
assertCustomWidgetsEnabled();
return next();
});
export const workshopAdminProcedure = customWidgetAdminProcedure.use(({ next }) => {
assertWorkshopEnabled();
return next();
});
@@ -7,7 +7,7 @@ import { boards, customWidgetDefinitions, legacyCustomWidgetDefinitions } from "
import { collectCustomWidgetRequestReferences } from "@homarr/custom-widgets/core";
import { throwIfActionForbiddenAsync } from "../board/board-access";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import { parseStoredCustomWidgetDefinition } from "./stored-definition";
import { executeCustomWidgetRequest } from "./request-executor";
import {
@@ -27,7 +27,8 @@ import {
} from "./management-query-mappers";
export const managementQueryProcedures = {
list: customWidgetAdminProcedure
list: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "List all Custom JSX widgets." } })
.query(async ({ ctx }) => {
const [definitions, legacyDefinitions] = await Promise.all([
@@ -46,7 +47,8 @@ export const managementQueryProcedures = {
return [...current, ...legacy].toSorted((left, right) => left.name.localeCompare(right.name));
}),
legacyMigrationPrompt: customWidgetAdminProcedure
legacyMigrationPrompt: permissionRequiredProcedure
.requiresPermission("admin")
.meta({
mcp: {
enabled: true,
@@ -71,7 +73,8 @@ export const managementQueryProcedures = {
};
}),
get: customWidgetAdminProcedure
get: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Get one Custom JSX widget without secret values." } })
.input(z.object({ id: z.string() }))
.query(async ({ ctx, input }) => {
@@ -95,7 +98,8 @@ export const managementQueryProcedures = {
};
}),
available: customWidgetAdminProcedure
available: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ boardId: z.string(), currentId: z.string().optional() }))
.query(async ({ ctx, input }) => {
await throwIfActionForbiddenAsync(ctx, eq(boards.id, input.boardId), "modify");
@@ -114,7 +118,8 @@ export const managementQueryProcedures = {
return [...available, mapLegacyAvailableCustomWidget(legacy)];
}),
optionRequest: customWidgetAdminProcedure
optionRequest: permissionRequiredProcedure
.requiresPermission("admin")
.input(
z.object({
boardId: z.string(),
@@ -4,14 +4,16 @@ import { CUSTOM_WIDGET_MCP_AUTHORING_PROMPT } from "@homarr/custom-widgets/autho
import { getCustomWidgetSkill } from "@homarr/custom-widgets/authoring-resources";
import { customWidgetImportSchema, getCustomWidgetJsonSchema } from "@homarr/custom-widgets/core";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
export const metadataProcedures = {
schema: customWidgetAdminProcedure
schema: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Get the current Custom JSX widget JSON Schema." } })
.query(() => getCustomWidgetJsonSchema()),
getAuthoringPrompt: customWidgetAdminProcedure
getAuthoringPrompt: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Get the current Custom Widget authoring instructions." } })
.query(() => ({
version: 2,
@@ -24,11 +26,13 @@ export const metadataProcedures = {
httpResources: ["/api/custom-widgets/schema", "/api/custom-widgets/components", "/api/custom-widgets/skill"],
})),
getSkill: customWidgetAdminProcedure
getSkill: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Get the portable Homarr Custom Widget skill." } })
.query(() => getCustomWidgetSkill()),
validate: customWidgetAdminProcedure
validate: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Validate one Custom JSX widget without saving it." } })
.input(z.object({ widget: z.unknown() }))
.query(({ input }) => {
@@ -1,7 +1,7 @@
import { TRPCError } from "@trpc/server";
import { z } from "zod/v4";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import {
getPreviewRequestSource,
previewSessionRequestSchema,
@@ -13,7 +13,8 @@ import { acquireCustomWidgetRequestLimit } from "./request-limits";
import { getPreviewSession } from "./preview-sessions";
export const previewActionProcedures = {
previewAction: customWidgetAdminProcedure
previewAction: permissionRequiredProcedure
.requiresPermission("admin")
.meta({
mcp: { enabled: true, description: "Simulate or run one named action in a custom widget preview session." },
})
@@ -12,7 +12,7 @@ import {
import { eq } from "@homarr/db";
import { customWidgetDefinitions } from "@homarr/db/schema";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import { createPreviewSession, getPreviewSession } from "./preview-sessions";
import { hasSameSecretBinding, requiredSecretKinds } from "./secret-policy";
import { parseStoredCustomWidgetDefinition } from "./stored-definition";
@@ -24,7 +24,8 @@ const previewCreateInputSchema = z.object({
options: z.record(z.string(), z.unknown()).optional(),
});
const previewCreateProcedure = customWidgetAdminProcedure
const previewCreateProcedure = permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Create a short-lived preview session for one unsaved custom widget." } })
.input(previewCreateInputSchema)
.mutation(async ({ ctx, input }) => {
@@ -118,25 +119,28 @@ const previewCreateProcedure = customWidgetAdminProcedure
export const previewBaseProcedures = {
previewCreate: previewCreateProcedure,
previewGet: customWidgetAdminProcedure.input(z.object({ sessionId: z.string() })).query(async ({ ctx, input }) => {
const session = await getPreviewSession(input.sessionId, ctx.session.user.id);
return {
id: session.id,
name: session.name,
expiresAt: session.expiresAt,
template: session.template,
optionDefinitions: session.optionDefinitions,
options: session.options,
requests: Object.entries(session.requests).map(([id, request]) => ({
id,
kind: request.kind,
method: request.method,
minimumBoardPermission: request.permission,
trigger: request.trigger,
confirmation: getCustomWidgetConfirmation(request),
invalidates: request.invalidates,
})),
liveActions: session.liveActions,
};
}),
previewGet: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ sessionId: z.string() }))
.query(async ({ ctx, input }) => {
const session = await getPreviewSession(input.sessionId, ctx.session.user.id);
return {
id: session.id,
name: session.name,
expiresAt: session.expiresAt,
template: session.template,
optionDefinitions: session.optionDefinitions,
options: session.options,
requests: Object.entries(session.requests).map(([id, request]) => ({
id,
kind: request.kind,
method: request.method,
minimumBoardPermission: request.permission,
trigger: request.trigger,
confirmation: getCustomWidgetConfirmation(request),
invalidates: request.invalidates,
})),
liveActions: session.liveActions,
};
}),
};
@@ -1,7 +1,7 @@
import { TRPCError } from "@trpc/server";
import { z } from "zod/v4";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import {
getPreviewRequestSource,
previewSessionRequestSchema,
@@ -15,7 +15,8 @@ import { acquireCustomWidgetRequestLimit } from "./request-limits";
import { getPreviewJournal, getPreviewSession, setPreviewSessionLiveActions } from "./preview-sessions";
export const previewQueryProcedures = {
previewQuery: customWidgetAdminProcedure
previewQuery: permissionRequiredProcedure
.requiresPermission("admin")
.meta({
mcp: {
enabled: true,
@@ -76,7 +77,8 @@ export const previewQueryProcedures = {
};
}),
previewRefresh: customWidgetAdminProcedure
previewRefresh: permissionRequiredProcedure
.requiresPermission("admin")
.input(
z.object({
sessionId: z.string().min(1),
@@ -109,13 +111,15 @@ export const previewQueryProcedures = {
return { requestIds };
}),
setPreviewLiveActions: customWidgetAdminProcedure
setPreviewLiveActions: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ sessionId: z.string().min(1), enabled: z.boolean() }))
.mutation(async ({ ctx, input }) =>
setPreviewSessionLiveActions(input.sessionId, ctx.session.user.id, input.enabled),
),
previewJournal: customWidgetAdminProcedure
previewJournal: permissionRequiredProcedure
.requiresPermission("admin")
.meta({
mcp: {
enabled: true,
@@ -18,7 +18,6 @@ import type { CustomWidgetHttpRequest, CustomWidgetHttpResponse } from "@homarr/
import { CustomWidgetDomainError } from "@homarr/custom-widgets/server";
import { toTrpcError } from "./domain-error";
import { assertCustomWidgetsEnabled } from "./feature-flags";
import { invalidateCustomWidgetResponseCache, withCustomWidgetResponseCache } from "./response-cache";
export type {
@@ -84,7 +83,6 @@ export async function executeCustomWidgetRequest(
input: CustomWidgetHttpRequest,
options: CustomWidgetRequestExecutionOptions = {},
): Promise<CustomWidgetHttpResponse> {
assertCustomWidgetsEnabled();
try {
return await withCustomWidgetResponseCache(input, async () => {
const release = await options.acquireRequestLimit?.();
@@ -10,7 +10,7 @@ import {
} from "@homarr/custom-widgets/core";
import type { CustomWidgetSource } from "@homarr/custom-widgets/core";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import {
createCustomWidgetConfigurationRequest,
getCustomWidgetConfigurationRequestForUser,
@@ -41,7 +41,8 @@ const secretRequestInputSchema = z
});
export const secretProcedures = {
secretSet: customWidgetAdminProcedure
secretSet: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Set one encrypted secret for a custom widget source." } })
.input(z.object({ definitionId: z.string(), secret: customWidgetSecretInputSchema }))
.mutation(async ({ ctx, input }) => {
@@ -55,7 +56,8 @@ export const secretProcedures = {
return { sourceId: input.secret.sourceId, kind: input.secret.kind, isSet: true };
}),
sourceConfigure: customWidgetAdminProcedure
sourceConfigure: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Configure one custom widget API source and its credentials." } })
.input(
z.object({
@@ -96,7 +98,8 @@ export const secretProcedures = {
};
}),
configurationRequestUser: customWidgetAdminProcedure
configurationRequestUser: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Create or check a short-lived user source-configuration request." } })
.input(secretRequestInputSchema)
.mutation(async ({ ctx, input }) => {
@@ -159,7 +162,8 @@ export const secretProcedures = {
};
}),
secretClear: customWidgetAdminProcedure
secretClear: permissionRequiredProcedure
.requiresPermission("admin")
.input(
z.object({ definitionId: z.string(), sourceId: z.string(), kind: z.enum(["apiKey", "username", "password"]) }),
)
@@ -8,7 +8,7 @@ import { customWidgetDefinitionSchema } from "@homarr/custom-widgets/core";
import { and, eq } from "@homarr/db";
import { customWidgetDefinitions } from "@homarr/db/schema";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import { parseStoredCustomWidgetDefinition } from "./stored-definition";
const logger = createLogger({ module: "custom-widget" });
@@ -32,22 +32,26 @@ const validateTemplate = (definition: ReturnType<typeof parseStoredCustomWidgetD
};
export const templateProcedures = {
readTemplate: customWidgetAdminProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
const definition = await ctx.db.query.customWidgetDefinitions.findFirst({
where: eq(customWidgetDefinitions.id, input.id),
});
if (!definition) throw new TRPCError({ code: "NOT_FOUND", message: "Custom widget definition not found" });
const template = parseStoredCustomWidgetDefinition(definition).template;
return {
id: definition.id,
name: definition.name,
template,
templateLines: template.split("\n"),
revision: getTemplateRevision(template),
};
}),
readTemplate: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ id: z.string() }))
.query(async ({ ctx, input }) => {
const definition = await ctx.db.query.customWidgetDefinitions.findFirst({
where: eq(customWidgetDefinitions.id, input.id),
});
if (!definition) throw new TRPCError({ code: "NOT_FOUND", message: "Custom widget definition not found" });
const template = parseStoredCustomWidgetDefinition(definition).template;
return {
id: definition.id,
name: definition.name,
template,
templateLines: template.split("\n"),
revision: getTemplateRevision(template),
};
}),
writeTemplate: customWidgetAdminProcedure
writeTemplate: permissionRequiredProcedure
.requiresPermission("admin")
.input(
z
.object({ id: z.string(), template: z.string().optional(), templateLines: z.array(z.string()).optional() })
@@ -73,7 +77,8 @@ export const templateProcedures = {
return { id: input.id, template, templateLines: template.split("\n"), revision: getTemplateRevision(template) };
}),
templatePatch: customWidgetAdminProcedure
templatePatch: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Patch selected JSX template lines using an optimistic revision." } })
.input(
z.object({
@@ -8,22 +8,26 @@ import { customWidgetDefinitions, customWidgetSecrets, legacyCustomWidgetDefinit
import { customWidgetImportSchema, customWidgetSecretsInputSchema } from "@homarr/custom-widgets/core";
import { insertCustomWidgetDefinition } from "./definition-insert";
import { customWidgetAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import { assertSecretSources, requiredSecretKinds } from "./secret-policy";
import { parseStoredCustomWidgetDefinition, serializeCustomWidgetDefinition } from "./stored-definition";
const logger = createLogger({ module: "custom-widget" });
export const transferProcedures = {
export: customWidgetAdminProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
const definition = await ctx.db.query.customWidgetDefinitions.findFirst({
where: eq(customWidgetDefinitions.id, input.id),
});
if (!definition) throw new TRPCError({ code: "NOT_FOUND" });
return parseStoredCustomWidgetDefinition(definition);
}),
export: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ id: z.string() }))
.query(async ({ ctx, input }) => {
const definition = await ctx.db.query.customWidgetDefinitions.findFirst({
where: eq(customWidgetDefinitions.id, input.id),
});
if (!definition) throw new TRPCError({ code: "NOT_FOUND" });
return parseStoredCustomWidgetDefinition(definition);
}),
import: customWidgetAdminProcedure
import: permissionRequiredProcedure
.requiresPermission("admin")
.input(z.object({ widget: customWidgetImportSchema, secrets: customWidgetSecretsInputSchema.default([]) }))
.mutation(async ({ ctx, input }) => {
assertSecretSources(input.widget.sources, input.secrets);
@@ -32,7 +36,8 @@ export const transferProcedures = {
return { id };
}),
migrateLegacy: customWidgetAdminProcedure
migrateLegacy: permissionRequiredProcedure
.requiresPermission("admin")
.meta({
mcp: {
enabled: true,
@@ -15,7 +15,7 @@ import { WorkshopBackend } from "@homarr/workshop/backend";
import { resolveHomarrUrlConfig, validateWorkshopWidget } from "@homarr/workshop/schema";
import { env } from "../../env";
import { workshopAdminProcedure } from "./feature-flags";
import { permissionRequiredProcedure } from "../../trpc";
import { insertCustomWidgetDefinition } from "./definition-insert";
import { assertSecretSources } from "./secret-policy";
@@ -75,7 +75,8 @@ const sourceOverridesSchema = z.record(
);
export const workshopProcedures = {
workshopSearch: workshopAdminProcedure
workshopSearch: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Search Workshop for Custom JSX widgets." } })
.input(workshopSearchInputSchema)
.query(async ({ input }) => {
@@ -107,7 +108,8 @@ export const workshopProcedures = {
}
}),
workshopGet: workshopAdminProcedure
workshopGet: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Get and validate one Workshop Custom JSX widget." } })
.input(z.object({ submissionId: z.string().min(1) }))
.query(async ({ input }) => {
@@ -131,7 +133,8 @@ export const workshopProcedures = {
};
}),
workshopInstall: workshopAdminProcedure
workshopInstall: permissionRequiredProcedure
.requiresPermission("admin")
.meta({ mcp: { enabled: true, description: "Install one validated Workshop Custom JSX widget." } })
.input(
z.object({
@@ -1,5 +1,5 @@
import SuperJSON from "superjson";
import { beforeEach, describe, expect, test, vi } from "vitest";
import { describe, expect, test } from "vitest";
import type { Session } from "@homarr/auth";
import { createId } from "@homarr/common";
@@ -7,9 +7,6 @@ import { eq } from "@homarr/db";
import { boards, items, users } from "@homarr/db/schema";
import { createDb } from "@homarr/db/test";
const mocks = vi.hoisted(() => ({ env: { CUSTOM_WIDGETS_ENABLED: true } }));
vi.mock("../../../env", () => ({ env: mocks.env }));
import { optionsRouter } from "../../widgets/options";
const createSession = (userId: string, isAdmin = false): Session => ({
@@ -42,10 +39,6 @@ async function setup(kind: "customApi" | "weather") {
}
describe("saveItemOptions Custom Widget access", () => {
beforeEach(() => {
mocks.env.CUSTOM_WIDGETS_ENABLED = true;
});
test("rejects direct Custom Widget reconfiguration by a non-admin board modifier", async () => {
const { db, userId, boardId, itemId } = await setup("customApi");
const caller = optionsRouter.createCaller({ db, deviceType: undefined, session: createSession(userId) });
@@ -82,16 +75,6 @@ describe("saveItemOptions Custom Widget access", () => {
expect(SuperJSON.parse(stored?.options ?? "")).toMatchObject({ refreshInterval: 60 });
});
test("rejects direct admin reconfiguration while the emergency switch is off", async () => {
const { db, userId, boardId, itemId } = await setup("customApi");
mocks.env.CUSTOM_WIDGETS_ENABLED = false;
const caller = optionsRouter.createCaller({ db, deviceType: undefined, session: createSession(userId, true) });
await expect(
caller.saveItemOptions({ boardId, itemId, newOptions: { refreshInterval: 60 } }),
).rejects.toMatchObject({ code: "SERVICE_UNAVAILABLE" });
});
test("allows normalized missing defaults without treating them as reconfiguration", async () => {
const { db, userId, boardId, itemId } = await setup("customApi");
const stored = await db.query.items.findFirst({ where: eq(items.id, itemId) });
@@ -16,7 +16,6 @@ import { CUSTOM_WIDGET_USER_ITEM_CONCURRENCY_LIMIT } from "@homarr/custom-widget
import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
import { throwIfActionForbiddenAsync } from "../board/board-access";
import { assertCustomWidgetsEnabled } from "../custom-widget/feature-flags";
import { executeCustomWidgetRequest, invalidateCustomWidgetResponseCache } from "../custom-widget/request-executor";
import {
hashRuntimeParams,
@@ -73,7 +72,6 @@ const parseItemOptions = (raw: string): CustomWidgetItemOptions => {
};
async function resolvePlacedDefinitionAsync(ctx: RouterContext, itemId: string) {
assertCustomWidgetsEnabled();
const item = await ctx.db.query.items.findFirst({
where: eq(items.id, itemId),
columns: { id: true, boardId: true, kind: true, options: true },
@@ -7,7 +7,6 @@ import { getServerSettingsAsync } from "@homarr/db/queries";
import { boards, items } from "@homarr/db/schema";
import type { WidgetOptionsSettings } from "../../../../widgets/src";
import { env } from "../../env";
import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
import { throwIfActionForbiddenAsync } from "../board/board-access";
import { throwIfCustomWidgetPlacementChangeForbidden } from "../board/custom-widget-placement-access";
@@ -51,7 +50,6 @@ export const optionsRouter = createTRPCRouter({
const updatedOptions = { ...options, ...input.newOptions };
throwIfCustomWidgetPlacementChangeForbidden({
isAdmin: ctx.session.user.permissions.includes("admin"),
customWidgetsEnabled: env.CUSTOM_WIDGETS_ENABLED !== false,
submittedItems: [{ id: item.id, kind: item.kind, options: updatedOptions }],
storedItems: [{ id: item.id, kind: item.kind, options }],
});