🙌 OpenHands: AI-Driven Development
feat: secrets manager settings (#8068)
sp.wack04d585513c89
diff --git a/frontend/__tests__/routes/secrets-settings.test.tsx b/frontend/__tests__/routes/secrets-settings.test.tsxnew file mode 100644index 0000000000..984257918e--- /dev/null+++ b/frontend/__tests__/routes/secrets-settings.test.tsx@@ -0,0 +1,565 @@+import { render, screen, waitFor, within } from "@testing-library/react";+import { beforeEach, describe, expect, it, vi } from "vitest";+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";+import userEvent from "@testing-library/user-event";+import { createRoutesStub, Outlet } from "react-router";+import SecretsSettingsScreen from "#/routes/secrets-settings";+import { SecretsService } from "#/api/secrets-service";+import { GetSecretsResponse } from "#/api/secrets-service.types";+import OpenHands from "#/api/open-hands";+import { MOCK_DEFAULT_USER_SETTINGS } from "#/mocks/handlers";++const MOCK_GET_SECRETS_RESPONSE: GetSecretsResponse["custom_secrets"] = [+ {+ name: "My_Secret_1",+ description: "My first secret",+ },+ {+ name: "My_Secret_2",+ description: "My second secret",+ },+];++const RouterStub = createRoutesStub([+ {+ Component: Outlet,+ path: "/settings",+ children: [+ {+ Component: SecretsSettingsScreen,+ path: "/settings/secrets",+ },+ {+ Component: () => <div data-testid="git-settings-screen" />,+ path: "/settings/git",+ },+ ],+ },+]);++const renderSecretsSettings = () =>+ render(<RouterStub initialEntries={["/settings/secrets"]} />, {+ wrapper: ({ children }) => (+ <QueryClientProvider+ client={+ new QueryClient({+ defaultOptions: { queries: { retry: false } },+ })+ }+ >+ {children}+ </QueryClientProvider>+ ),+ });++beforeEach(() => {+ const getConfigSpy = vi.spyOn(OpenHands, "getConfig");+ // @ts-expect-error - only return the config we need+ getConfigSpy.mockResolvedValue({+ APP_MODE: "oss",+ });+});++describe("Content", () => {+ it("should render the secrets settings screen", () => {+ renderSecretsSettings();+ screen.getByTestId("secrets-settings-screen");+ });++ it("should NOT render a button to connect with git if they havent already in oss", async () => {+ const getConfigSpy = vi.spyOn(OpenHands, "getConfig");+ const getSettingsSpy = vi.spyOn(OpenHands, "getSettings");+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ // @ts-expect-error - only return the config we need+ getConfigSpy.mockResolvedValue({+ APP_MODE: "oss",+ });+ getSettingsSpy.mockResolvedValue({+ ...MOCK_DEFAULT_USER_SETTINGS,+ provider_tokens_set: {},+ });++ renderSecretsSettings();++ expect(getConfigSpy).toHaveBeenCalled();+ await waitFor(() => expect(getSecretsSpy).toHaveBeenCalled());+ expect(screen.queryByTestId("connect-git-button")).not.toBeInTheDocument();+ });++ it("should render a button to connect with git if they havent already in saas", async () => {+ const getConfigSpy = vi.spyOn(OpenHands, "getConfig");+ const getSettingsSpy = vi.spyOn(OpenHands, "getSettings");+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ // @ts-expect-error - only return the config we need+ getConfigSpy.mockResolvedValue({+ APP_MODE: "saas",+ });+ getSettingsSpy.mockResolvedValue({+ ...MOCK_DEFAULT_USER_SETTINGS,+ provider_tokens_set: {},+ });++ renderSecretsSettings();++ expect(getSecretsSpy).not.toHaveBeenCalled();+ await waitFor(() =>+ expect(screen.queryByTestId("add-secret-button")).not.toBeInTheDocument(),+ );+ const button = await screen.findByTestId("connect-git-button");+ await userEvent.click(button);++ screen.getByTestId("git-settings-screen");+ });++ it("should render a message if there are no existing secrets", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ getSecretsSpy.mockResolvedValue([]);+ renderSecretsSettings();++ await screen.findByTestId("no-secrets-message");+ });++ it("should render existing secrets", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ renderSecretsSettings();++ const secrets = await screen.findAllByTestId("secret-item");+ expect(secrets).toHaveLength(2);+ expect(screen.queryByTestId("no-secrets-message")).not.toBeInTheDocument();+ });+});++describe("Secret actions", () => {+ it("should create a new secret", async () => {+ const createSecretSpy = vi.spyOn(SecretsService, "createSecret");+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ createSecretSpy.mockResolvedValue(true);+ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);++ const secretForm = screen.getByTestId("add-secret-form");+ const secrets = screen.queryAllByTestId("secret-item");++ expect(screen.queryByTestId("add-secret-button")).not.toBeInTheDocument();+ expect(secretForm).toBeInTheDocument();+ expect(secrets).toHaveLength(0);++ // enter details+ const nameInput = within(secretForm).getByTestId("name-input");+ const valueInput = within(secretForm).getByTestId("value-input");+ const descriptionInput =+ within(secretForm).getByTestId("description-input");++ const submitButton = within(secretForm).getByTestId("submit-button");++ vi.clearAllMocks(); // reset mocks to check for upcoming calls++ await userEvent.type(nameInput, "My_Custom_Secret");+ await userEvent.type(valueInput, "my-custom-secret-value");+ await userEvent.type(descriptionInput, "My custom secret description");++ await userEvent.click(submitButton);++ // make POST request+ expect(createSecretSpy).toHaveBeenCalledWith(+ "My_Custom_Secret",+ "my-custom-secret-value",+ "My custom secret description",+ );++ // hide form & render items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ expect(getSecretsSpy).toHaveBeenCalled();+ });++ it("should edit a secret", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ const updateSecretSpy = vi.spyOn(SecretsService, "updateSecret");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ updateSecretSpy.mockResolvedValue(true);+ renderSecretsSettings();++ // render edit button within a secret list item+ const secrets = await screen.findAllByTestId("secret-item");+ const firstSecret = within(secrets[0]);+ const editButton = firstSecret.getByTestId("edit-secret-button");++ await userEvent.click(editButton);++ // render edit form+ const editForm = screen.getByTestId("edit-secret-form");++ expect(screen.queryByTestId("add-secret-button")).not.toBeInTheDocument();+ expect(editForm).toBeInTheDocument();+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(0);++ // enter details+ const nameInput = within(editForm).getByTestId("name-input");+ const descriptionInput = within(editForm).getByTestId("description-input");+ const submitButton = within(editForm).getByTestId("submit-button");++ // should not show value input+ const valueInput = within(editForm).queryByTestId("value-input");+ expect(valueInput).not.toBeInTheDocument();++ expect(nameInput).toHaveValue("My_Secret_1");+ expect(descriptionInput).toHaveValue("My first secret");++ await userEvent.clear(nameInput);+ await userEvent.type(nameInput, "My_Edited_Secret");++ await userEvent.clear(descriptionInput);+ await userEvent.type(descriptionInput, "My edited secret description");++ await userEvent.click(submitButton);++ // make POST request+ expect(updateSecretSpy).toHaveBeenCalledWith(+ "My_Secret_1",+ "My_Edited_Secret",+ "My edited secret description",+ );++ // hide form+ expect(screen.queryByTestId("edit-secret-form")).not.toBeInTheDocument();++ // optimistic update+ const updatedSecrets = await screen.findAllByTestId("secret-item");+ expect(updatedSecrets).toHaveLength(2);+ expect(updatedSecrets[0]).toHaveTextContent(/my_edited_secret/i);+ });++ it("should be able to cancel the create or edit form", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);+ const secretForm = screen.getByTestId("add-secret-form");+ expect(secretForm).toBeInTheDocument();++ // cancel button+ const cancelButton = within(secretForm).getByTestId("cancel-button");+ await userEvent.click(cancelButton);+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ expect(screen.queryByTestId("add-secret-button")).toBeInTheDocument();++ // render edit button within a secret list item+ const secrets = await screen.findAllByTestId("secret-item");+ const firstSecret = within(secrets[0]);+ const editButton = firstSecret.getByTestId("edit-secret-button");+ await userEvent.click(editButton);++ // render edit form+ const editForm = screen.getByTestId("edit-secret-form");+ expect(editForm).toBeInTheDocument();+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(0);++ // cancel button+ const cancelEditButton = within(editForm).getByTestId("cancel-button");+ await userEvent.click(cancelEditButton);+ expect(screen.queryByTestId("edit-secret-form")).not.toBeInTheDocument();+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(2);+ });++ it("should undo the optimistic update if the request fails", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ const updateSecretSpy = vi.spyOn(SecretsService, "updateSecret");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ updateSecretSpy.mockRejectedValue(new Error("Failed to update secret"));+ renderSecretsSettings();++ // render edit button within a secret list item+ const secrets = await screen.findAllByTestId("secret-item");+ const firstSecret = within(secrets[0]);+ const editButton = firstSecret.getByTestId("edit-secret-button");++ await userEvent.click(editButton);++ // render edit form+ const editForm = screen.getByTestId("edit-secret-form");++ expect(editForm).toBeInTheDocument();+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(0);++ // enter details+ const nameInput = within(editForm).getByTestId("name-input");+ const submitButton = within(editForm).getByTestId("submit-button");++ // should not show value input+ const valueInput = within(editForm).queryByTestId("value-input");+ expect(valueInput).not.toBeInTheDocument();++ await userEvent.clear(nameInput);+ await userEvent.type(nameInput, "My_Edited_Secret");+ await userEvent.click(submitButton);++ // make POST request+ expect(updateSecretSpy).toHaveBeenCalledWith(+ "My_Secret_1",+ "My_Edited_Secret",+ "My first secret",+ );++ // hide form+ expect(screen.queryByTestId("edit-secret-form")).not.toBeInTheDocument();++ // no optimistic update+ const updatedSecrets = await screen.findAllByTestId("secret-item");+ expect(updatedSecrets).toHaveLength(2);+ expect(updatedSecrets[0]).not.toHaveTextContent(/my edited secret/i);+ });++ it("should remove the secret from the list after deletion", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ const deleteSecretSpy = vi.spyOn(SecretsService, "deleteSecret");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ deleteSecretSpy.mockResolvedValue(true);+ renderSecretsSettings();++ // render delete button within a secret list item+ const secrets = await screen.findAllByTestId("secret-item");+ const secondSecret = within(secrets[1]);+ const deleteButton = secondSecret.getByTestId("delete-secret-button");+ await userEvent.click(deleteButton);++ // confirmation modal+ const confirmationModal = screen.getByTestId("confirmation-modal");+ const confirmButton =+ within(confirmationModal).getByTestId("confirm-button");+ await userEvent.click(confirmButton);++ // make DELETE request+ expect(deleteSecretSpy).toHaveBeenCalledWith("My_Secret_2");+ expect(screen.queryByTestId("confirmation-modal")).not.toBeInTheDocument();++ // optimistic update+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(1);+ expect(screen.queryByText("My_Secret_2")).not.toBeInTheDocument();+ });++ it("should be able to cancel the delete confirmation modal", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ const deleteSecretSpy = vi.spyOn(SecretsService, "deleteSecret");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ deleteSecretSpy.mockResolvedValue(true);+ renderSecretsSettings();++ // render delete button within a secret list item+ const secrets = await screen.findAllByTestId("secret-item");+ const secondSecret = within(secrets[1]);+ const deleteButton = secondSecret.getByTestId("delete-secret-button");+ await userEvent.click(deleteButton);++ // confirmation modal+ const confirmationModal = screen.getByTestId("confirmation-modal");+ const cancelButton = within(confirmationModal).getByTestId("cancel-button");+ await userEvent.click(cancelButton);++ // no DELETE request+ expect(deleteSecretSpy).not.toHaveBeenCalled();+ expect(screen.queryByTestId("confirmation-modal")).not.toBeInTheDocument();+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(2);+ });++ it("should revert the optimistic update if the request fails", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ const deleteSecretSpy = vi.spyOn(SecretsService, "deleteSecret");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);+ deleteSecretSpy.mockRejectedValue(new Error("Failed to delete secret"));+ renderSecretsSettings();++ // render delete button within a secret list item+ const secrets = await screen.findAllByTestId("secret-item");+ const secondSecret = within(secrets[1]);+ const deleteButton = secondSecret.getByTestId("delete-secret-button");+ await userEvent.click(deleteButton);++ // confirmation modal+ const confirmationModal = screen.getByTestId("confirmation-modal");+ const confirmButton =+ within(confirmationModal).getByTestId("confirm-button");+ await userEvent.click(confirmButton);++ // make DELETE request+ expect(deleteSecretSpy).toHaveBeenCalledWith("My_Secret_2");+ expect(screen.queryByTestId("confirmation-modal")).not.toBeInTheDocument();++ // optimistic update+ expect(screen.queryAllByTestId("secret-item")).toHaveLength(2);+ expect(screen.queryByText("My_Secret_2")).toBeInTheDocument();+ });++ it("should hide the no items message when in form view", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ getSecretsSpy.mockResolvedValue([]);+ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("no-secrets-message")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);++ const secretForm = screen.getByTestId("add-secret-form");+ expect(secretForm).toBeInTheDocument();+ expect(screen.queryByTestId("no-secrets-message")).not.toBeInTheDocument();+ });++ it("should not allow spaces in secret names", async () => {+ const createSecretSpy = vi.spyOn(SecretsService, "createSecret");+ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);++ const secretForm = screen.getByTestId("add-secret-form");+ expect(secretForm).toBeInTheDocument();++ // enter details+ const nameInput = within(secretForm).getByTestId("name-input");+ const valueInput = within(secretForm).getByTestId("value-input");+ const submitButton = within(secretForm).getByTestId("submit-button");++ await userEvent.type(nameInput, "My Custom Secret With Spaces");+ await userEvent.type(valueInput, "my-custom-secret-value");+ await userEvent.click(submitButton);++ // make POST request+ expect(createSecretSpy).not.toHaveBeenCalled();++ await userEvent.clear(nameInput);+ await userEvent.type(nameInput, "MyCustomSecret");+ await userEvent.click(submitButton);++ expect(createSecretSpy).toHaveBeenCalledWith(+ "MyCustomSecret",+ "my-custom-secret-value",+ undefined,+ );+ });++ it("should not allow existing secret names", async () => {+ const createSecretSpy = vi.spyOn(SecretsService, "createSecret");+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE.slice(0, 1));+ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);++ const secretForm = screen.getByTestId("add-secret-form");+ expect(secretForm).toBeInTheDocument();++ // enter details+ const nameInput = within(secretForm).getByTestId("name-input");+ const valueInput = within(secretForm).getByTestId("value-input");+ const submitButton = within(secretForm).getByTestId("submit-button");++ await userEvent.type(nameInput, "My_Secret_1");+ await userEvent.type(valueInput, "my-custom-secret-value");+ await userEvent.click(submitButton);++ // make POST request+ expect(createSecretSpy).not.toHaveBeenCalled();+ expect(screen.queryByText(/secret already exists/i)).toBeInTheDocument();++ await userEvent.clear(nameInput);+ await userEvent.type(nameInput, "My_Custom_Secret");++ await userEvent.clear(valueInput);+ await userEvent.type(valueInput, "my-custom-secret-value");++ await userEvent.click(submitButton);++ expect(createSecretSpy).toHaveBeenCalledWith(+ "My_Custom_Secret",+ "my-custom-secret-value",+ undefined,+ );+ expect(+ screen.queryByText("SECRETS$SECRET_VALUE_REQUIRED"),+ ).not.toBeInTheDocument();+ });++ it("should not submit whitespace secret names or values", async () => {+ const createSecretSpy = vi.spyOn(SecretsService, "createSecret");+ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);++ const secretForm = screen.getByTestId("add-secret-form");+ expect(secretForm).toBeInTheDocument();++ // enter details+ const nameInput = within(secretForm).getByTestId("name-input");+ const valueInput = within(secretForm).getByTestId("value-input");+ const submitButton = within(secretForm).getByTestId("submit-button");++ await userEvent.type(nameInput, " ");+ await userEvent.type(valueInput, "my-custom-secret-value");+ await userEvent.click(submitButton);++ // make POST request+ expect(createSecretSpy).not.toHaveBeenCalled();++ await userEvent.clear(nameInput);+ await userEvent.type(nameInput, "My_Custom_Secret");++ await userEvent.clear(valueInput);+ await userEvent.type(valueInput, " ");++ await userEvent.click(submitButton);++ expect(createSecretSpy).not.toHaveBeenCalled();+ expect(+ screen.queryByText("SECRETS$SECRET_VALUE_REQUIRED"),+ ).toBeInTheDocument();+ });++ it("should not reset ipout values on an invalid submit", async () => {+ const getSecretsSpy = vi.spyOn(SecretsService, "getSecrets");+ const createSecretSpy = vi.spyOn(SecretsService, "createSecret");+ getSecretsSpy.mockResolvedValue(MOCK_GET_SECRETS_RESPONSE);++ renderSecretsSettings();++ // render form & hide items+ expect(screen.queryByTestId("add-secret-form")).not.toBeInTheDocument();+ const button = await screen.findByTestId("add-secret-button");+ await userEvent.click(button);++ const secretForm = screen.getByTestId("add-secret-form");+ expect(secretForm).toBeInTheDocument();++ // enter details+ const nameInput = within(secretForm).getByTestId("name-input");+ const valueInput = within(secretForm).getByTestId("value-input");+ const submitButton = within(secretForm).getByTestId("submit-button");++ await userEvent.type(nameInput, MOCK_GET_SECRETS_RESPONSE[0].name);+ await userEvent.type(valueInput, "my-custom-secret-value");+ await userEvent.click(submitButton);++ // make POST request+ expect(createSecretSpy).not.toHaveBeenCalled();+ expect(screen.queryByText(/secret already exists/i)).toBeInTheDocument();++ expect(nameInput).toHaveValue(MOCK_GET_SECRETS_RESPONSE[0].name);+ expect(valueInput).toHaveValue("my-custom-secret-value");+ });+});diff --git a/frontend/__tests__/routes/settings.test.tsx b/frontend/__tests__/routes/settings.test.tsxindex 23f14ebdec..30ba6a1348 100644--- a/frontend/__tests__/routes/settings.test.tsx+++ b/frontend/__tests__/routes/settings.test.tsx@@ -79,7 +79,7 @@ describe("Settings Screen", () => {};it("should render the navbar", async () => {- const sectionsToInclude = ["llm", "git", "application"];+ const sectionsToInclude = ["llm", "git", "application", "secrets"];const sectionsToExclude = ["api keys", "credits"];const getConfigSpy = vi.spyOn(OpenHands, "getConfig");// @ts-expect-error - only return app mode@@ -110,7 +110,13 @@ describe("Settings Screen", () => {getConfigSpy.mockResolvedValue({APP_MODE: "saas",});- const sectionsToInclude = ["git", "application", "credits", "api keys"];+ const sectionsToInclude = [+ "git",+ "application",+ "credits",+ "secrets",+ "api keys",+ ];const sectionsToExclude = ["llm"];renderSettingsScreen();diff --git a/frontend/scripts/check-unlocalized-strings.cjs b/frontend/scripts/check-unlocalized-strings.cjsindex 3124d20d23..a536f6340c 100755--- a/frontend/scripts/check-unlocalized-strings.cjs+++ b/frontend/scripts/check-unlocalized-strings.cjs@@ -111,6 +111,8 @@ const EXCLUDED_TECHNICAL_STRINGS = ["GitLab API", // Git provider specific terminology"Pull Request", // Git provider specific terminology"GitHub API", // Git provider specific terminology+ "add-secret-form", // Test ID for secret form+ "edit-secret-form", // Test ID for secret form];function isExcludedTechnicalString(str) {diff --git a/frontend/src/api/secrets-service.ts b/frontend/src/api/secrets-service.tsindex 3116813710..fd247ec9bd 100644--- a/frontend/src/api/secrets-service.ts+++ b/frontend/src/api/secrets-service.ts@@ -1,8 +1,43 @@-import { Provider, ProviderToken } from "#/types/settings";import { openHands } from "./open-hands-axios";-import { POSTProviderTokens } from "./secrets-service.types";+import {+ CustomSecret,+ GetSecretsResponse,+ POSTProviderTokens,+} from "./secrets-service.types";+import { Provider, ProviderToken } from "#/types/settings";export class SecretsService {+ static async getSecrets() {+ const { data } = await openHands.get<GetSecretsResponse>("/api/secrets");+ return data.custom_secrets;+ }++ static async createSecret(name: string, value: string, description?: string) {+ const secret: CustomSecret = {+ name,+ value,+ description,+ };++ const { status } = await openHands.post("/api/secrets", secret);+ return status === 201;+ }++ static async updateSecret(id: string, name: string, description?: string) {+ const secret: Omit<CustomSecret, "value"> = {+ name,+ description,+ };++ const { status } = await openHands.put(`/api/secrets/${id}`, secret);+ return status === 200;+ }++ static async deleteSecret(id: string) {+ const { status } = await openHands.delete<boolean>(`/api/secrets/${id}`);+ return status === 200;+ }+static async addGitProvider(providers: Record<Provider, ProviderToken>) {const tokens: POSTProviderTokens = {provider_tokens: providers,diff --git a/frontend/src/api/secrets-service.types.ts b/frontend/src/api/secrets-service.types.tsindex f2426c80f0..888d1a1fea 100644--- a/frontend/src/api/secrets-service.types.ts+++ b/frontend/src/api/secrets-service.types.ts@@ -1,5 +1,15 @@import { Provider, ProviderToken } from "#/types/settings";+export type CustomSecret = {+ name: string;+ value: string;+ description?: string;+};++export interface GetSecretsResponse {+ custom_secrets: Omit<CustomSecret, "value">[];+}+export interface POSTProviderTokens {provider_tokens: Record<Provider, ProviderToken>;}diff --git a/frontend/src/components/features/settings/secrets-settings/secret-form.tsx b/frontend/src/components/features/settings/secrets-settings/secret-form.tsxnew file mode 100644index 0000000000..7ad39e3853--- /dev/null+++ b/frontend/src/components/features/settings/secrets-settings/secret-form.tsx@@ -0,0 +1,202 @@+import { useQueryClient } from "@tanstack/react-query";+import React from "react";+import { useTranslation } from "react-i18next";+import { useCreateSecret } from "#/hooks/mutation/use-create-secret";+import { useUpdateSecret } from "#/hooks/mutation/use-update-secret";+import { SettingsInput } from "../settings-input";+import { cn } from "#/utils/utils";+import { BrandButton } from "../brand-button";+import { useGetSecrets } from "#/hooks/query/use-get-secrets";+import { GetSecretsResponse } from "#/api/secrets-service.types";+import { OptionalTag } from "../optional-tag";++interface SecretFormProps {+ mode: "add" | "edit";+ selectedSecret: string | null;+ onCancel: () => void;+}++export function SecretForm({+ mode,+ selectedSecret,+ onCancel,+}: SecretFormProps) {+ const queryClient = useQueryClient();+ const { t } = useTranslation();++ const { data: secrets } = useGetSecrets();+ const { mutate: createSecret } = useCreateSecret();+ const { mutate: updateSecret } = useUpdateSecret();++ const [error, setError] = React.useState<string | null>(null);++ const secretDescription =+ (mode === "edit" &&+ selectedSecret &&+ secrets+ ?.find((secret) => secret.name === selectedSecret)+ ?.description?.trim()) ||+ "";++ const handleCreateSecret = (+ name: string,+ value: string,+ description?: string,+ ) => {+ createSecret(+ { name, value, description },+ {+ onSettled: onCancel,+ onSuccess: async () => {+ await queryClient.invalidateQueries({ queryKey: ["secrets"] });+ },+ },+ );+ };++ const updateSecretOptimistically = (+ oldName: string,+ name: string,+ description?: string,+ ) => {+ queryClient.setQueryData<GetSecretsResponse["custom_secrets"]>(+ ["secrets"],+ (oldSecrets) => {+ if (!oldSecrets) return [];+ return oldSecrets.map((secret) => {+ if (secret.name === oldName) {+ return {+ ...secret,+ name,+ description,+ };+ }+ return secret;+ });+ },+ );+ };++ const revertOptimisticUpdate = () => {+ queryClient.invalidateQueries({ queryKey: ["secrets"] });+ };++ const handleEditSecret = (+ secretToEdit: string,+ name: string,+ description?: string,+ ) => {+ updateSecretOptimistically(secretToEdit, name, description);+ updateSecret(+ { secretToEdit, name, description },+ {+ onSettled: onCancel,+ onError: revertOptimisticUpdate,+ },+ );+ };++ const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {+ event.preventDefault();++ const formData = new FormData(event.currentTarget);+ const name = formData.get("secret-name")?.toString();+ const value = formData.get("secret-value")?.toString().trim();+ const description = formData.get("secret-description")?.toString();++ if (name) {+ setError(null);++ const isNameAlreadyUsed = secrets?.some(+ (secret) => secret.name === name && secret.name !== selectedSecret,+ );+ if (isNameAlreadyUsed) {+ setError("Secret already exists");+ return;+ }++ if (mode === "add") {+ if (!value) {+ setError(t("SECRETS$SECRET_VALUE_REQUIRED"));+ return;+ }++ handleCreateSecret(name, value, description || undefined);+ } else if (mode === "edit" && selectedSecret) {+ handleEditSecret(selectedSecret, name, description || undefined);+ }+ }+ };++ const formTestId = mode === "add" ? "add-secret-form" : "edit-secret-form";++ return (+ <form+ data-testid={formTestId}+ onSubmit={handleSubmit}+ className="flex flex-col items-start gap-6"+ >+ <SettingsInput+ testId="name-input"+ name="secret-name"+ type="text"+ label="Name"+ className="w-[350px]"+ required+ defaultValue={mode === "edit" && selectedSecret ? selectedSecret : ""}+ placeholder="e.g. OpenAI_API_Key"+ pattern="^\S*$"+ />+ {error && <p className="text-red-500 text-sm">{error}</p>}++ {mode === "add" && (+ <label className="flex flex-col gap-2.5 w-fit">+ <span className="text-sm">Value</span>+ <textarea+ data-testid="value-input"+ name="secret-value"+ required+ className={cn(+ "resize-none w-[680px]",+ "bg-tertiary border border-[#717888] rounded p-2 placeholder:italic placeholder:text-tertiary-alt",+ "disabled:bg-[#2D2F36] disabled:border-[#2D2F36] disabled:cursor-not-allowed",+ )}+ rows={8}+ />+ </label>+ )}++ <label className="flex flex-col gap-2.5 w-fit">+ <div className="flex items-center gap-2">+ <span className="text-sm">Description</span>+ <OptionalTag />+ </div>+ <input+ data-testid="description-input"+ name="secret-description"+ defaultValue={secretDescription}+ className={cn(+ "resize-none w-[680px]",+ "bg-tertiary border border-[#717888] rounded p-2 placeholder:italic placeholder:text-tertiary-alt",+ "disabled:bg-[#2D2F36] disabled:border-[#2D2F36] disabled:cursor-not-allowed",+ )}+ />+ </label>++ <div className="flex items-center gap-4">+ <BrandButton+ testId="cancel-button"+ type="button"+ variant="secondary"+ onClick={onCancel}+ >+ Cancel+ </BrandButton>+ <BrandButton testId="submit-button" type="submit" variant="primary">+ {mode === "add" && t("SECRETS$ADD_SECRET")}+ {mode === "edit" && t("SECRETS$EDIT_SECRET")}+ </BrandButton>+ </div>+ </form>+ );+}diff --git a/frontend/src/components/features/settings/secrets-settings/secret-list-item.tsx b/frontend/src/components/features/settings/secrets-settings/secret-list-item.tsxnew file mode 100644index 0000000000..7b2a61ac91--- /dev/null+++ b/frontend/src/components/features/settings/secrets-settings/secret-list-item.tsx@@ -0,0 +1,63 @@+import { FaPencil, FaTrash } from "react-icons/fa6";++export function SecretListItemSkeleton() {+ return (+ <div className="border-t border-[#717888] last-of-type:border-b max-w-[830px] pr-2.5 py-[13px] flex items-center justify-between">+ <div className="flex items-center justify-between w-1/3">+ <span className="skeleton h-4 w-1/2" />+ <span className="skeleton h-4 w-1/4" />+ </div>++ <div className="flex items-center gap-8">+ <span className="skeleton h-4 w-4" />+ <span className="skeleton h-4 w-4" />+ </div>+ </div>+ );+}++interface SecretListItemProps {+ title: string;+ description?: string;+ onEdit: () => void;+ onDelete: () => void;+}++export function SecretListItem({+ title,+ description,+ onEdit,+ onDelete,+}: SecretListItemProps) {+ return (+ <tr+ data-testid="secret-item"+ className="border-t border-[#717888] last-of-type:border-b max-w-[830px] py-[13px] flex w-full items-center"+ >+ <td className="w-1/4 text-sm text-content-2">{title}</td>++ <td className="w-1/2 truncate overflow-hidden whitespace-nowrap text-sm text-content-2 opacity-80 italic">+ {description || "-"}+ </td>++ <td className="w-1/4 flex items-center justify-end gap-4">+ <button+ data-testid="edit-secret-button"+ type="button"+ onClick={onEdit}+ aria-label={`Edit ${title}`}+ >+ <FaPencil size={16} />+ </button>+ <button+ data-testid="delete-secret-button"+ type="button"+ onClick={onDelete}+ aria-label={`Delete ${title}`}+ >+ <FaTrash size={16} />+ </button>+ </td>+ </tr>+ );+}diff --git a/frontend/src/components/features/settings/settings-input.tsx b/frontend/src/components/features/settings/settings-input.tsxindex 4aad109f24..b34a593a65 100644--- a/frontend/src/components/features/settings/settings-input.tsx+++ b/frontend/src/components/features/settings/settings-input.tsx@@ -14,9 +14,11 @@ interface SettingsInputProps {startContent?: React.ReactNode;className?: string;onChange?: (value: string) => void;+ required?: boolean;min?: number;max?: number;step?: number;+ pattern?: string;}export function SettingsInput({@@ -32,9 +34,11 @@ export function SettingsInput({startContent,className,onChange,+ required,min,max,step,+ pattern,}: SettingsInputProps) {return (<label className={cn("flex flex-col gap-2.5 w-fit", className)}>@@ -55,6 +59,8 @@ export function SettingsInput({min={min}max={max}step={step}+ required={required}+ pattern={pattern}className={cn("bg-tertiary border border-[#717888] h-10 w-full rounded p-2 placeholder:italic placeholder:text-tertiary-alt","disabled:bg-[#2D2F36] disabled:border-[#2D2F36] disabled:cursor-not-allowed",diff --git a/frontend/src/components/shared/modals/confirmation-modal.tsx b/frontend/src/components/shared/modals/confirmation-modal.tsxnew file mode 100644index 0000000000..426edccaea--- /dev/null+++ b/frontend/src/components/shared/modals/confirmation-modal.tsx@@ -0,0 +1,45 @@+import { BrandButton } from "#/components/features/settings/brand-button";+import { ModalBackdrop } from "./modal-backdrop";++interface ConfirmationModalProps {+ text: string;+ onConfirm: () => void;+ onCancel: () => void;+}++export function ConfirmationModal({+ text,+ onConfirm,+ onCancel,+}: ConfirmationModalProps) {+ return (+ <ModalBackdrop onClose={onCancel}>+ <div+ data-testid="confirmation-modal"+ className="bg-base-secondary p-4 rounded-xl flex flex-col gap-4 border border-tertiary"+ >+ <p>{text}</p>+ <div className="w-full flex gap-2">+ <BrandButton+ testId="cancel-button"+ type="button"+ onClick={onCancel}+ variant="secondary"+ className="grow"+ >+ Cancel+ </BrandButton>+ <BrandButton+ testId="confirm-button"+ type="button"+ onClick={onConfirm}+ variant="primary"+ className="grow"+ >+ Confirm+ </BrandButton>+ </div>+ </div>+ </ModalBackdrop>+ );+}diff --git a/frontend/src/hooks/mutation/use-create-secret.ts b/frontend/src/hooks/mutation/use-create-secret.tsnew file mode 100644index 0000000000..d8a7f7177f--- /dev/null+++ b/frontend/src/hooks/mutation/use-create-secret.ts@@ -0,0 +1,15 @@+import { useMutation } from "@tanstack/react-query";+import { SecretsService } from "#/api/secrets-service";++export const useCreateSecret = () =>+ useMutation({+ mutationFn: ({+ name,+ value,+ description,+ }: {+ name: string;+ value: string;+ description?: string;+ }) => SecretsService.createSecret(name, value, description),+ });diff --git a/frontend/src/hooks/mutation/use-delete-secret.ts b/frontend/src/hooks/mutation/use-delete-secret.tsnew file mode 100644index 0000000000..a7c360a5d1--- /dev/null+++ b/frontend/src/hooks/mutation/use-delete-secret.ts@@ -0,0 +1,7 @@+import { useMutation } from "@tanstack/react-query";+import { SecretsService } from "#/api/secrets-service";++export const useDeleteSecret = () =>+ useMutation({+ mutationFn: (id: string) => SecretsService.deleteSecret(id),+ });diff --git a/frontend/src/hooks/mutation/use-logout.ts b/frontend/src/hooks/mutation/use-logout.tsindex 56e9551aed..c574778a71 100644--- a/frontend/src/hooks/mutation/use-logout.ts+++ b/frontend/src/hooks/mutation/use-logout.ts@@ -15,6 +15,7 @@ export const useLogout = () => {queryClient.removeQueries({ queryKey: ["tasks"] });queryClient.removeQueries({ queryKey: ["settings"] });queryClient.removeQueries({ queryKey: ["user"] });+ queryClient.removeQueries({ queryKey: ["secrets"] });posthog.reset();await navigate("/");diff --git a/frontend/src/hooks/mutation/use-update-secret.ts b/frontend/src/hooks/mutation/use-update-secret.tsnew file mode 100644index 0000000000..d63eee4a1b--- /dev/null+++ b/frontend/src/hooks/mutation/use-update-secret.ts@@ -0,0 +1,15 @@+import { useMutation } from "@tanstack/react-query";+import { SecretsService } from "#/api/secrets-service";++export const useUpdateSecret = () =>+ useMutation({+ mutationFn: ({+ secretToEdit,+ name,+ description,+ }: {+ secretToEdit: string;+ name: string;+ description?: string;+ }) => SecretsService.updateSecret(secretToEdit, name, description),+ });diff --git a/frontend/src/hooks/query/use-get-secrets.ts b/frontend/src/hooks/query/use-get-secrets.tsnew file mode 100644index 0000000000..e031222d58--- /dev/null+++ b/frontend/src/hooks/query/use-get-secrets.ts@@ -0,0 +1,17 @@+import { useQuery } from "@tanstack/react-query";+import { SecretsService } from "#/api/secrets-service";+import { useUserProviders } from "../use-user-providers";+import { useConfig } from "./use-config";++export const useGetSecrets = () => {+ const { data: config } = useConfig();+ const { providers } = useUserProviders();++ const isOss = config?.APP_MODE === "oss";++ return useQuery({+ queryKey: ["secrets"],+ queryFn: SecretsService.getSecrets,+ enabled: isOss || providers.length > 0,+ });+};diff --git a/frontend/src/i18n/declaration.ts b/frontend/src/i18n/declaration.tsindex daa67ae7a7..fd73bdb18b 100644--- a/frontend/src/i18n/declaration.ts+++ b/frontend/src/i18n/declaration.ts@@ -1,5 +1,11 @@// this file generate by script, don't modify it manually!!!export enum I18nKey {+ SECRETS$SECRET_VALUE_REQUIRED = "SECRETS$SECRET_VALUE_REQUIRED",+ SECRETS$ADD_SECRET = "SECRETS$ADD_SECRET",+ SECRETS$EDIT_SECRET = "SECRETS$EDIT_SECRET",+ SECRETS$NO_SECRETS_FOUND = "SECRETS$NO_SECRETS_FOUND",+ SECRETS$ADD_NEW_SECRET = "SECRETS$ADD_NEW_SECRET",+ SECRETS$CONFIRM_DELETE_KEY = "SECRETS$CONFIRM_DELETE_KEY",SETTINGS$MCP_TITLE = "SETTINGS$MCP_TITLE",SETTINGS$MCP_DESCRIPTION = "SETTINGS$MCP_DESCRIPTION",SETTINGS$NAV_MCP = "SETTINGS$NAV_MCP",@@ -60,6 +66,7 @@ export enum I18nKey {SETTINGS$NAV_GIT = "SETTINGS$NAV_GIT",SETTINGS$NAV_APPLICATION = "SETTINGS$NAV_APPLICATION",SETTINGS$NAV_CREDITS = "SETTINGS$NAV_CREDITS",+ SETTINGS$NAV_SECRETS = "SETTINGS$NAV_SECRETS",SETTINGS$NAV_API_KEYS = "SETTINGS$NAV_API_KEYS",SETTINGS$NAV_LLM = "SETTINGS$NAV_LLM",GIT$MERGE_REQUEST = "GIT$MERGE_REQUEST",diff --git a/frontend/src/i18n/translation.json b/frontend/src/i18n/translation.jsonindex 419f9535d6..a7466e37c9 100644--- a/frontend/src/i18n/translation.json+++ b/frontend/src/i18n/translation.json@@ -1,4 +1,94 @@{+ "SECRETS$SECRET_VALUE_REQUIRED": {+ "en": "Secret value is required",+ "ja": "シークレット値は必須です",+ "zh-CN": "密钥值是必需的",+ "zh-TW": "密鑰值是必需的",+ "ko-KR": "비밀 값이 필요합니다",+ "no": "Hemmelig verdi er påkrevd",+ "it": "Il valore del segreto è obbligatorio",+ "pt": "O valor do segredo é obrigatório",+ "es": "El valor del secreto es obligatorio",+ "ar": "قيمة السر مطلوبة",+ "fr": "La valeur du secret est requise",+ "tr": "Gizli değer gereklidir",+ "de": "Geheimer Wert ist erforderlich"+ },+ "SECRETS$ADD_SECRET": {+ "en": "Add secret",+ "ja": "シークレットを追加",+ "zh-CN": "添加密钥",+ "zh-TW": "添加密鑰",+ "ko-KR": "비밀 추가",+ "no": "Legg til hemmelighet",+ "it": "Aggiungi segreto",+ "pt": "Adicionar segredo",+ "es": "Añadir secreto",+ "ar": "إضافة سر",+ "fr": "Ajouter un secret",+ "tr": "Gizli ekle",+ "de": "Geheimnis hinzufügen"+ },+ "SECRETS$EDIT_SECRET": {+ "en": "Edit secret",+ "ja": "シークレットを編集",+ "zh-CN": "编辑密钥",+ "zh-TW": "編輯密鑰",+ "ko-KR": "비밀 편집",+ "no": "Rediger hemmelighet",+ "it": "Modifica segreto",+ "pt": "Editar segredo",+ "es": "Editar secreto",+ "ar": "تعديل السر",+ "fr": "Modifier le secret",+ "tr": "Gizliyi düzenle",+ "de": "Geheimnis bearbeiten"+ },+ "SECRETS$NO_SECRETS_FOUND": {+ "en": "No secrets found",+ "ja": "シークレットが見つかりません",+ "zh-CN": "未找到密钥",+ "zh-TW": "未找到密鑰",+ "ko-KR": "비밀을 찾을 수 없습니다",+ "no": "Ingen hemmeligheter funnet",+ "it": "Nessun segreto trovato",+ "pt": "Nenhum segredo encontrado",+ "es": "No se encontraron secretos",+ "ar": "لم يتم العثور على أسرار",+ "fr": "Aucun secret trouvé",+ "tr": "Gizli bulunamadı",+ "de": "Keine Geheimnisse gefunden"+ },+ "SECRETS$ADD_NEW_SECRET": {+ "en": "Add a new secret",+ "ja": "新しいシークレットを追加",+ "zh-CN": "添加新密钥",+ "zh-TW": "添加新密鑰",+ "ko-KR": "새 비밀 추가",+ "no": "Legg til en ny hemmelighet",+ "it": "Aggiungi un nuovo segreto",+ "pt": "Adicionar um novo segredo",+ "es": "Añadir un nuevo secreto",+ "ar": "إضافة سر جديد",+ "fr": "Ajouter un nouveau secret",+ "tr": "Yeni bir gizli ekle",+ "de": "Neues Geheimnis hinzufügen"+ },+ "SECRETS$CONFIRM_DELETE_KEY": {+ "en": "Are you sure you want to delete this key?",+ "ja": "このキーを削除してもよろしいですか?",+ "zh-CN": "您确定要删除此密钥吗?",+ "zh-TW": "您確定要刪除此密鑰嗎?",+ "ko-KR": "이 키를 삭제하시겠습니까?",+ "no": "Er du sikker på at du vil slette denne nøkkelen?",+ "it": "Sei sicuro di voler eliminare questa chiave?",+ "pt": "Tem certeza de que deseja excluir esta chave?",+ "es": "¿Está seguro de que desea eliminar esta clave?",+ "ar": "هل أنت متأكد أنك تريد حذف هذا المفتاح؟",+ "fr": "Êtes-vous sûr de vouloir supprimer cette clé ?",+ "tr": "Bu anahtarı silmek istediğinizden emin misiniz?",+ "de": "Sind Sie sicher, dass Sie diesen Schlüssel löschen möchten?"+ },"SETTINGS$MCP_TITLE": {"en": "Model Context Protocol (MCP)","ja": "モデルコンテキストプロトコル (MCP)",@@ -959,6 +1049,21 @@"de": "Guthaben","uk": "Кредити"},+ "SETTINGS$NAV_SECRETS": {+ "en": "Secrets",+ "ja": "シークレット",+ "zh-CN": "机密",+ "zh-TW": "機密",+ "ko-KR": "비밀",+ "no": "Hemmeligheter",+ "it": "Segreti",+ "pt": "Segredos",+ "es": "Secretos",+ "ar": "أسرار",+ "fr": "Secrets",+ "tr": "Sırları",+ "de": "Geheimnisse"+ },"SETTINGS$NAV_API_KEYS": {"en": "API Keys","ja": "APIキー",diff --git a/frontend/src/mocks/handlers.ts b/frontend/src/mocks/handlers.tsindex 1d492462c7..2dfc9f21e3 100644--- a/frontend/src/mocks/handlers.ts+++ b/frontend/src/mocks/handlers.ts@@ -10,6 +10,7 @@ import { ApiSettings, PostApiSettings, Provider } from "#/types/settings";import { FILE_SERVICE_HANDLERS } from "./file-service-handlers";import { GitRepository, GitUser } from "#/types/git";import { TASK_SUGGESTIONS_HANDLERS } from "./task-suggestions-handlers";+import { SECRETS_HANDLERS } from "./secrets-handlers";export const MOCK_DEFAULT_USER_SETTINGS: ApiSettings | PostApiSettings = {llm_model: DEFAULT_SETTINGS.LLM_MODEL,@@ -118,6 +119,7 @@ export const handlers = [...STRIPE_BILLING_HANDLERS,...FILE_SERVICE_HANDLERS,...TASK_SUGGESTIONS_HANDLERS,+ ...SECRETS_HANDLERS,...openHandsHandlers,http.get("/api/user/repositories", () => {const data: GitRepository[] = [@@ -164,7 +166,7 @@ export const handlers = [POSTHOG_CLIENT_KEY: "fake-posthog-client-key",STRIPE_PUBLISHABLE_KEY: "",FEATURE_FLAGS: {- ENABLE_BILLING: mockSaas,+ ENABLE_BILLING: false,HIDE_LLM_SETTINGS: mockSaas,},};@@ -210,8 +212,6 @@ export const handlers = [HttpResponse.json({ message: "Authenticated" }),),- http.get("/api/options/config", () => HttpResponse.json({ APP_MODE: "oss" })),-http.get("/api/conversations", async () => {const values = Array.from(CONVERSATIONS.values());const results: ResultSet<Conversation> = {diff --git a/frontend/src/mocks/secrets-handlers.ts b/frontend/src/mocks/secrets-handlers.tsnew file mode 100644index 0000000000..3d5570943a--- /dev/null+++ b/frontend/src/mocks/secrets-handlers.ts@@ -0,0 +1,72 @@+import { http, HttpResponse } from "msw";+import { CustomSecret, GetSecretsResponse } from "#/api/secrets-service.types";++const DEFAULT_SECRETS: CustomSecret[] = [+ {+ name: "OpenAI_API_Key",+ value: "test-123",+ description: "OpenAI API Key",+ },+ {+ name: "Google_Maps_API_Key",+ value: "test-123",+ description: "Google Maps API Key",+ },+];++const secrets = new Map<string, CustomSecret>(+ DEFAULT_SECRETS.map((secret) => [secret.name, secret]),+);++export const SECRETS_HANDLERS = [+ http.get("/api/secrets", async () => {+ const secretsArray = Array.from(secrets.values());+ const secretsWithoutValue: Omit<CustomSecret, "value">[] = secretsArray.map(+ ({ value, ...rest }) => rest,+ );++ const data: GetSecretsResponse = {+ custom_secrets: secretsWithoutValue,+ };++ return HttpResponse.json(data);+ }),++ http.post("/api/secrets", async ({ request }) => {+ const body = (await request.json()) as CustomSecret;+ if (typeof body === "object" && body && body.name) {+ secrets.set(body.name, body);+ return HttpResponse.json(true);+ }++ return HttpResponse.json(false, { status: 400 });+ }),++ http.put("/api/secrets/:id", async ({ params, request }) => {+ const { id } = params;+ const body = (await request.json()) as Omit<CustomSecret, "value">;++ if (typeof id === "string" && typeof body === "object") {+ const secret = secrets.get(id);+ if (secret && body && body.name) {+ const newSecret: CustomSecret = { ...secret, ...body };+ secrets.delete(id);+ secrets.set(body.name, newSecret);+ return HttpResponse.json(true);+ }+ }++ return HttpResponse.json(false, { status: 400 });+ }),++ http.delete("/api/secrets/:id", async ({ params }) => {+ const { id } = params;++ if (typeof id === "string") {+ secrets.delete(id);+ return HttpResponse.json(true);+ }++ return HttpResponse.json(false, { status: 400 });+ }),+];diff --git a/frontend/src/routes.ts b/frontend/src/routes.tsindex 3f43d9690c..a1bf89b224 100644--- a/frontend/src/routes.ts+++ b/frontend/src/routes.ts@@ -15,6 +15,7 @@ export default [route("git", "routes/git-settings.tsx"),route("app", "routes/app-settings.tsx"),route("billing", "routes/billing.tsx"),+ route("secrets", "routes/secrets-settings.tsx"),route("api-keys", "routes/api-keys.tsx"),]),route("conversations/:conversationId", "routes/conversation.tsx", [diff --git a/frontend/src/routes/secrets-settings.tsx b/frontend/src/routes/secrets-settings.tsxnew file mode 100644index 0000000000..16ff9d128e--- /dev/null+++ b/frontend/src/routes/secrets-settings.tsx@@ -0,0 +1,151 @@+import { useQueryClient } from "@tanstack/react-query";+import React from "react";+import { Link } from "react-router";+import { useTranslation } from "react-i18next";+import { useGetSecrets } from "#/hooks/query/use-get-secrets";+import { useDeleteSecret } from "#/hooks/mutation/use-delete-secret";+import { SecretForm } from "#/components/features/settings/secrets-settings/secret-form";+import {+ SecretListItem,+ SecretListItemSkeleton,+} from "#/components/features/settings/secrets-settings/secret-list-item";+import { BrandButton } from "#/components/features/settings/brand-button";+import { ConfirmationModal } from "#/components/shared/modals/confirmation-modal";+import { GetSecretsResponse } from "#/api/secrets-service.types";+import { useUserProviders } from "#/hooks/use-user-providers";+import { useConfig } from "#/hooks/query/use-config";++function SecretsSettingsScreen() {+ const queryClient = useQueryClient();+ const { t } = useTranslation();++ const { data: config } = useConfig();+ const { data: secrets, isLoading: isLoadingSecrets } = useGetSecrets();+ const { mutate: deleteSecret } = useDeleteSecret();+ const { providers } = useUserProviders();++ const isSaas = config?.APP_MODE === "saas";+ const hasProviderSet = providers.length > 0;++ const [view, setView] = React.useState<+ "list" | "add-secret-form" | "edit-secret-form"+ >("list");+ const [selectedSecret, setSelectedSecret] = React.useState<string | null>(+ null,+ );+ const [confirmationModalIsVisible, setConfirmationModalIsVisible] =+ React.useState(false);++ const deleteSecretOptimistically = (secret: string) => {+ queryClient.setQueryData<GetSecretsResponse["custom_secrets"]>(+ ["secrets"],+ (oldSecrets) => {+ if (!oldSecrets) return [];+ return oldSecrets.filter((s) => s.name !== secret);+ },+ );+ };++ const revertOptimisticUpdate = () => {+ queryClient.invalidateQueries({ queryKey: ["secrets"] });+ };++ const handleDeleteSecret = (secret: string) => {+ deleteSecretOptimistically(secret);+ deleteSecret(secret, {+ onSettled: () => {+ setConfirmationModalIsVisible(false);+ },+ onError: revertOptimisticUpdate,+ });+ };++ const onConfirmDeleteSecret = () => {+ if (selectedSecret) handleDeleteSecret(selectedSecret);+ };++ const onCancelDeleteSecret = () => {+ setConfirmationModalIsVisible(false);+ };++ const shouldRenderConnectToGitButton = isSaas && !hasProviderSet;++ return (+ <div+ data-testid="secrets-settings-screen"+ className="px-11 py-9 flex flex-col gap-5"+ >+ {isLoadingSecrets && view === "list" && (+ <ul>+ <SecretListItemSkeleton />+ <SecretListItemSkeleton />+ <SecretListItemSkeleton />+ </ul>+ )}++ {shouldRenderConnectToGitButton && (+ <Link to="/settings/git" data-testid="connect-git-button" type="button">+ <BrandButton type="button" variant="secondary">+ Connect a Git provider to manage secrets+ </BrandButton>+ </Link>+ )}++ {secrets?.length === 0 && view === "list" && (+ <p data-testid="no-secrets-message">{t("SECRETS$NO_SECRETS_FOUND")}</p>+ )}++ {view === "list" && (+ <table className="w-full">+ <tbody>+ {secrets?.map((secret) => (+ <SecretListItem+ key={secret.name}+ title={secret.name}+ description={secret.description}+ onEdit={() => {+ setView("edit-secret-form");+ setSelectedSecret(secret.name);+ }}+ onDelete={() => {+ setConfirmationModalIsVisible(true);+ setSelectedSecret(secret.name);+ }}+ />+ ))}+ </tbody>+ </table>+ )}++ {!shouldRenderConnectToGitButton && view === "list" && (+ <BrandButton+ testId="add-secret-button"+ type="button"+ variant="primary"+ onClick={() => setView("add-secret-form")}+ isDisabled={isLoadingSecrets}+ >+ {t("SECRETS$ADD_NEW_SECRET")}+ </BrandButton>+ )}++ {(view === "add-secret-form" || view === "edit-secret-form") && (+ <SecretForm+ mode={view === "add-secret-form" ? "add" : "edit"}+ selectedSecret={selectedSecret}+ onCancel={() => setView("list")}+ />+ )}++ {confirmationModalIsVisible && (+ <ConfirmationModal+ text={t("SECRETS$CONFIRM_DELETE_KEY")}+ onConfirm={onConfirmDeleteSecret}+ onCancel={onCancelDeleteSecret}+ />+ )}+ </div>+ );+}++export default SecretsSettingsScreen;diff --git a/frontend/src/routes/settings.tsx b/frontend/src/routes/settings.tsxindex 4b36ecf7a5..3aa4339b01 100644--- a/frontend/src/routes/settings.tsx+++ b/frontend/src/routes/settings.tsx@@ -18,6 +18,7 @@ function SettingsScreen() {{ to: "/settings/git", text: t("SETTINGS$NAV_GIT") },{ to: "/settings/app", text: t("SETTINGS$NAV_APPLICATION") },{ to: "/settings/billing", text: t("SETTINGS$NAV_CREDITS") },+ { to: "/settings/secrets", text: t("SETTINGS$NAV_SECRETS") },{ to: "/settings/api-keys", text: t("SETTINGS$NAV_API_KEYS") },];@@ -26,6 +27,7 @@ function SettingsScreen() {{ to: "/settings/mcp", text: t("SETTINGS$NAV_MCP") },{ to: "/settings/git", text: t("SETTINGS$NAV_GIT") },{ to: "/settings/app", text: t("SETTINGS$NAV_APPLICATION") },+ { to: "/settings/secrets", text: t("SETTINGS$NAV_SECRETS") },];React.useEffect(() => {diff --git a/openhands/integrations/provider.py b/openhands/integrations/provider.pyindex 4e2478d8a8..ad89b042b3 100644--- a/openhands/integrations/provider.py+++ b/openhands/integrations/provider.py@@ -57,8 +57,31 @@ class ProviderToken(BaseModel):raise ValueError('Unsupported Provider token type')+class CustomSecret(BaseModel):+ secret: SecretStr = Field(default_factory=lambda: SecretStr(''))+ description: str = Field(default='')++ model_config = {+ 'frozen': True, # Makes the entire model immutable+ 'validate_assignment': True,+ }++ @classmethod+ def from_value(cls, secret_value: CustomSecret | dict[str, str]) -> CustomSecret:+ """Factory method to create a ProviderToken from various input types"""+ if isinstance(secret_value, CustomSecret):+ return secret_value+ elif isinstance(secret_value, dict):+ secret = secret_value.get('secret')+ description = secret_value.get('description')+ return cls(secret=SecretStr(secret), description=description)++ else:+ raise ValueError('Unsupport Provider token type')++PROVIDER_TOKEN_TYPE = MappingProxyType[ProviderType, ProviderToken]-CUSTOM_SECRETS_TYPE = MappingProxyType[str, SecretStr]+CUSTOM_SECRETS_TYPE = MappingProxyType[str, CustomSecret]PROVIDER_TOKEN_TYPE_WITH_JSON_SCHEMA = Annotated[PROVIDER_TOKEN_TYPE,WithJsonSchema({'type': 'object', 'additionalProperties': {'type': 'string'}}),diff --git a/openhands/server/routes/secrets.py b/openhands/server/routes/secrets.pyindex 86719295c0..5bb7f92daf 100644--- a/openhands/server/routes/secrets.py+++ b/openhands/server/routes/secrets.py@@ -2,12 +2,14 @@ from fastapi import APIRouter, Depends, statusfrom fastapi.responses import JSONResponsefrom openhands.core.logger import openhands_logger as logger+from openhands.integrations.provider import CustomSecretfrom openhands.integrations.provider import PROVIDER_TOKEN_TYPEfrom openhands.integrations.service_types import ProviderTypefrom openhands.integrations.utils import validate_provider_tokenfrom openhands.server.settings import (+ CustomSecretModel,+ CustomSecretWithoutValueModel,GETCustomSecrets,- POSTCustomSecrets,POSTProviderModel,)from openhands.server.user_auth import (@@ -188,7 +190,15 @@ async def load_custom_secrets_names(content={'error': 'User secrets not found'},)- custom_secrets = list(user_secrets.custom_secrets.keys())+ custom_secrets: list[CustomSecretWithoutValueModel] = []+ if user_secrets.custom_secrets:+ for secret_name, secret_value in user_secrets.custom_secrets.items():+ custom_secret = CustomSecretWithoutValueModel(+ name=secret_name,+ description=secret_value.description,+ )+ custom_secrets.append(custom_secret)+return GETCustomSecrets(custom_secrets=custom_secrets)except Exception as e:@@ -201,7 +211,7 @@ async def load_custom_secrets_names(@app.post('/secrets', response_model=dict[str, str])async def create_custom_secret(- incoming_secret: POSTCustomSecrets,+ incoming_secret: CustomSecretModel,secrets_store: SecretsStore = Depends(get_secrets_store),) -> JSONResponse:try:@@ -209,14 +219,20 @@ async def create_custom_secret(if existing_secrets:custom_secrets = dict(existing_secrets.custom_secrets)- for secret_name, secret_value in incoming_secret.custom_secrets.items():- if secret_name in custom_secrets:- return JSONResponse(- status_code=status.HTTP_400_BAD_REQUEST,- content={'message': f'Secret {secret_name} already exists'},- )+ secret_name = incoming_secret.name+ secret_value = incoming_secret.value+ secret_description = incoming_secret.description++ if secret_name in custom_secrets:+ return JSONResponse(+ status_code=status.HTTP_400_BAD_REQUEST,+ content={'message': f'Secret {secret_name} already exists'},+ )- custom_secrets[secret_name] = secret_value+ custom_secrets[secret_name] = CustomSecret(+ secret=secret_value,+ description=secret_description or '',+ )# Create a new UserSecrets that preserves provider tokensupdated_user_secrets = UserSecrets(@@ -227,7 +243,7 @@ async def create_custom_secret(await secrets_store.store(updated_user_secrets)return JSONResponse(- status_code=status.HTTP_200_OK,+ status_code=status.HTTP_201_CREATED,content={'message': 'Secret created successfully'},)except Exception as e:@@ -241,7 +257,7 @@ async def create_custom_secret(@app.put('/secrets/{secret_id}', response_model=dict[str, str])async def update_custom_secret(secret_id: str,- incoming_secret: POSTCustomSecrets,+ incoming_secret: CustomSecretWithoutValueModel,secrets_store: SecretsStore = Depends(get_secrets_store),) -> JSONResponse:try:@@ -254,13 +270,23 @@ async def update_custom_secret(content={'error': f'Secret with ID {secret_id} not found'},)+ secret_name = incoming_secret.name+ secret_description = incoming_secret.description+custom_secrets = dict(existing_secrets.custom_secrets)- custom_secrets.pop(secret_id)+ existing_secret = custom_secrets.pop(secret_id)- for secret_name, secret_value in incoming_secret.custom_secrets.items():- custom_secrets[secret_name] = secret_value+ if secret_name != secret_id and secret_name in custom_secrets:+ return JSONResponse(+ status_code=status.HTTP_400_BAD_REQUEST,+ content={'message': f'Secret {secret_name} already exists'},+ )++ custom_secrets[secret_name] = CustomSecret(+ secret=existing_secret.secret,+ description=secret_description or '',+ )- # Create a new UserSecrets that preserves provider tokensupdated_secrets = UserSecrets(custom_secrets=custom_secrets,provider_tokens=existing_secrets.provider_tokens,diff --git a/openhands/server/settings.py b/openhands/server/settings.pyindex 16629be3d5..3be513b6e7 100644--- a/openhands/server/settings.py+++ b/openhands/server/settings.py@@ -6,7 +6,7 @@ from pydantic import ()from openhands.core.config.mcp_config import MCPConfig-from openhands.integrations.provider import ProviderToken+from openhands.integrations.provider import CustomSecret, ProviderTokenfrom openhands.integrations.service_types import ProviderTypefrom openhands.storage.data_models.settings import Settings@@ -25,7 +25,7 @@ class POSTCustomSecrets(BaseModel):Adding new custom secret"""- custom_secrets: dict[str, str | SecretStr] = {}+ custom_secrets: dict[str, CustomSecret] = {}class GETSettingsModel(Settings):@@ -41,9 +41,26 @@ class GETSettingsModel(Settings):model_config = {'use_enum_values': True}+class CustomSecretWithoutValueModel(BaseModel):+ """+ Custom secret model without value+ """++ name: str+ description: str | None = None+++class CustomSecretModel(CustomSecretWithoutValueModel):+ """+ Custom secret model with value+ """++ value: SecretStr++class GETCustomSecrets(BaseModel):"""Custom secrets names"""- custom_secrets: list[str] | None = None+ custom_secrets: list[CustomSecretWithoutValueModel] | None = Nonediff --git a/openhands/storage/data_models/user_secrets.py b/openhands/storage/data_models/user_secrets.pyindex 1b4ce2e097..2ec11bfd5d 100644--- a/openhands/storage/data_models/user_secrets.py+++ b/openhands/storage/data_models/user_secrets.py@@ -3,9 +3,7 @@ from typing import Anyfrom pydantic import (BaseModel,- ConfigDict,Field,- SecretStr,SerializationInfo,field_serializer,model_validator,@@ -17,6 +15,7 @@ from openhands.integrations.provider import (CUSTOM_SECRETS_TYPE_WITH_JSON_SCHEMA,PROVIDER_TOKEN_TYPE,PROVIDER_TOKEN_TYPE_WITH_JSON_SCHEMA,+ CustomSecret,ProviderToken,)from openhands.integrations.service_types import ProviderType@@ -31,11 +30,11 @@ class UserSecrets(BaseModel):default_factory=lambda: MappingProxyType({}))- model_config = ConfigDict(- frozen=True,- validate_assignment=True,- arbitrary_types_allowed=True,- )+ model_config = {+ 'frozen': True,+ 'validate_assignment': True,+ 'arbitrary_types_allowed': True,+ }@field_serializer('provider_tokens')def provider_tokens_serializer(@@ -78,12 +77,14 @@ class UserSecrets(BaseModel):expose_secrets = info.context and info.context.get('expose_secrets', False)if custom_secrets:- for secret_name, secret_key in custom_secrets.items():- secrets[secret_name] = (- secret_key.get_secret_value()+ for secret_name, secret_value in custom_secrets.items():+ secrets[secret_name] = {+ 'secret': secret_value.secret.get_secret_value()if expose_secrets- else pydantic_encoder(secret_key)- )+ else pydantic_encoder(secret_value.secret),+ 'description': secret_value.description,+ }+return secrets@model_validator(mode='before')@@ -125,10 +126,10 @@ class UserSecrets(BaseModel):if isinstance(secrets, dict):converted_secrets = {}for key, value in secrets.items():- if isinstance(value, str):- converted_secrets[key] = SecretStr(value)- elif isinstance(value, SecretStr):- converted_secrets[key] = value+ try:+ converted_secrets[key] = CustomSecret.from_value(value)+ except ValueError:+ continuenew_data['custom_secrets'] = MappingProxyType(converted_secrets)elif isinstance(secrets, MappingProxyType):diff --git a/tests/unit/test_secret_store.py b/tests/unit/test_secret_store.pyindex a75a47fa8f..4112e2fdf1 100644--- a/tests/unit/test_secret_store.py+++ b/tests/unit/test_secret_store.py@@ -5,7 +5,11 @@ from typing import Anyfrom pydantic import SecretStr-from openhands.integrations.provider import ProviderToken, ProviderType+from openhands.integrations.provider import (+ CustomSecret,+ ProviderToken,+ ProviderType,+)from openhands.storage.data_models.user_secrets import UserSecrets@@ -51,8 +55,12 @@ class TestUserSecrets:"""Test adding only custom secrets to the UserSecrets."""# Create custom secretscustom_secrets = {- 'API_KEY': 'api-key-123',- 'DATABASE_PASSWORD': 'db-pass-456',+ 'API_KEY': CustomSecret(+ secret=SecretStr('api-key-123'), description='API key'+ ),+ 'DATABASE_PASSWORD': CustomSecret(+ secret=SecretStr('db-pass-456'), description='Database password'+ ),}# Initialize the store with custom secrets@@ -61,9 +69,11 @@ class TestUserSecrets:# Verify the custom secrets were added correctlyassert isinstance(store.custom_secrets, MappingProxyType)assert len(store.custom_secrets) == 2- assert store.custom_secrets['API_KEY'].get_secret_value() == 'api-key-123'assert (- store.custom_secrets['DATABASE_PASSWORD'].get_secret_value()+ store.custom_secrets['API_KEY'].secret.get_secret_value() == 'api-key-123'+ )+ assert (+ store.custom_secrets['DATABASE_PASSWORD'].secret.get_secret_value()== 'db-pass-456')@@ -79,10 +89,10 @@ class TestUserSecrets:}# Create custom secrets as a MappingProxyType- custom_secrets_dict = {'API_KEY': 'api-key-123'}- custom_secrets_proxy = MappingProxyType(- {key: SecretStr(value) for key, value in custom_secrets_dict.items()}+ custom_secret = CustomSecret(+ secret=SecretStr('api-key-123'), description='API key')+ custom_secrets_proxy = MappingProxyType({'API_KEY': custom_secret})# Test with dict for provider_tokens and MappingProxyType for custom_secretsstore1 = UserSecrets(@@ -95,7 +105,9 @@ class TestUserSecrets:store1.provider_tokens[ProviderType.GITHUB].token.get_secret_value()== 'github-token-123')- assert store1.custom_secrets['API_KEY'].get_secret_value() == 'api-key-123'+ assert (+ store1.custom_secrets['API_KEY'].secret.get_secret_value() == 'api-key-123'+ )# Test with MappingProxyType for provider_tokens and dict for custom_secretsprovider_token = ProviderToken(@@ -103,6 +115,11 @@ class TestUserSecrets:)provider_tokens_proxy = MappingProxyType({ProviderType.GITLAB: provider_token})+ # Create custom secrets as a dict+ custom_secrets_dict = {+ 'API_KEY': {'secret': 'api-key-123', 'description': 'API key'}+ }+store2 = UserSecrets(provider_tokens=provider_tokens_proxy, custom_secrets=custom_secrets_dict)@@ -113,7 +130,9 @@ class TestUserSecrets:store2.provider_tokens[ProviderType.GITLAB].token.get_secret_value()== 'gitlab-token-456')- assert store2.custom_secrets['API_KEY'].get_secret_value() == 'api-key-123'+ assert (+ store2.custom_secrets['API_KEY'].secret.get_secret_value() == 'api-key-123'+ )def test_model_copy_update_fields(self):"""Test using model_copy to update fields without affecting other fields."""@@ -121,7 +140,11 @@ class TestUserSecrets:github_token = ProviderToken(token=SecretStr('github-token-123'), user_id='user1')- custom_secret = {'API_KEY': SecretStr('api-key-123')}+ custom_secret = {+ 'API_KEY': CustomSecret(+ secret=SecretStr('api-key-123'), description='API key'+ )+ }initial_store = UserSecrets(provider_tokens=MappingProxyType({ProviderType.GITHUB: github_token}),@@ -152,14 +175,19 @@ class TestUserSecrets:)assert len(updated_store1.custom_secrets) == 1assert (- updated_store1.custom_secrets['API_KEY'].get_secret_value() == 'api-key-123'+ updated_store1.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'api-key-123')# Update only custom_secretsupdated_custom_secrets = MappingProxyType({- 'API_KEY': SecretStr('api-key-123'),- 'DATABASE_PASSWORD': SecretStr('db-pass-456'),+ 'API_KEY': CustomSecret(+ secret=SecretStr('api-key-123'), description='API key'+ ),+ 'DATABASE_PASSWORD': CustomSecret(+ secret=SecretStr('db-pass-456'), description='DB password'+ ),})@@ -175,10 +203,11 @@ class TestUserSecrets:)assert len(updated_store2.custom_secrets) == 2assert (- updated_store2.custom_secrets['API_KEY'].get_secret_value() == 'api-key-123'+ updated_store2.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'api-key-123')assert (- updated_store2.custom_secrets['DATABASE_PASSWORD'].get_secret_value()+ updated_store2.custom_secrets['DATABASE_PASSWORD'].secret.get_secret_value()== 'db-pass-456')@@ -188,7 +217,11 @@ class TestUserSecrets:github_token = ProviderToken(token=SecretStr('github-token-123'), user_id='user1')- custom_secrets = {'API_KEY': SecretStr('api-key-123')}+ custom_secrets = {+ 'API_KEY': CustomSecret(+ secret=SecretStr('api-key-123'), description='API key'+ )+ }store = UserSecrets(provider_tokens=MappingProxyType({ProviderType.GITHUB: github_token}),@@ -209,7 +242,8 @@ class TestUserSecrets:assert serialized_provider_tokens['github']['user_id'] == 'user1'# Verify custom secrets are exposed- assert serialized_custom_secrets['API_KEY'] == 'api-key-123'+ assert serialized_custom_secrets['API_KEY']['secret'] == 'api-key-123'+ assert serialized_custom_secrets['API_KEY']['description'] == 'API key'# Test serialization with expose_secrets=False (default)hidden_provider_tokens = store.provider_tokens_serializer(@@ -225,8 +259,8 @@ class TestUserSecrets:assert '**' in hidden_provider_tokens['github']['token']# Verify custom secrets are hidden- assert hidden_custom_secrets['API_KEY'] != 'api-key-123'- assert '**' in hidden_custom_secrets['API_KEY']+ assert hidden_custom_secrets['API_KEY']['secret'] != 'api-key-123'+ assert '**' in hidden_custom_secrets['API_KEY']['secret']def test_initializing_provider_tokens_with_mixed_value_types(self):"""Test initializing provider tokens with both plain strings and SecretStr objects."""@@ -278,27 +312,36 @@ class TestUserSecrets:"""Test initializing custom secrets with both plain strings and SecretStr objects."""# Create custom secrets with mixed value typescustom_secrets_dict = {- 'API_KEY': 'api-key-123', # Plain string- 'DATABASE_PASSWORD': SecretStr('db-pass-456'), # SecretStr+ 'API_KEY': {+ 'secret': 'api-key-123',+ 'description': 'API key',+ }, # Dict format+ 'DATABASE_PASSWORD': CustomSecret(+ secret=SecretStr('db-pass-456'), description='DB password'+ ), # CustomSecret object}# Initialize the storestore = UserSecrets(custom_secrets=custom_secrets_dict)- # Verify all secrets are converted to SecretStr+ # Verify all secrets are converted to CustomSecret objectsassert isinstance(store.custom_secrets, MappingProxyType)assert len(store.custom_secrets) == 2- # Check API_KEY (was plain string)- assert isinstance(store.custom_secrets['API_KEY'], SecretStr)- assert store.custom_secrets['API_KEY'].get_secret_value() == 'api-key-123'+ # Check API_KEY (was dict)+ assert isinstance(store.custom_secrets['API_KEY'], CustomSecret)+ assert (+ store.custom_secrets['API_KEY'].secret.get_secret_value() == 'api-key-123'+ )+ assert store.custom_secrets['API_KEY'].description == 'API key'- # Check DATABASE_PASSWORD (was SecretStr)- assert isinstance(store.custom_secrets['DATABASE_PASSWORD'], SecretStr)+ # Check DATABASE_PASSWORD (was CustomSecret)+ assert isinstance(store.custom_secrets['DATABASE_PASSWORD'], CustomSecret)assert (- store.custom_secrets['DATABASE_PASSWORD'].get_secret_value()+ store.custom_secrets['DATABASE_PASSWORD'].secret.get_secret_value()== 'db-pass-456')+ assert store.custom_secrets['DATABASE_PASSWORD'].description == 'DB password'# Mock class for SerializationInfo since it's not directly importablediff --git a/tests/unit/test_secrets_api.py b/tests/unit/test_secrets_api.pyindex 2d8efee37c..dc210610d7 100644--- a/tests/unit/test_secrets_api.py+++ b/tests/unit/test_secrets_api.py@@ -8,7 +8,11 @@ from fastapi import FastAPIfrom fastapi.testclient import TestClientfrom pydantic import SecretStr-from openhands.integrations.provider import ProviderToken, ProviderType+from openhands.integrations.provider import (+ CustomSecret,+ ProviderToken,+ ProviderType,+)from openhands.server.routes.secrets import app as secrets_appfrom openhands.storage import get_file_storefrom openhands.storage.data_models.user_secrets import UserSecrets@@ -45,8 +49,8 @@ async def test_load_custom_secrets_names(test_client, file_secrets_store):# Create initial settings with custom secretscustom_secrets = {- 'API_KEY': SecretStr('api-key-value'),- 'DB_PASSWORD': SecretStr('db-password-value'),+ 'API_KEY': CustomSecret(secret=SecretStr('api-key-value')),+ 'DB_PASSWORD': CustomSecret(secret=SecretStr('db-password-value')),}provider_tokens = {ProviderType.GITHUB: ProviderToken(token=SecretStr('github-token'))@@ -60,20 +64,24 @@ async def test_load_custom_secrets_names(test_client, file_secrets_store):# Make the GET requestresponse = test_client.get('/api/secrets')+ print(response)assert response.status_code == 200# Check the responsedata = response.json()assert 'custom_secrets' in data- assert sorted(data['custom_secrets']) == ['API_KEY', 'DB_PASSWORD']+ # Extract just the names from the list of custom secrets+ secret_names = [secret['name'] for secret in data['custom_secrets']]+ assert sorted(secret_names) == ['API_KEY', 'DB_PASSWORD']# Verify that the original settings were not modifiedstored_settings = await file_secrets_store.load()assert (- stored_settings.custom_secrets['API_KEY'].get_secret_value() == 'api-key-value'+ stored_settings.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'api-key-value')assert (- stored_settings.custom_secrets['DB_PASSWORD'].get_secret_value()+ stored_settings.custom_secrets['DB_PASSWORD'].secret.get_secret_value()== 'db-password-value')assert ProviderType.GITHUB in stored_settings.provider_tokens@@ -86,7 +94,7 @@ async def test_load_custom_secrets_names_empty(test_client, file_secrets_store):provider_tokens = {ProviderType.GITHUB: ProviderToken(token=SecretStr('github-token'))}- user_secrets = UserSecrets(provider_tokens=provider_tokens)+ user_secrets = UserSecrets(provider_tokens=provider_tokens, custom_secrets={})# Store the initial settingsawait file_secrets_store.store(user_secrets)@@ -115,9 +123,9 @@ async def test_add_custom_secret(test_client, file_secrets_store):await file_secrets_store.store(user_secrets)# Make the POST request to add a custom secret- add_secret_data = {'custom_secrets': {'API_KEY': 'api-key-value'}}+ add_secret_data = {'name': 'API_KEY', 'value': 'api-key-value', 'description': None}response = test_client.post('/api/secrets', json=add_secret_data)- assert response.status_code == 200+ assert response.status_code == 201# Verify that the settings were stored with the new secretstored_settings = await file_secrets_store.load()@@ -125,16 +133,17 @@ async def test_add_custom_secret(test_client, file_secrets_store):# Check that the secret was addedassert 'API_KEY' in stored_settings.custom_secretsassert (- stored_settings.custom_secrets['API_KEY'].get_secret_value() == 'api-key-value'+ stored_settings.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'api-key-value')@pytest.mark.asyncioasync def test_update_existing_custom_secret(test_client, file_secrets_store):- """Test updating an existing custom secret."""+ """Test updating an existing custom secret's name and description (cannot change value once set)."""# Create initial settings with a custom secret- custom_secrets = {'API_KEY': SecretStr('old-api-key')}+ custom_secrets = {'API_KEY': CustomSecret(secret=SecretStr('old-api-key'))}provider_tokens = {ProviderType.GITHUB: ProviderToken(token=SecretStr('github-token'))}@@ -145,8 +154,11 @@ async def test_update_existing_custom_secret(test_client, file_secrets_store):# Store the initial settingsawait file_secrets_store.store(user_secrets)- # Make the POST request to update the custom secret- update_secret_data = {'custom_secrets': {'API_KEY': 'new-api-key'}}+ # Make the PUT request to update the custom secret+ update_secret_data = {+ 'name': 'API_KEY',+ 'description': None,+ }response = test_client.put('/api/secrets/API_KEY', json=update_secret_data)assert response.status_code == 200@@ -155,7 +167,10 @@ async def test_update_existing_custom_secret(test_client, file_secrets_store):# Check that the secret was updatedassert 'API_KEY' in stored_settings.custom_secrets- assert stored_settings.custom_secrets['API_KEY'].get_secret_value() == 'new-api-key'+ assert (+ stored_settings.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'old-api-key'+ )# Check that other settings were preservedassert ProviderType.GITHUB in stored_settings.provider_tokens@@ -166,7 +181,9 @@ async def test_add_multiple_custom_secrets(test_client, file_secrets_store):"""Test adding multiple custom secrets at once."""# Create initial settings with one custom secret- custom_secrets = {'EXISTING_SECRET': SecretStr('existing-value')}+ custom_secrets = {+ 'EXISTING_SECRET': CustomSecret(secret=SecretStr('existing-value'))+ }provider_tokens = {ProviderType.GITHUB: ProviderToken(token=SecretStr('github-token'))}@@ -177,15 +194,23 @@ async def test_add_multiple_custom_secrets(test_client, file_secrets_store):# Store the initial settingsawait file_secrets_store.store(user_secrets)- # Make the POST request to add multiple custom secrets- add_secrets_data = {- 'custom_secrets': {- 'API_KEY': 'api-key-value',- 'DB_PASSWORD': 'db-password-value',- }+ # Make the POST request to add first custom secret+ add_secret_data1 = {+ 'name': 'API_KEY',+ 'value': 'api-key-value',+ 'description': None,}- response = test_client.post('/api/secrets', json=add_secrets_data)- assert response.status_code == 200+ response1 = test_client.post('/api/secrets', json=add_secret_data1)+ assert response1.status_code == 201++ # Make the POST request to add second custom secret+ add_secret_data2 = {+ 'name': 'DB_PASSWORD',+ 'value': 'db-password-value',+ 'description': None,+ }+ response = test_client.post('/api/secrets', json=add_secret_data2)+ assert response.status_code == 201# Verify that the settings were stored with the new secretsstored_settings = await file_secrets_store.load()@@ -193,18 +218,19 @@ async def test_add_multiple_custom_secrets(test_client, file_secrets_store):# Check that the new secrets were addedassert 'API_KEY' in stored_settings.custom_secretsassert (- stored_settings.custom_secrets['API_KEY'].get_secret_value() == 'api-key-value'+ stored_settings.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'api-key-value')assert 'DB_PASSWORD' in stored_settings.custom_secretsassert (- stored_settings.custom_secrets['DB_PASSWORD'].get_secret_value()+ stored_settings.custom_secrets['DB_PASSWORD'].secret.get_secret_value()== 'db-password-value')# Check that existing secrets were preservedassert 'EXISTING_SECRET' in stored_settings.custom_secretsassert (- stored_settings.custom_secrets['EXISTING_SECRET'].get_secret_value()+ stored_settings.custom_secrets['EXISTING_SECRET'].secret.get_secret_value()== 'existing-value')@@ -218,8 +244,8 @@ async def test_delete_custom_secret(test_client, file_secrets_store):# Create initial settings with multiple custom secretscustom_secrets = {- 'API_KEY': SecretStr('api-key-value'),- 'DB_PASSWORD': SecretStr('db-password-value'),+ 'API_KEY': CustomSecret(secret=SecretStr('api-key-value')),+ 'DB_PASSWORD': CustomSecret(secret=SecretStr('db-password-value')),}provider_tokens = {ProviderType.GITHUB: ProviderToken(token=SecretStr('github-token'))@@ -244,7 +270,7 @@ async def test_delete_custom_secret(test_client, file_secrets_store):# Check that other secrets were preservedassert 'DB_PASSWORD' in stored_settings.custom_secretsassert (- stored_settings.custom_secrets['DB_PASSWORD'].get_secret_value()+ stored_settings.custom_secrets['DB_PASSWORD'].secret.get_secret_value()== 'db-password-value')@@ -257,7 +283,9 @@ async def test_delete_nonexistent_custom_secret(test_client, file_secrets_store)"""Test deleting a custom secret that doesn't exist."""# Create initial settings with a custom secret- custom_secrets = {'API_KEY': SecretStr('api-key-value')}+ custom_secrets = {+ 'API_KEY': CustomSecret(secret=SecretStr('api-key-value'), description='')+ }provider_tokens = {ProviderType.GITHUB: ProviderToken(token=SecretStr('github-token'))}@@ -278,7 +306,8 @@ async def test_delete_nonexistent_custom_secret(test_client, file_secrets_store)# Check that the existing secret was preservedassert 'API_KEY' in stored_settings.custom_secretsassert (- stored_settings.custom_secrets['API_KEY'].get_secret_value() == 'api-key-value'+ stored_settings.custom_secrets['API_KEY'].secret.get_secret_value()+ == 'api-key-value')# Check that other settings were preserved