Add heartbeat settings section defaults

Author: ibetitsmike

src/browser/features/Settings/Sections/GeneralSection.test.tsx

@@ -1,9 +1,8 @@
 import React from "react";
 import { cleanup, fireEvent, render, waitFor, within } from "@testing-library/react";
-import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 import { ThemeProvider } from "@/browser/contexts/ThemeContext";
 import * as ActualSelectPrimitiveModule from "@/browser/components/SelectPrimitive/SelectPrimitive";
-import * as ExperimentsModule from "@/browser/hooks/useExperiments";
 import { installDom } from "../../../../../tests/ui/dom";
 import {
   DEFAULT_CODER_ARCHIVE_BEHAVIOR,
@@ -18,7 +17,6 @@ interface MockConfig {
   coderWorkspaceArchiveBehavior: CoderWorkspaceArchiveBehavior;
   worktreeArchiveBehavior: WorktreeArchiveBehavior;
   llmDebugLogs: boolean;
-  heartbeatDefaultPrompt?: string;
 }
 
 interface MockAPIClient {
@@ -29,7 +27,6 @@ interface MockAPIClient {
       worktreeArchiveBehavior: WorktreeArchiveBehavior;
     }) => Promise<void>;
     updateLlmDebugLogs: (input: { enabled: boolean }) => Promise<void>;
-    updateHeartbeatDefaultPrompt: (input: { defaultPrompt?: string | null }) => Promise<void>;
   };
   server: {
     getSshHost: () => Promise<string | null>;
@@ -216,15 +213,6 @@ function createMockAPI(configOverrides: Partial<MockConfig> = {}): MockAPISetup
 
           return Promise.resolve();
         }),
-        updateHeartbeatDefaultPrompt: mock(
-          ({ defaultPrompt }: { defaultPrompt?: string | null }) => {
-            config.heartbeatDefaultPrompt = defaultPrompt?.trim()
-              ? defaultPrompt.trim()
-              : undefined;
-
-            return Promise.resolve();
-          }
-        ),
       },
       server: {
         getSshHost: mock(() => Promise.resolve(null)),
@@ -245,7 +233,6 @@ describe("GeneralSection", () => {
 
   beforeEach(() => {
     cleanupDom = installDom();
-    spyOn(ExperimentsModule, "useExperimentValue").mockImplementation(() => true);
   });
 
   afterEach(() => {
@@ -443,20 +430,6 @@ describe("GeneralSection", () => {
     });
   });
 
-  test("renders the heartbeat default prompt textarea when the experiment is enabled", () => {
-    const { view } = renderGeneralSection();
-
-    expect(view.getByLabelText("Default heartbeat prompt")).toBeTruthy();
-  });
-
-  test("hides the heartbeat default prompt textarea when the experiment is disabled", () => {
-    spyOn(ExperimentsModule, "useExperimentValue").mockImplementation(() => false);
-
-    const { view } = renderGeneralSection();
-
-    expect(view.queryByLabelText("Default heartbeat prompt")).toBeNull();
-  });
-
   test("disables archive settings until config finishes loading", async () => {
     const { api, getConfigMock, updateCoderPrefsMock } = createMockAPI({
       worktreeArchiveBehavior: DEFAULT_WORKTREE_ARCHIVE_BEHAVIOR,

src/browser/features/Settings/Sections/GeneralSection.tsx

@@ -10,9 +10,7 @@ import {
 import { Input } from "@/browser/components/Input/Input";
 import { Switch } from "@/browser/components/Switch/Switch";
 import { usePersistedState } from "@/browser/hooks/usePersistedState";
-import { useExperimentValue } from "@/browser/hooks/useExperiments";
 import { useAPI } from "@/browser/contexts/API";
-import { EXPERIMENT_IDS } from "@/common/constants/experiments";
 import { CUSTOM_EVENTS, createCustomEvent } from "@/common/constants/events";
 import {
   EDITOR_CONFIG_KEY,
@@ -41,7 +39,6 @@ import {
   isWorktreeArchiveBehavior,
   type WorktreeArchiveBehavior,
 } from "@/common/config/worktreeArchiveBehavior";
-import { HEARTBEAT_DEFAULT_MESSAGE_BODY } from "@/constants/heartbeat";
 
 // Guard against corrupted/old persisted settings (e.g. from a downgraded build).
 const ALLOWED_EDITOR_TYPES: ReadonlySet<EditorType> = new Set([
@@ -163,7 +160,6 @@ const isBrowserMode = typeof window !== "undefined" && !window.api;
 export function GeneralSection() {
   const { themePreference, setTheme } = useTheme();
   const { api } = useAPI();
-  const workspaceHeartbeatsEnabled = useExperimentValue(EXPERIMENT_IDS.WORKSPACE_HEARTBEATS);
   const [launchBehavior, setLaunchBehavior] = usePersistedState<LaunchBehavior>(
     LAUNCH_BEHAVIOR_KEY,
     "dashboard"
@@ -207,23 +203,18 @@ export function GeneralSection() {
   );
   const [archiveSettingsLoaded, setArchiveSettingsLoaded] = useState(false);
   const [llmDebugLogs, setLlmDebugLogs] = useState(false);
-  const [heartbeatDefaultPrompt, setHeartbeatDefaultPrompt] = useState("");
-  const [heartbeatDefaultPromptLoaded, setHeartbeatDefaultPromptLoaded] = useState(false);
-  const [heartbeatDefaultPromptLoadedOk, setHeartbeatDefaultPromptLoadedOk] = useState(false);
   const archiveBehaviorLoadNonceRef = useRef(0);
   const archiveBehaviorRef = useRef<CoderWorkspaceArchiveBehavior>(DEFAULT_CODER_ARCHIVE_BEHAVIOR);
   const worktreeArchiveBehaviorRef = useRef<WorktreeArchiveBehavior>(
     DEFAULT_WORKTREE_ARCHIVE_BEHAVIOR
   );
 
   const llmDebugLogsLoadNonceRef = useRef(0);
-  const heartbeatDefaultPromptLoadNonceRef = useRef(0);
 
   // updateCoderPrefs writes config.json on the backend. Serialize (and coalesce) updates so rapid
   // selections can't race and persist a stale value via out-of-order writes.
   const archiveBehaviorUpdateChainRef = useRef<Promise<void>>(Promise.resolve());
   const llmDebugLogsUpdateChainRef = useRef<Promise<void>>(Promise.resolve());
-  const heartbeatDefaultPromptUpdateChainRef = useRef<Promise<void>>(Promise.resolve());
   const archiveBehaviorPendingUpdateRef = useRef<CoderWorkspaceArchiveBehavior | undefined>(
     undefined
   );
@@ -237,11 +228,8 @@ export function GeneralSection() {
     }
 
     setArchiveSettingsLoaded(false);
-    setHeartbeatDefaultPromptLoaded(false);
-    setHeartbeatDefaultPromptLoadedOk(false);
     const archiveBehaviorNonce = ++archiveBehaviorLoadNonceRef.current;
     const llmDebugLogsNonce = ++llmDebugLogsLoadNonceRef.current;
-    const heartbeatDefaultPromptNonce = ++heartbeatDefaultPromptLoadNonceRef.current;
 
     void api.config
       .getConfig()
@@ -268,25 +256,13 @@ export function GeneralSection() {
         if (llmDebugLogsNonce === llmDebugLogsLoadNonceRef.current) {
           setLlmDebugLogs(cfg.llmDebugLogs === true);
         }
-
-        if (heartbeatDefaultPromptNonce === heartbeatDefaultPromptLoadNonceRef.current) {
-          setHeartbeatDefaultPrompt(cfg.heartbeatDefaultPrompt ?? "");
-          setHeartbeatDefaultPromptLoaded(true);
-          setHeartbeatDefaultPromptLoadedOk(true);
-        }
       })
       .catch(() => {
         if (archiveBehaviorNonce === archiveBehaviorLoadNonceRef.current) {
           // Fall back to the safe defaults already in state so the controls can recover after a
           // config read failure and the next user change can persist a fresh value.
           setArchiveSettingsLoaded(true);
         }
-
-        if (heartbeatDefaultPromptNonce === heartbeatDefaultPromptLoadNonceRef.current) {
-          // Keep the field editable after load failures, but avoid clearing an existing saved
-          // prompt unless the user has actively typed a replacement in this session.
-          setHeartbeatDefaultPromptLoaded(true);
-        }
       });
   }, [api]);
 
@@ -391,35 +367,6 @@ export function GeneralSection() {
       });
   };
 
-  const handleHeartbeatDefaultPromptBlur = useCallback(() => {
-    if (!heartbeatDefaultPromptLoaded || !api?.config?.updateHeartbeatDefaultPrompt) {
-      return;
-    }
-
-    const trimmedDefaultPrompt = heartbeatDefaultPrompt.trim();
-    if (!heartbeatDefaultPromptLoadedOk && !trimmedDefaultPrompt) {
-      return;
-    }
-
-    setHeartbeatDefaultPrompt(trimmedDefaultPrompt);
-
-    heartbeatDefaultPromptUpdateChainRef.current = heartbeatDefaultPromptUpdateChainRef.current
-      .catch(() => {
-        // Best-effort only.
-      })
-      .then(() =>
-        api.config.updateHeartbeatDefaultPrompt({
-          defaultPrompt: trimmedDefaultPrompt || null,
-        })
-      )
-      .then(() => {
-        setHeartbeatDefaultPromptLoadedOk(true);
-      })
-      .catch(() => {
-        // Best-effort persistence.
-      });
-  }, [api, heartbeatDefaultPrompt, heartbeatDefaultPromptLoaded, heartbeatDefaultPromptLoadedOk]);
-
   // Load SSH host from server on mount (browser mode only)
   useEffect(() => {
     if (isBrowserMode && api) {
@@ -612,30 +559,6 @@ export function GeneralSection() {
               aria-label="Toggle API Debug Logs"
             />
           </div>
-          {workspaceHeartbeatsEnabled ? (
-            <div className="py-3">
-              <label htmlFor="heartbeat-default-prompt" className="block">
-                <div className="text-foreground text-sm">Default heartbeat prompt</div>
-                <div className="text-muted mt-0.5 text-xs">
-                  Used for workspace heartbeats when a workspace does not set its own message.
-                </div>
-              </label>
-              <textarea
-                id="heartbeat-default-prompt"
-                rows={4}
-                value={heartbeatDefaultPrompt}
-                onChange={(event: React.ChangeEvent<HTMLTextAreaElement>) => {
-                  heartbeatDefaultPromptLoadNonceRef.current++;
-                  setHeartbeatDefaultPromptLoaded(true);
-                  setHeartbeatDefaultPrompt(event.target.value);
-                }}
-                onBlur={handleHeartbeatDefaultPromptBlur}
-                className="border-border-medium bg-background-secondary text-foreground focus:border-accent focus:ring-accent mt-3 min-h-[120px] w-full resize-y rounded-md border p-3 text-sm leading-relaxed focus:ring-1 focus:outline-none disabled:cursor-not-allowed disabled:opacity-50"
-                placeholder={HEARTBEAT_DEFAULT_MESSAGE_BODY}
-                aria-label="Default heartbeat prompt"
-              />
-            </div>
-          ) : null}
         </div>
       </div>
 

src/browser/features/Settings/Sections/HeartbeatSection.test.tsx

@@ -0,0 +1,149 @@
+import "../../../../../tests/ui/dom";
+
+import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { ThemeProvider } from "@/browser/contexts/ThemeContext";
+import { HEARTBEAT_DEFAULT_MESSAGE_BODY } from "@/constants/heartbeat";
+import { installDom } from "../../../../../tests/ui/dom";
+
+interface MockConfig {
+  heartbeatDefaultPrompt?: string;
+  heartbeatDefaultIntervalMs?: number;
+}
+
+interface MockAPIClient {
+  config: {
+    getConfig: () => Promise<MockConfig>;
+    updateHeartbeatDefaultPrompt: (input: { defaultPrompt?: string | null }) => Promise<void>;
+    updateHeartbeatDefaultIntervalMs: (input: { intervalMs?: number | null }) => Promise<void>;
+  };
+}
+
+let mockApi: MockAPIClient;
+
+void mock.module("@/browser/contexts/API", () => ({
+  useAPI: () => ({
+    api: mockApi,
+    status: "connected" as const,
+    error: null,
+    authenticate: () => undefined,
+    retry: () => undefined,
+  }),
+}));
+
+import { HeartbeatSection } from "./HeartbeatSection";
+
+function createMockAPI(configOverrides: Partial<MockConfig> = {}) {
+  const config: MockConfig = {
+    ...configOverrides,
+  };
+
+  const updateHeartbeatDefaultPromptMock = mock(
+    ({ defaultPrompt }: { defaultPrompt?: string | null }) => {
+      config.heartbeatDefaultPrompt = defaultPrompt?.trim() ? defaultPrompt.trim() : undefined;
+      return Promise.resolve();
+    }
+  );
+  const updateHeartbeatDefaultIntervalMsMock = mock(
+    ({ intervalMs }: { intervalMs?: number | null }) => {
+      config.heartbeatDefaultIntervalMs = intervalMs ?? undefined;
+      return Promise.resolve();
+    }
+  );
+
+  return {
+    api: {
+      config: {
+        getConfig: mock(() => Promise.resolve({ ...config })),
+        updateHeartbeatDefaultPrompt: updateHeartbeatDefaultPromptMock,
+        updateHeartbeatDefaultIntervalMs: updateHeartbeatDefaultIntervalMsMock,
+      },
+    },
+    updateHeartbeatDefaultPromptMock,
+    updateHeartbeatDefaultIntervalMsMock,
+  };
+}
+
+function renderHeartbeatSection(configOverrides: Partial<MockConfig> = {}) {
+  const { api, updateHeartbeatDefaultPromptMock, updateHeartbeatDefaultIntervalMsMock } =
+    createMockAPI(configOverrides);
+  mockApi = api;
+
+  const view = render(
+    <ThemeProvider forcedTheme="dark">
+      <HeartbeatSection />
+    </ThemeProvider>
+  );
+
+  return { view, updateHeartbeatDefaultPromptMock, updateHeartbeatDefaultIntervalMsMock };
+}
+
+describe("HeartbeatSection", () => {
+  let cleanupDom: (() => void) | null = null;
+
+  beforeEach(() => {
+    cleanupDom = installDom();
+  });
+
+  afterEach(() => {
+    cleanup();
+    mock.restore();
+    cleanupDom?.();
+    cleanupDom = null;
+  });
+
+  test("renders the default heartbeat controls", async () => {
+    const { view } = renderHeartbeatSection();
+
+    const thresholdInput = (await waitFor(() =>
+      view.getByLabelText("Default heartbeat threshold in minutes")
+    )) as HTMLInputElement;
+
+    expect(thresholdInput.value).toBe("30");
+    const promptField = view.getByLabelText("Default heartbeat prompt") as HTMLTextAreaElement;
+    expect(promptField.placeholder).toBe(HEARTBEAT_DEFAULT_MESSAGE_BODY);
+  });
+
+  test("loads and saves the default heartbeat prompt", async () => {
+    const initialPrompt = "Review pending work before acting.";
+    const { view, updateHeartbeatDefaultPromptMock } = renderHeartbeatSection({
+      heartbeatDefaultPrompt: initialPrompt,
+    });
+
+    const promptField = (await waitFor(() =>
+      view.getByLabelText("Default heartbeat prompt")
+    )) as HTMLTextAreaElement;
+
+    expect(promptField.value).toBe(initialPrompt);
+
+    fireEvent.blur(promptField);
+
+    await waitFor(() => {
+      expect(updateHeartbeatDefaultPromptMock.mock.calls[0]?.[0]).toEqual({
+        defaultPrompt: initialPrompt,
+      });
+    });
+  });
+
+  test("loads and saves the default heartbeat threshold", async () => {
+    const initialIntervalMs = 45 * 60_000;
+    const { view, updateHeartbeatDefaultIntervalMsMock } = renderHeartbeatSection({
+      heartbeatDefaultIntervalMs: initialIntervalMs,
+    });
+
+    const thresholdInput = (await waitFor(() =>
+      view.getByLabelText("Default heartbeat threshold in minutes")
+    )) as HTMLInputElement;
+
+    expect(thresholdInput.value).toBe("45");
+
+    fireEvent.blur(thresholdInput);
+
+    await waitFor(() => {
+      expect(updateHeartbeatDefaultIntervalMsMock.mock.calls[0]?.[0]).toEqual({
+        intervalMs: initialIntervalMs,
+      });
+    });
+  });
+});