Skip to content

πŸ™Œ OpenHands: AI-Driven Development

fix(automations): set local responder URL from browser origin (#16332)

Aditi Bhagat6670b4726a81
diff --git a/__tests__/api/secrets-service.test.ts b/__tests__/api/secrets-service.test.ts
index 9dbadbed59..41ce2959bb 100644
--- a/__tests__/api/secrets-service.test.ts
+++ b/__tests__/api/secrets-service.test.ts
@@ -8,19 +8,18 @@ import {
} from "#/api/backend-registry/active-store";
import { SecretsService } from "#/api/secrets-service";
-const {
- mockGetSecret,
- mockUpsertSecret,
- mockDeleteSecret,
-} = vi.hoisted(() => ({
- mockGetSecret: vi.fn(),
- mockUpsertSecret: vi.fn(),
- mockDeleteSecret: vi.fn(),
-}));
+const { mockListSecrets, mockGetSecret, mockUpsertSecret, mockDeleteSecret } =
+ vi.hoisted(() => ({
+ mockListSecrets: vi.fn(),
+ mockGetSecret: vi.fn(),
+ mockUpsertSecret: vi.fn(),
+ mockDeleteSecret: vi.fn(),
+ }));
vi.mock("@openhands/typescript-client/clients", () => ({
SettingsClient: vi.fn(function SettingsClientMock() {
return {
+ listSecrets: mockListSecrets,
getSecret: mockGetSecret,
upsertSecret: mockUpsertSecret,
deleteSecret: mockDeleteSecret,
@@ -42,6 +41,7 @@ describe("SecretsService", () => {
__resetActiveStoreForTests();
setRegisteredBackends([localBackend]);
setActiveSelection({ backendId: localBackend.id });
+ mockListSecrets.mockReset();
mockGetSecret.mockReset();
mockUpsertSecret.mockReset();
mockDeleteSecret.mockReset();
@@ -51,6 +51,17 @@ describe("SecretsService", () => {
__resetActiveStoreForTests();
});
+ it("lists local secret metadata through the strict read", async () => {
+ mockListSecrets.mockResolvedValue({
+ secrets: [{ name: "OPENHANDS_URL", description: "Canvas origin" }],
+ });
+
+ await expect(SecretsService.getSecretsOrThrow()).resolves.toEqual([
+ { name: "OPENHANDS_URL", description: "Canvas origin" },
+ ]);
+ expect(mockListSecrets).toHaveBeenCalledTimes(1);
+ });
+
it("preserves the existing value when updating description", async () => {
// Arrange
mockGetSecret.mockResolvedValue("keep-this");
diff --git a/__tests__/components/automations/recommended-automations.test.tsx b/__tests__/components/automations/recommended-automations.test.tsx
index cc4b73944a..7ca2db41aa 100644
--- a/__tests__/components/automations/recommended-automations.test.tsx
+++ b/__tests__/components/automations/recommended-automations.test.tsx
@@ -1,5 +1,6 @@
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import {
+ act,
fireEvent,
render,
screen,
@@ -9,6 +10,7 @@ import {
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import SettingsService from "#/api/settings-service/settings-service.api";
import McpService from "#/api/mcp-service/mcp-service.api";
+import { SecretsService } from "#/api/secrets-service";
import { I18nKey } from "#/i18n/declaration";
import { getConversationState } from "#/utils/conversation-local-storage";
import {
@@ -32,8 +34,15 @@ import {
type RecommendedAutomation,
} from "@openhands/extensions/automations";
-const { mockCreateConversationMutate, mockUseSettings } = vi.hoisted(() => ({
+const {
+ mockCreateConversationMutate,
+ mockCreateSecret,
+ mockDisplayErrorToast,
+ mockUseSettings,
+} = vi.hoisted(() => ({
mockCreateConversationMutate: vi.fn(),
+ mockCreateSecret: vi.fn(),
+ mockDisplayErrorToast: vi.fn(),
mockUseSettings: vi.fn(),
}));
@@ -54,10 +63,19 @@ vi.mock("#/hooks/mutation/use-create-conversation", () => ({
}),
}));
+vi.mock("#/hooks/mutation/use-create-secret", () => ({
+ useCreateSecret: () => ({ mutateAsync: mockCreateSecret }),
+}));
+
vi.mock("#/hooks/query/use-settings", () => ({
useSettings: () => mockUseSettings(),
}));
+vi.mock("#/utils/custom-toast-handlers", async (importOriginal) => ({
+ ...(await importOriginal()),
+ displayErrorToast: mockDisplayErrorToast,
+}));
+
const localBackend: Backend = {
id: "local-backend",
name: "Local",
@@ -96,15 +114,18 @@ function renderLauncher({ withBackendProvider = false } = {}) {
</NavigationProvider>
);
- return render(
- <QueryClientProvider client={queryClient}>
- {withBackendProvider ? (
- <ActiveBackendProvider>{launcher}</ActiveBackendProvider>
- ) : (
- launcher
- )}
- </QueryClientProvider>,
- );
+ return {
+ ...render(
+ <QueryClientProvider client={queryClient}>
+ {withBackendProvider ? (
+ <ActiveBackendProvider>{launcher}</ActiveBackendProvider>
+ ) : (
+ launcher
+ )}
+ </QueryClientProvider>,
+ ),
+ queryClient,
+ };
}
function settingsWithMcpConfig(mcp_config: unknown) {
@@ -124,6 +145,17 @@ function settingsWithGithubMcp() {
});
}
+function continueGithubResponderLocally() {
+ fireEvent.click(
+ screen.getByTestId("recommended-automation-card-github-pr-reviewer"),
+ );
+ const continueButton = screen.getByTestId(
+ "responder-deployment-continue-local",
+ );
+ fireEvent.click(continueButton);
+ return continueButton;
+}
+
describe("recommended automations", () => {
beforeEach(() => {
vi.clearAllMocks();
@@ -134,6 +166,8 @@ describe("recommended automations", () => {
mockUseSettings.mockReturnValue({
data: settingsWithMcpConfig({}),
});
+ vi.spyOn(SecretsService, "getSecretsOrThrow").mockResolvedValue([]);
+ mockCreateSecret.mockResolvedValue(undefined);
// Pre-flight connectivity test must pass so save mutations are reached.
vi.spyOn(McpService, "testServer").mockResolvedValue({
ok: true,
@@ -539,25 +573,155 @@ describe("recommended automations", () => {
expect(mockCreateConversationMutate).not.toHaveBeenCalled();
});
- it("opens the setup form for an automation that ships one, creating nothing", () => {
- // Arrange
+ it("saves OPENHANDS_URL before opening a responder setup form", async () => {
mockUseSettings.mockReturnValue({
data: settingsWithGithubMcp(),
});
renderLauncher();
+ continueGithubResponderLocally();
- // Act
- fireEvent.click(
- screen.getByTestId("recommended-automation-card-github-pr-reviewer"),
+ await waitFor(() =>
+ expect(mockCreateSecret).toHaveBeenCalledWith({
+ name: "OPENHANDS_URL",
+ value: window.location.origin,
+ }),
);
- fireEvent.click(screen.getByTestId("responder-deployment-continue-local"));
+ expect(mockCreateConversationMutate).not.toHaveBeenCalled();
+ });
- // Assert β€” nothing exists until the user confirms in the setup form.
- expect(mockNavigate).toHaveBeenCalledWith(
- "/automations/new/github-pr-reviewer",
+ it("preserves an existing OPENHANDS_URL when starting a local responder", async () => {
+ mockUseSettings.mockReturnValue({
+ data: settingsWithGithubMcp(),
+ });
+ vi.mocked(SecretsService.getSecretsOrThrow).mockResolvedValue([
+ { name: "OPENHANDS_URL" },
+ ]);
+
+ renderLauncher();
+
+ continueGithubResponderLocally();
+
+ await waitFor(() =>
+ expect(mockNavigate).toHaveBeenCalledWith(
+ "/automations/new/github-pr-reviewer",
+ ),
);
- expect(mockCreateConversationMutate).not.toHaveBeenCalled();
+ expect(mockCreateSecret).not.toHaveBeenCalled();
+ });
+
+ it("uses fresh secrets instead of a cached OPENHANDS_URL", async () => {
+ mockUseSettings.mockReturnValue({ data: settingsWithGithubMcp() });
+ const { queryClient } = renderLauncher();
+ queryClient.setQueryData(
+ ["secrets", localBackend.id, null],
+ [{ name: "OPENHANDS_URL" }],
+ );
+
+ continueGithubResponderLocally();
+
+ await waitFor(() => expect(mockCreateSecret).toHaveBeenCalledTimes(1));
+ expect(SecretsService.getSecretsOrThrow).toHaveBeenCalledTimes(1);
+ });
+
+ it("matches the OPENHANDS_URL secret name exactly", async () => {
+ mockUseSettings.mockReturnValue({ data: settingsWithGithubMcp() });
+ vi.mocked(SecretsService.getSecretsOrThrow).mockResolvedValue([
+ { name: "OPENHANDS_URL_BACKUP" },
+ ]);
+
+ renderLauncher();
+ continueGithubResponderLocally();
+
+ await waitFor(() => expect(mockCreateSecret).toHaveBeenCalledTimes(1));
+ });
+
+ it("waits for the secret save and invalidates the cache before continuing", async () => {
+ mockUseSettings.mockReturnValue({ data: settingsWithGithubMcp() });
+ let resolveSave: (() => void) | undefined;
+ mockCreateSecret.mockReturnValue(
+ new Promise<void>((resolve) => {
+ resolveSave = resolve;
+ }),
+ );
+ const { queryClient } = renderLauncher();
+ const invalidateSpy = vi.spyOn(queryClient, "invalidateQueries");
+
+ const continueButton = continueGithubResponderLocally();
+
+ await waitFor(() => expect(mockCreateSecret).toHaveBeenCalledTimes(1));
+ expect(continueButton).toBeDisabled();
+ expect(mockNavigate).not.toHaveBeenCalled();
+
+ await act(async () => resolveSave?.());
+
+ await waitFor(() => expect(mockNavigate).toHaveBeenCalledTimes(1));
+ expect(invalidateSpy).toHaveBeenCalledWith({ queryKey: ["secrets"] });
+ expect(invalidateSpy.mock.invocationCallOrder[0]).toBeLessThan(
+ mockNavigate.mock.invocationCallOrder[0],
+ );
+ });
+
+ it("keeps the responder modal open when the fresh secret read fails", async () => {
+ mockUseSettings.mockReturnValue({ data: settingsWithGithubMcp() });
+ vi.mocked(SecretsService.getSecretsOrThrow).mockRejectedValue(
+ new Error("secret read failed"),
+ );
+
+ renderLauncher();
+ continueGithubResponderLocally();
+
+ await waitFor(() =>
+ expect(mockDisplayErrorToast).toHaveBeenCalledWith("secret read failed"),
+ );
+ expect(
+ screen.getByTestId("responder-deployment-modal"),
+ ).toBeInTheDocument();
+ expect(mockCreateSecret).not.toHaveBeenCalled();
+ expect(mockNavigate).not.toHaveBeenCalled();
+ });
+
+ it("blocks duplicate local continues while secrets are loading", async () => {
+ mockUseSettings.mockReturnValue({ data: settingsWithGithubMcp() });
+ vi.mocked(SecretsService.getSecretsOrThrow).mockReturnValue(
+ new Promise(() => {}),
+ );
+
+ renderLauncher();
+ const continueButton = continueGithubResponderLocally();
+ fireEvent.click(continueButton);
+
+ await waitFor(() =>
+ expect(SecretsService.getSecretsOrThrow).toHaveBeenCalledTimes(1),
+ );
+ expect(continueButton).toBeDisabled();
+ expect(
+ screen.getByTestId("responder-deployment-modal-close"),
+ ).toBeDisabled();
+ expect(
+ screen.getByTestId("responder-deployment-open-openhands-cloud"),
+ ).toBeDisabled();
+ expect(mockCreateSecret).not.toHaveBeenCalled();
+ expect(mockNavigate).not.toHaveBeenCalled();
+ });
+
+ it("does not continue or close the modal when the secret save fails", async () => {
+ mockUseSettings.mockReturnValue({ data: settingsWithGithubMcp() });
+ mockCreateSecret.mockRejectedValue(new Error("secret save failed"));
+
+ renderLauncher();
+ continueGithubResponderLocally();
+
+ await waitFor(() => expect(mockCreateSecret).toHaveBeenCalledTimes(1));
+ await waitFor(() =>
+ expect(
+ screen.getByTestId("responder-deployment-continue-local"),
+ ).not.toBeDisabled(),
+ );
+ expect(
+ screen.getByTestId("responder-deployment-modal"),
+ ).toBeInTheDocument();
+ expect(mockNavigate).not.toHaveBeenCalled();
});
it("launches an automation that ships no setup form with its slash command", () => {
@@ -632,7 +796,7 @@ describe("recommended automations", () => {
expect(mockCreateConversationMutate).not.toHaveBeenCalled();
});
- it("ignores repeated launches once a responder deployment choice is in flight", () => {
+ it("ignores repeated launches once a responder deployment choice is in flight", async () => {
mockUseSettings.mockReturnValue({
data: settingsWithGithubMcp(),
});
@@ -648,7 +812,7 @@ describe("recommended automations", () => {
screen.getByTestId("recommended-automation-card-github-pr-reviewer"),
);
- expect(mockNavigate).toHaveBeenCalledTimes(1);
+ await waitFor(() => expect(mockNavigate).toHaveBeenCalledTimes(1));
});
it("hides the recommended automations section on cloud backends", () => {
@@ -706,6 +870,7 @@ describe("recommended automations", () => {
"noopener,noreferrer",
);
expect(mockCreateConversationMutate).not.toHaveBeenCalled();
+ expect(mockCreateSecret).not.toHaveBeenCalled();
openSpy.mockRestore();
});
@@ -720,5 +885,6 @@ describe("recommended automations", () => {
expect(
screen.queryByTestId("responder-deployment-modal"),
).not.toBeInTheDocument();
+ expect(mockCreateSecret).not.toHaveBeenCalled();
});
});
diff --git a/src/api/secrets-service.ts b/src/api/secrets-service.ts
index accb2f0dcc..ed31385918 100644
--- a/src/api/secrets-service.ts
+++ b/src/api/secrets-service.ts
@@ -10,6 +10,19 @@ import { getAgentServerClientOptions } from "./agent-server-client-options";
import { CustomSecretWithoutValue } from "./secrets-service.types";
import { withRetry } from "./with-retry";
+async function fetchSecrets(): Promise<CustomSecretWithoutValue[]> {
+ if (getActiveBackend().backend.kind === "cloud") {
+ return withRetry(() => fetchCloudSecrets());
+ }
+ const response = await withRetry(() =>
+ new SettingsClient(getAgentServerClientOptions()).listSecrets(),
+ );
+ return response.secrets.map((s) => ({
+ name: s.name,
+ description: s.description,
+ }));
+}
+
export class SecretsService {
/**
* List all custom secrets (names and descriptions only, no values).
@@ -20,22 +33,21 @@ export class SecretsService {
*/
static async getSecrets(): Promise<CustomSecretWithoutValue[]> {
try {
- if (getActiveBackend().backend.kind === "cloud") {
- return await withRetry(() => fetchCloudSecrets());
- }
- const response = await withRetry(() =>
- new SettingsClient(getAgentServerClientOptions()).listSecrets(),
- );
- return response.secrets.map((s) => ({
- name: s.name,
- description: s.description,
- }));
+ return await fetchSecrets();
} catch (error) {
console.error("Failed to fetch secrets after retries:", error);
return [];
}
}
+ /**
+ * List all custom secrets, surfacing failures to callers that must
+ * distinguish an unavailable list from an empty one.
+ */
+ static async getSecretsOrThrow(): Promise<CustomSecretWithoutValue[]> {
+ return fetchSecrets();
+ }
+
/**
* Create or update a custom secret (upsert by name).
* Uses the agent-server API endpoint: PUT /api/settings/secrets
diff --git a/src/components/features/automations/recommended-automations-launcher.tsx b/src/components/features/automations/recommended-automations-launcher.tsx
index 2f67ec4fbb..57f753dbfb 100644
--- a/src/components/features/automations/recommended-automations-launcher.tsx
+++ b/src/components/features/automations/recommended-automations-launcher.tsx
@@ -4,6 +4,7 @@ import { useNavigation } from "#/context/navigation-context";
import { useCreateConversation } from "#/hooks/mutation/use-create-conversation";
import { useSettings } from "#/hooks/query/use-settings";
import { useIsCreatingConversation } from "#/hooks/use-is-creating-conversation";
+import { useResponderUrlSecret } from "#/hooks/use-responder-url-secret";
import { useConversationStore } from "#/stores/conversation-store";
import {
setConversationState,
@@ -67,6 +68,7 @@ export function RecommendedAutomationsLauncher({
const { data: settings } = useSettings();
const { trackPrebuiltAutomationEnabled } = useTracking();
const createConversation = useCreateConversation();
+ const ensureResponderUrlSecret = useResponderUrlSecret();
const isCreatingConversation = useIsCreatingConversation();
const setMessageToSend = useConversationStore(
(state) => state.setMessageToSend,
@@ -78,6 +80,9 @@ export function RecommendedAutomationsLauncher({
const [installQueue, setInstallQueue] = useState<MarketplaceEntry[]>([]);
const completedInstallRef = useRef(false);
const launchInFlightRef = useRef(false);
+ const localSetupInFlightRef = useRef(false);
+ const [isPreparingLocalResponder, setIsPreparingLocalResponder] =
+ useState(false);
const installedMcpConfig = useMemo(
() =>
@@ -189,11 +194,22 @@ export function RecommendedAutomationsLauncher({
proceedWithLocalLaunch(automation);
};
- const handleDeploymentContinueLocal = () => {
+ const handleDeploymentContinueLocal = async () => {
const automation = deploymentChoiceAutomation;
- setDeploymentChoiceAutomation(null);
- if (automation) {
+ if (!automation || localSetupInFlightRef.current) return;
+
+ localSetupInFlightRef.current = true;
+ setIsPreparingLocalResponder(true);
+
+ try {
+ const isSecretReady = await ensureResponderUrlSecret();
+ if (!isSecretReady) return;
+
+ setDeploymentChoiceAutomation(null);
proceedWithLocalLaunch(automation);
+ } finally {
+ localSetupInFlightRef.current = false;
+ setIsPreparingLocalResponder(false);
}
};
@@ -261,6 +277,7 @@ export function RecommendedAutomationsLauncher({
<ResponderDeploymentModal
isOpen={deploymentChoiceAutomation !== null}
+ isPending={isPreparingLocalResponder}
onClose={handleDeploymentClose}
onContinueLocal={handleDeploymentContinueLocal}
onOpenUrl={handleDeploymentOpenUrl}
diff --git a/src/components/features/automations/responder-deployment-modal.tsx b/src/components/features/automations/responder-deployment-modal.tsx
index 85fc5e6613..515d97b3c3 100644
--- a/src/components/features/automations/responder-deployment-modal.tsx
+++ b/src/components/features/automations/responder-deployment-modal.tsx
@@ -12,6 +12,7 @@ import {
interface ResponderDeploymentModalProps {
isOpen: boolean;
+ isPending: boolean;
onClose: () => void;
/** Fired for the "Continue with local setup" action. */
onContinueLocal: () => void;
@@ -21,6 +22,7 @@ interface ResponderDeploymentModalProps {
export function ResponderDeploymentModal({
isOpen,
+ isPending,
onClose,
onContinueLocal,
onOpenUrl,
@@ -32,6 +34,8 @@ export function ResponderDeploymentModal({
return (
<ModalBackdrop
onClose={onClose}
+ closeOnEscape={!isPending}
+ closeOnBackdropClick={!isPending}
aria-label={t(I18nKey.RESPONDER_DEPLOYMENT$TITLE)}
>
<div
@@ -41,6 +45,7 @@ export function ResponderDeploymentModal({
<ModalCloseButton
onClose={onClose}
testId="responder-deployment-modal-close"
+ disabled={isPending}
/>
<header className="flex-shrink-0 px-6 pb-4 pt-6">
<h2 className={cn("pr-6", modalTitleLgClassName)}>
@@ -73,6 +78,12 @@ export function ResponderDeploymentModal({
variant="primary"
className="mt-auto"
testId={option.primaryActionTestId}
+ isDisabled={isPending}
+ aria-busy={
+ isPending && action.kind === "launch-local"
+ ? true
+ : undefined
+ }
onClick={() => {
if (action.kind === "launch-local") {
onContinueLocal();
diff --git a/src/hooks/use-responder-url-secret.ts b/src/hooks/use-responder-url-secret.ts
new file mode 100644
index 0000000000..744be33538
--- /dev/null
+++ b/src/hooks/use-responder-url-secret.ts
@@ -0,0 +1,60 @@
+import { useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { SecretsService } from "#/api/secrets-service";
+import { useActiveBackend } from "#/contexts/active-backend-context";
+import { I18nKey } from "#/i18n/declaration";
+import i18n from "#/i18n";
+import { useCreateSecret } from "#/hooks/mutation/use-create-secret";
+import { displayErrorToast } from "#/utils/custom-toast-handlers";
+import { retrieveAxiosErrorMessage } from "#/utils/retrieve-axios-error-message";
+
+const OPENHANDS_URL_SECRET_NAME = "OPENHANDS_URL";
+
+/**
+ * Provides an operation that ensures the active backend has an OPENHANDS_URL
+ * secret without overwriting an existing value.
+ */
+export function useResponderUrlSecret() {
+ const activeBackend = useActiveBackend();
+ const queryClient = useQueryClient();
+ const { mutateAsync: createSecret } = useCreateSecret();
+
+ return useCallback(async (): Promise<boolean> => {
+ let secrets;
+ try {
+ secrets = await queryClient.fetchQuery({
+ queryKey: ["secrets", activeBackend.backend.id, activeBackend.orgId],
+ queryFn: SecretsService.getSecretsOrThrow,
+ staleTime: 0,
+ retry: false,
+ meta: { disableToast: true },
+ });
+ } catch (error) {
+ const message = retrieveAxiosErrorMessage(error);
+ displayErrorToast(message || i18n.t(I18nKey.ERROR$GENERIC));
+ return false;
+ }
+
+ if (secrets.some((secret) => secret.name === OPENHANDS_URL_SECRET_NAME)) {
+ return true;
+ }
+
+ try {
+ await createSecret({
+ name: OPENHANDS_URL_SECRET_NAME,
+ value: window.location.origin,
+ });
+ } catch {
+ // The shared mutation cache displays the error toast.
+ return false;
+ }
+
+ await queryClient.invalidateQueries({ queryKey: ["secrets"] });
+ return true;
+ }, [
+ activeBackend.backend.id,
+ activeBackend.orgId,
+ createSecret,
+ queryClient,
+ ]);
+}