YC (S26) | Open Computer History | Continuously record your company computer work, map your workflows, help you find work worth automating, and power your agents' context
Rust agentsagiaiai-memoryaudio-recordingcomputer-visionhermeshermes-agentllmlocal-ailocal-firstmachine-learningmcpmultimodalopenclawprivacyrewindscreen-recordingspeech-to-textycombinator
fix(overlay): add Wispr-style hiding controls (#6317)
Louis Beaumont362bf60d45c7
diff --git a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsxindex 778048ed7..b22305528 100644--- a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx+++ b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.test.tsx@@ -20,6 +20,7 @@ const mocks = vi.hoisted(() => ({storeGet: vi.fn(),storeSet: vi.fn(),hideShortcutReminder: vi.fn(),+ snoozeShortcutReminderForHour: vi.fn(),showWindow: vi.fn(),setSize: vi.fn(),setPosition: vi.fn(),@@ -118,6 +119,7 @@ vi.mock("@/lib/utils/tauri", () => ({overlayRestartRecording: vi.fn(),overlayDismissIncident: vi.fn(),hideShortcutReminder: mocks.hideShortcutReminder,+ snoozeShortcutReminderForHour: mocks.snoozeShortcutReminderForHour,showWindow: mocks.showWindow,setShortcutOverlayAnchor: mocks.setShortcutOverlayAnchor,},@@ -155,6 +157,8 @@ describe("recording health hover detail", () => {mocks.stopMeeting.mockReset();mocks.storeSet.mockReset();mocks.hideShortcutReminder.mockReset();+ mocks.snoozeShortcutReminderForHour.mockReset();+ mocks.snoozeShortcutReminderForHour.mockResolvedValue({ status: "ok", data: null });mocks.showWindow.mockReset();mocks.setSize.mockReset();mocks.setPosition.mockReset();@@ -306,7 +310,7 @@ describe("recording health hover detail", () => {expect(meetingDot.className).toContain("pointer-events-none");});- it("cannot be hidden from the gear — it opens Display settings instead", async () => {+ it("offers Wispr-style one-hour hiding and a path to Display settings", async () => {mocks.getRecordingHealthState.mockResolvedValue("normal");mocks.storeGet.mockResolvedValue({});@@ -315,12 +319,16 @@ describe("recording health hover detail", () => {fireEvent.mouseEnter(await screen.findByTestId("shortcut-reminder-root"));fireEvent.click(await screen.findByTitle("Overlay settings"));- // The gear never hides the pill. Even when `overlay-hiding-control` grants- // the capability back, the switch lives in Display settings, not here.- expect(screen.queryByTitle("Hide for today")).toBeNull();- expect(screen.queryByTitle("Hide for a week")).toBeNull();- expect(mocks.hideShortcutReminder).not.toHaveBeenCalled();- expect(mocks.storeSet).not.toHaveBeenCalled();+ expect(screen.getByRole("menu", { name: "Shortcut reminder options" })).toBeVisible();+ fireEvent.click(screen.getByTitle("Hide for 1 hour"));++ await waitFor(() =>+ expect(mocks.snoozeShortcutReminderForHour).toHaveBeenCalledTimes(1),+ );++ fireEvent.mouseEnter(screen.getByTestId("shortcut-reminder-root"));+ fireEvent.click(screen.getByTitle("Overlay settings"));+ fireEvent.click(screen.getByTitle("Open overlay settings"));expect(mocks.showWindow).toHaveBeenCalledWith({ Home: { page: "display" } });});diff --git a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsxindex 8a281843b..c1be3bc07 100644--- a/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx+++ b/apps/screenpipe-app-tauri/app/shortcut-reminder/page.tsx@@ -63,6 +63,7 @@ const DEFAULT_SHORTCUTS = {const COLLAPSED_SIZE = { width: 22, height: 16 };const EXPANDED_SIZE = { width: 160, height: 62 };+const SETTINGS_MENU_SIZE = { width: 164, height: 96 };const INCIDENT_SIZE = { width: 160, height: 40 };const MEETING_SIZE = { width: 280, height: 80 };@@ -85,6 +86,7 @@ export default function ShortcutReminderPage() {const [hoverMeetingId, setHoverMeetingId] = useState<number | null>(null);const [pinnedMeetingId, setPinnedMeetingId] = useState<number | null>(null);const [expanded, setExpanded] = useState(false);+ const [settingsOpen, setSettingsOpen] = useState(false);const [hoveredControl, setHoveredControl] = useState<string | null>(null);const [overlayScale, setOverlayScale] = useState(1);const [anchor, setAnchor] = useState<OverlayAnchor>(DEFAULT_OVERLAY_ANCHOR);@@ -354,6 +356,8 @@ export default function ShortcutReminderPage() {resizeOverlay(INCIDENT_SIZE);} else if (meetingOverlay.active && meetingCardOpen) {resizeOverlay(MEETING_SIZE);+ } else if (settingsOpen) {+ resizeOverlay(SETTINGS_MENU_SIZE);} else if (expanded) {resizeOverlay(EXPANDED_SIZE);} else {@@ -366,6 +370,7 @@ export default function ShortcutReminderPage() {meetingCardOpen,meetingOverlay.active,resizeOverlay,+ settingsOpen,]);const handleRestartRecording = useCallback(async (e: React.MouseEvent) => {@@ -409,10 +414,29 @@ export default function ShortcutReminderPage() {const handleOpenSettings = useCallback((e: React.MouseEvent) => {e.preventDefault();e.stopPropagation();+ setSettingsOpen(false);posthog.capture("shortcut_reminder_overlay_settings_clicked");void commands.showWindow({ Home: { page: "display" } });}, []);+ const handleHourSnooze = useCallback(async (e: React.MouseEvent) => {+ e.preventDefault();+ e.stopPropagation();+ // Close immediately so a slow encrypted-store write cannot close a menu+ // the user reopened while the reminder is still animating away.+ setSettingsOpen(false);+ try {+ const result = await commands.snoozeShortcutReminderForHour();+ if (result.status === "error") throw new Error(result.error);+ posthog.capture("shortcut_reminder_dismissed", {+ dismiss_scope: "hour",+ snooze_hours: 1,+ });+ } catch (error) {+ console.error("Failed to snooze shortcut reminder:", error);+ }+ }, []);+// Size tokens are scaled inline instead of via CSS `transform: scale()` so// we avoid subpixel-rounding clipping at non-integer scales (e.g. 1.5×)// and don't double-compensate the window — Rust already sizes the Tauri@@ -761,6 +785,7 @@ export default function ShortcutReminderPage() {}}onMouseLeave={() => {setExpanded(false);+ setSettingsOpen(false);setHoveredControl(null);}}>@@ -834,20 +859,55 @@ export default function ShortcutReminderPage() {onMouseEnter={() => setHoveredControl("settings")}onMouseDown={(e) => e.stopPropagation()}onPointerDown={(e) => e.stopPropagation()}- onClick={handleOpenSettings}+ onClick={(e) => {+ e.stopPropagation();+ setSettingsOpen((open) => !open);+ }}><Settings style={{ width: `${12 * overlayScale}px`, height: `${12 * overlayScale}px` }} /></button></div>- {/* The label row only exists while a control is hovered. The native panel+ {settingsOpen ? (+ <div+ role="menu"+ aria-label="Shortcut reminder options"+ className="flex w-full min-h-0 flex-1 flex-col overflow-hidden border border-white/40 font-mono text-white/85"+ style={{+ marginTop: dockAbove ? `${4 * overlayScale}px` : 0,+ marginBottom: dockAbove ? 0 : `${4 * overlayScale}px`,+ background: "rgba(0, 0, 0, 0.96)",+ borderRadius: `${4 * overlayScale}px`,+ fontSize: `${fontPx}px`,+ }}+ >+ <button+ role="menuitem"+ className="flex-1 px-2 text-left hover:bg-white/15"+ title="Hide for 1 hour"+ onClick={(e) => void handleHourSnooze(e)}+ >+ hide for 1 hour+ </button>+ <div className="mx-2 bg-white/20" style={{ height: "1px" }} />+ <button+ role="menuitem"+ className="flex-1 px-2 text-left hover:bg-white/15"+ title="Open overlay settings"+ onClick={handleOpenSettings}+ >+ settings…+ </button>+ </div>+ ) : (+ /* The label row only exists while a control is hovered. The native panelkeeps this area transparent (`Color.clear`) and floats the label underthe hovered icon; painting it unconditionally left an empty black barhanging under the dock whenever the pointer sat between icons. The- reserved height stays either way so the dock never shifts. */}- <div- className="flex w-full min-h-0 flex-1 items-center justify-center overflow-hidden font-mono text-white/75"- style={{+ reserved height stays either way so the dock never shifts. */+ <div+ className="flex w-full min-h-0 flex-1 items-center justify-center overflow-hidden font-mono text-white/75"+ style={{maxHeight: `${26 * overlayScale}px`,// The gap belongs between the two rows, and `column-reverse` does not// flip which physical side a margin lands on. Keeping it on `top`@@ -859,15 +919,16 @@ export default function ShortcutReminderPage() {border: `1px solid ${disclosure ? "rgba(255, 255, 255, 0.25)" : "transparent"}`,borderRadius: `${4 * overlayScale}px`,fontSize: `${fontPx}px`,- }}- >- {disclosure ? (- <span className="truncate px-1">- {disclosure[0]}- {disclosure[1] ? ` ${disclosure[1]}` : ""}- </span>- ) : null}- </div>+ }}+ >+ {disclosure ? (+ <span className="truncate px-1">+ {disclosure[0]}+ {disclosure[1] ? ` ${disclosure[1]}` : ""}+ </span>+ ) : null}+ </div>+ )}</div>);}diff --git a/apps/screenpipe-app-tauri/components/settings/display-section.tsx b/apps/screenpipe-app-tauri/components/settings/display-section.tsxindex a97d22fab..1bdf629c3 100644--- a/apps/screenpipe-app-tauri/components/settings/display-section.tsx+++ b/apps/screenpipe-app-tauri/components/settings/display-section.tsx@@ -556,9 +556,6 @@ export function DisplaySection() {opens the timeline — hide the whole section when the timeline is off. */}{!(settings?.disableTimeline ?? false) && (<>- {/* The overlay ships unhideable because it carries recording health,- live meeting state and meeting alerts. `overlay-hiding-control`- hands the switch back remotely if that proves too strict. */}<Card className="border-border bg-card"><CardContent className="px-3 py-2.5"><div className="flex items-center justify-between">@@ -566,32 +563,30 @@ export function DisplaySection() {<Monitor className="h-4 w-4 text-muted-foreground shrink-0" /><div><h3 className="text-sm font-medium text-foreground">Shortcut Reminder</h3>- {/* Only the "always on screen" claim depends on the flag.- The drag hint is true either way and is the only place- pinning is discoverable, so it stays in both. */}<p className="text-xs text-muted-foreground">- {settings?.allowHidingShortcutOverlay- ? "Carries recording health, live meeting state and meeting alerts. Drag it to pin it to any corner or edge."- : "Always on screen. It carries recording health, live meeting state and meeting alerts. Drag it to pin it to any corner or edge."}+ Show the floating shortcut bar. Recording problems can still surface temporarily.</p></div></div>- {settings?.allowHidingShortcutOverlay && (- <Switch- id="shortcut-overlay"- checked={settings?.showShortcutOverlay ?? true}- onCheckedChange={async (checked) => {- handleSettingsChange({ showShortcutOverlay: checked });- try {- if (checked) {- await commands.showShortcutReminder(settings.showScreenpipeShortcut);- } else {- await commands.hideShortcutReminder();- }- } catch (e) {}- }}- />- )}+ <Switch+ id="shortcut-overlay"+ checked={settings?.showShortcutOverlay ?? true}+ onCheckedChange={async (checked) => {+ await updateSettings({+ showShortcutOverlay: checked,+ shortcutOverlaySnoozedUntil: null,+ });+ try {+ if (checked) {+ await commands.showShortcutReminder(settings.showScreenpipeShortcut);+ } else {+ await commands.hideShortcutReminder();+ }+ } catch (error) {+ console.warn("failed to update shortcut reminder visibility", error);+ }+ }}+ /></div></CardContent></Card>diff --git a/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts b/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.tsindex 479e71d9b..79f211c28 100644--- a/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts+++ b/apps/screenpipe-app-tauri/e2e/specs/windows-user-journey.spec.ts@@ -647,7 +647,7 @@ describe("Windows user journey", function () {expect(existsSync(shortcutsScreenshot)).toBe(true);});- it("keeps the shortcut reminder overlay on screen and drives its dock actions", async function () {+ it("lets users control the shortcut reminder and drives its dock actions", async function () {if (!isWindows) this.skip();await openHomeWindow();@@ -660,10 +660,8 @@ describe("Windows user journey", function () {await displayNav.waitForDisplayed({ timeout: t(15_000) });await displayNav.click();- // The overlay carries recording health, live meeting state and meeting- // alerts, so it ships unhideable and Display offers only a size. The- // `overlay-hiding-control` remote flag can restore the switch, but it is- // off by default and E2E never initializes PostHog.+ // Like Wispr Flow, the persistent choice lives in Settings while the+ // floating menu owns the temporary one-hour snooze.await waitForBodyText((bodyText) =>bodyText.includes("theme, windows, and overlay appearance") &&@@ -671,7 +669,7 @@ describe("Windows user journey", function () {bodyText.includes("overlay size"),"Display settings did not show the shortcut reminder controls",);- expect(await $("#shortcut-overlay").isExisting()).toBe(false);+ expect(await $("#shortcut-overlay").isExisting()).toBe(true);try {await expectShortcutReminderVisible(true, t(20_000));@@ -790,10 +788,12 @@ describe("Windows user journey", function () {await overlaySettingsButton.waitForDisplayed({ timeout: t(10_000) });await overlaySettingsButton.click();- // The gear opens Display settings; it must not offer to hide the pill,- // and the pill must still be on screen afterwards.- expect(await $('button[title="Hide for today"]').isExisting()).toBe(false);- expect(await $('button[title="Hide for a week"]').isExisting()).toBe(false);+ // Match Wispr Flow's progressive disclosure: the floating bar offers a+ // one-hour snooze and links to the persistent control in Display.+ const hideForHourButton = await $('button[title="Hide for 1 hour"]');+ await hideForHourButton.waitForDisplayed({ timeout: t(10_000) });+ const persistentSettingsButton = await $('button[title="Open overlay settings"]');+ await persistentSettingsButton.waitForDisplayed({ timeout: t(10_000) });await expectShortcutReminderVisible(true, t(20_000));} finally {if ((await browser.getWindowHandles()).includes("home")) {diff --git a/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts b/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.tsindex bec06e593..c18a250ee 100644--- a/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts+++ b/apps/screenpipe-app-tauri/lib/desktop-remote-control.test.ts@@ -340,8 +340,8 @@ describe("desktop remote control", () => {).toEqual([]);});- it("ships the overlay unhideable and never seeds a local opt-in", () => {- // Shipped: the capability is off, so the Display toggle stays absent.+ it("ships the rollout capability disabled and never seeds a local opt-in", () => {+ // The user-facing visibility choice is independent of this legacy rollout.expect(resolveBooleanRemoteControlValue("overlayHiding",@@ -350,7 +350,7 @@ describe("desktop remote control", () => {),).toBe(false);- // Remote grant: the toggle comes back without a release.+ // Managed installs can still grant the legacy capability remotely.expect(resolveBooleanRemoteControlValue("overlayHiding", null, {defaultEnabled: true,@@ -358,8 +358,7 @@ describe("desktop remote control", () => {}),).toBe(true);- // Nothing lets a user grant themselves the capability, so the preference- // must stay null forever — a seeded value would make the flag a no-op.+ // The capability remains inherited rather than becoming sticky.expect(normalizeDesktopRemotePreferences({allowHidingShortcutOverlay: true,diff --git a/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts b/apps/screenpipe-app-tauri/lib/desktop-remote-control.tsindex ca2bb7c67..c765bccdc 100644--- a/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts+++ b/apps/screenpipe-app-tauri/lib/desktop-remote-control.ts@@ -43,10 +43,8 @@ export const BOOLEAN_REMOTE_CONTROL_DEFINITIONS = {settingKey: "enableSidebarCustomization",shippedDefault: false,},- // Whether the user is allowed to hide the shortcut overlay at all. The- // overlay carries recording health, live meeting state and meeting alerts,- // so it ships unhideable; this is the remote escape hatch that gives the- // Display toggle back if that turns out to be too strict.+ // Compatibility control retained for managed installs. The consumer UI's+ // visibility choice is independent from this rollout capability.overlayHiding: {flagKey: "overlay-hiding-control",settingKey: "allowHidingShortcutOverlay",diff --git a/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx b/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsxindex e29a0d1e4..2f225f48e 100644--- a/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx+++ b/apps/screenpipe-app-tauri/lib/hooks/use-settings.tsx@@ -783,6 +783,7 @@ let DEFAULT_SETTINGS: Settings = {enableSidebarCustomization: false,allowHidingShortcutOverlay: false,showShortcutOverlay: true,+ shortcutOverlaySnoozedUntil: null,sidebarNavLayout: { ...DEFAULT_SIDEBAR_NAV_LAYOUT },ignoreIncognitoWindows: true,enhancedIncognitoDetection: false,diff --git a/apps/screenpipe-app-tauri/lib/utils/tauri.ts b/apps/screenpipe-app-tauri/lib/utils/tauri.tsindex 95971ff7d..e30d0fad7 100644--- a/apps/screenpipe-app-tauri/lib/utils/tauri.ts+++ b/apps/screenpipe-app-tauri/lib/utils/tauri.ts@@ -2445,6 +2445,14 @@ async showWindowActivated(window: ShowRewindWindow) : Promise<Result<null, strinelse return { status: "error", error: e as any };}},+async snoozeShortcutReminderForHour() : Promise<Result<null, string>> {+ try {+ return { status: "ok", data: await TAURI_INVOKE("snooze_shortcut_reminder_for_hour") };+} catch (e) {+ if(e instanceof Error) throw e;+ else return { status: "error", error: e as any };+}+},/*** Start the server (if not running) and capture.* This is the main entry point called by the frontend.@@ -3421,10 +3429,10 @@ captureOnClipboard?: boolean | null;/*** Override `UiRecorderConfig::capture_scroll`.* None = engine default (false). When true, scroll wheel events are- * recorded into `ui_events` so the `ScrollBurstTracker` can fire a- * `ScrollStop` trigger at burst-end and link the last scroll row to- * the resulting frame. Off by default — wheel ticks fire at ~60Hz- * and inflate the table fast.+ * recorded into `ui_events` so the `ScrollBurstTracker` can retain every+ * correlation ID, fire a `ScrollStop` trigger at burst-end, and link every+ * persisted scroll row in the settled burst to the resulting frame. Off by+ * default — wheel ticks fire at ~60Hz and inflate the table fast.*/captureScroll?: boolean | null;/**@@ -3712,14 +3720,17 @@ listenOnLan?: boolean }) &*/shortcutOverlaySize?: string;/**- * The user's choice, honored only while `allow_hiding_shortcut_overlay`- * is on. The overlay ships unhideable, so this is inert by default.+ * The user's persistent choice for the shortcut reminder. Recording-health+ * incidents may still reveal their own temporary recovery surface.*/showShortcutOverlay?: boolean;/**- * Remote-controlled capability (`overlay-hiding-control`), written by the- * desktop remote-control registry. False ships; flipping the flag on gives- * the Display toggle back without a release.+ * Unix timestamp until which the user asked to hide the shortcut reminder.+ */+shortcutOverlaySnoozedUntil?: number | null;+/**+ * Compatibility capability written by the desktop remote-control registry.+ * Consumer visibility is controlled by `show_shortcut_overlay` above.*/allowHidingShortcutOverlay?: boolean;/**diff --git a/apps/screenpipe-app-tauri/src-tauri/src/commands.rs b/apps/screenpipe-app-tauri/src-tauri/src/commands.rsindex 0bcb1d962..7cab0168a 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/commands.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/commands.rs@@ -56,8 +56,8 @@ mod tests {merge_enterprise_file_configs, persist_enterprise_device_config,persist_recovered_enterprise_device_config, read_enterprise_config_from_path,notification_belongs_to_overlay, recovery_anchor_license_key, save_enterprise_team_config,- scan_chat_entries_by_mtime, shortcut_overlay_hidden_by_choice, EnterpriseFileConfig,- RecoveredEnterpriseDeviceConfig,+ scan_chat_entries_by_mtime, shortcut_overlay_hidden_by_choice,+ should_resume_snoozed_overlay, EnterpriseFileConfig, RecoveredEnterpriseDeviceConfig,};/// `get_local_api_config` must never await the server mutex.@@ -113,15 +113,20 @@ mod tests {assert_eq!(config["port"], 3030);}- /// The overlay ships unhideable. A stored `showShortcutOverlay: false` —- /// whether left over from before this shipped or set while the remote- /// capability was on — must stay inert until the flag grants it back.#[test]- fn a_stored_hide_choice_only_counts_once_remote_policy_allows_it() {- assert!(!shortcut_overlay_hidden_by_choice(false, false));- assert!(!shortcut_overlay_hidden_by_choice(false, true));- assert!(shortcut_overlay_hidden_by_choice(true, false));- assert!(!shortcut_overlay_hidden_by_choice(true, true));+ fn saved_choice_and_active_snooze_hide_the_shortcut_overlay() {+ assert!(shortcut_overlay_hidden_by_choice(false, None, 100));+ assert!(shortcut_overlay_hidden_by_choice(true, Some(101), 100));+ assert!(!shortcut_overlay_hidden_by_choice(true, Some(100), 100));+ assert!(!shortcut_overlay_hidden_by_choice(true, None, 100));+ }++ #[test]+ fn only_the_matching_expired_snooze_may_restore_the_overlay() {+ assert!(should_resume_snoozed_overlay(true, Some(100), 100, 100));+ assert!(!should_resume_snoozed_overlay(false, Some(100), 100, 100));+ assert!(!should_resume_snoozed_overlay(true, Some(200), 100, 100));+ assert!(!should_resume_snoozed_overlay(true, Some(100), 100, 99));}#[test]@@ -2886,42 +2891,128 @@ fn shortcut_reminder_payload(map}-/// Whether a stored "keep the overlay hidden" choice may be honored at all.-/// The overlay is the app's only always-on surface — it carries recording-/// health, live meeting state and meeting notifications — so it ships-/// unhideable and a stale stored `false` stays inert. `overlay-hiding-control`-/// (see `lib/desktop-remote-control.ts`) can grant the capability back-/// remotely, at which point the user's own choice starts counting again.+/// Whether the user's persistent choice or temporary snooze hides the normal+/// shortcut reminder. Confirmed recording incidents bypass this predicate and+/// use the same small surface only for recovery.pub(crate) fn shortcut_overlay_hidden_by_choice(- allow_hiding: bool,show_overlay: bool,+ snoozed_until: Option<i64>,+ now_unix: i64,) -> bool {- allow_hiding && !show_overlay+ !show_overlay || snoozed_until.is_some_and(|until| until > now_unix)+}++const SHORTCUT_OVERLAY_HOUR_SNOOZE_SECONDS: i64 = 60 * 60;++fn should_resume_snoozed_overlay(+ show_overlay: bool,+ stored_until: Option<i64>,+ expected_until: i64,+ now_unix: i64,+) -> bool {+ show_overlay && stored_until == Some(expected_until) && expected_until <= now_unix+}++fn schedule_shortcut_overlay_resume(app_handle: tauri::AppHandle, expected_until: i64) {+ tauri::async_runtime::spawn(async move {+ let delay_seconds = expected_until+ .saturating_sub(chrono::Utc::now().timestamp())+ .max(0) as u64;+ tokio::time::sleep(std::time::Duration::from_secs(delay_seconds)).await;++ let Ok(Some(mut store)) = crate::store::SettingsStore::get(&app_handle) else {+ return;+ };+ let now_unix = chrono::Utc::now().timestamp();+ if !should_resume_snoozed_overlay(+ store.show_shortcut_overlay,+ store.shortcut_overlay_snoozed_until,+ expected_until,+ now_unix,+ ) {+ return;+ }++ store.shortcut_overlay_snoozed_until = None;+ if let Err(error) = store.save(&app_handle) {+ warn!("failed to clear expired shortcut overlay snooze: {}", error);+ return;+ }+ if let Err(error) = show_shortcut_reminder_impl(app_handle, true, true).await {+ warn!("failed to restore shortcut overlay after snooze: {}", error);+ }+ });}-/// Suppression is otherwise a system decision (timeline off, headless), never-/// a stored dismissal.+/// Honor the saved preference on every startup. Expired snoozes are cleared so+/// Settings and subsequent launches reflect the actual state.pub(crate) async fn maybe_show_shortcut_reminder_on_startup(app_handle: tauri::AppHandle,) -> Result<(), String> {- let store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();+ let mut store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();+ let now_unix = chrono::Utc::now().timestamp();if shortcut_overlay_hidden_by_choice(- store.allow_hiding_shortcut_overlay,store.show_shortcut_overlay,+ store.shortcut_overlay_snoozed_until,+ now_unix,) {- info!("shortcut overlay stays hidden: remote policy allows it and the user turned it off");+ if store.show_shortcut_overlay {+ if let Some(until) = store.shortcut_overlay_snoozed_until {+ schedule_shortcut_overlay_resume(app_handle, until);+ }+ }+ info!("shortcut overlay stays hidden: saved preference or one-hour snooze");return Ok(());}+ if store+ .shortcut_overlay_snoozed_until+ .is_some_and(|until| until <= now_unix)+ {+ store.shortcut_overlay_snoozed_until = None;+ store.save(&app_handle)?;+ }show_shortcut_reminder_impl(app_handle, true, true).await}+#[tauri::command]+#[specta::specta]+pub async fn snooze_shortcut_reminder_for_hour(+ app_handle: tauri::AppHandle,+) -> Result<(), String> {+ let mut store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();+ let until = chrono::Utc::now()+ .timestamp()+ .saturating_add(SHORTCUT_OVERLAY_HOUR_SNOOZE_SECONDS);+ store.show_shortcut_overlay = true;+ store.shortcut_overlay_snoozed_until = Some(until);+ store.save(&app_handle)?;+ schedule_shortcut_overlay_resume(app_handle.clone(), until);+ hide_shortcut_reminder(app_handle).await+}+#[tauri::command]#[specta::specta]pub async fn show_shortcut_reminder(app_handle: tauri::AppHandle,_shortcut: String,) -> Result<(), String> {+ let mut store = crate::store::SettingsStore::get(&app_handle)?.unwrap_or_default();+ let now_unix = chrono::Utc::now().timestamp();+ if shortcut_overlay_hidden_by_choice(+ store.show_shortcut_overlay,+ store.shortcut_overlay_snoozed_until,+ now_unix,+ ) {+ return Ok(());+ }+ if store+ .shortcut_overlay_snoozed_until+ .is_some_and(|until| until <= now_unix)+ {+ store.shortcut_overlay_snoozed_until = None;+ store.save(&app_handle)?;+ }show_shortcut_reminder_impl(app_handle, true, true).await}diff --git a/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs b/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rsindex 5e3c498a1..7b9240140 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/commands/native_actions.rs@@ -13,6 +13,25 @@ use tracing::{error, info, warn};/// Global app handle stored so native action callbacks can emit events.static GLOBAL_APP_HANDLE: std::sync::OnceLock<tauri::AppHandle> = std::sync::OnceLock::new();+fn handle_shortcut_overlay_hour_snooze(app: &tauri::AppHandle) {+ let app = app.clone();+ native_shortcut_reminder::hide();+ tauri::async_runtime::spawn(async move {+ let persist_succeeded = crate::commands::snooze_shortcut_reminder_for_hour(app.clone())+ .await+ .is_ok();+ track_native_overlay_event(+ &app,+ "shortcut_reminder_dismissed",+ serde_json::json!({+ "dismiss_scope": "hour",+ "snooze_hours": 1,+ "persist_succeeded": persist_succeeded,+ }),+ );+ });+}+// The anchor allowlist and both store writes live in `overlay_anchor`, which is// compiled everywhere: the native panel and the webview overlay have to agree// on what a valid anchor is, and only one of them is macOS-only.@@ -797,6 +816,9 @@ fn native_shortcut_action_callback_inner(action_ptr: *const std::os::raw::c_char}});}+ "dismiss_hour" => {+ handle_shortcut_overlay_hour_snooze(&app_clone);+ }"restart_recording" => {// Recording-health overlay: restart the engine in place.// Same flow as the webview's overlay_restart_recordingdiff --git a/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs b/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rsindex f084d1479..2f07ed6d0 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/overlay_health.rs@@ -591,12 +591,23 @@ async fn reveal_overlay_if_hidden(app: &tauri::AppHandle) {if overlay_visible(app) {return;}- // The overlay can no longer be dismissed, so anything hiding it now is a- // system decision (timeline disabled, headless, or the startup show has not- // landed yet). Leave it up after recovery rather than re-hiding it: if the- // startup show was simply slow, hiding it again would fight that.+ // Take responsibility for re-hiding only when this reveal overrides the+ // user's persistent choice or active one-hour snooze. If startup is merely+ // slow, the normal shortcut pill should stay once recovery finishes.+ let now_unix = chrono::Utc::now().timestamp();+ let user_wants_hidden = crate::store::SettingsStore::get(app)+ .ok()+ .flatten()+ .map(|store| {+ crate::commands::shortcut_overlay_hidden_by_choice(+ store.show_shortcut_overlay,+ store.shortcut_overlay_snoozed_until,+ now_unix,+ )+ })+ .unwrap_or(false);if let Ok(mut inner) = INNER.lock() {- inner.auto_revealed = false;+ inner.auto_revealed = user_wants_hidden;}info!("overlay health: revealing hidden shortcut overlay for incident");// Skip the disable_timeline gate and the wait-for-server handshake — thediff --git a/apps/screenpipe-app-tauri/src-tauri/src/store.rs b/apps/screenpipe-app-tauri/src-tauri/src/store.rsindex 56365b067..1e7152aeb 100644--- a/apps/screenpipe-app-tauri/src-tauri/src/store.rs+++ b/apps/screenpipe-app-tauri/src-tauri/src/store.rs@@ -982,13 +982,15 @@ pub struct SettingsStore {/// Overlay size: "small" (default), "medium" (1.5x), "large" (2x)#[serde(rename = "shortcutOverlaySize", default = "default_overlay_size")]pub shortcut_overlay_size: String,- /// The user's choice, honored only while `allow_hiding_shortcut_overlay`- /// is on. The overlay ships unhideable, so this is inert by default.+ /// The user's persistent choice for the shortcut reminder. Recording-health+ /// incidents may still reveal their own temporary recovery surface.#[serde(rename = "showShortcutOverlay", default = "default_true")]pub show_shortcut_overlay: bool,- /// Remote-controlled capability (`overlay-hiding-control`), written by the- /// desktop remote-control registry. False ships; flipping the flag on gives- /// the Display toggle back without a release.+ /// Unix timestamp until which the user asked to hide the shortcut reminder.+ #[serde(rename = "shortcutOverlaySnoozedUntil", default)]+ pub shortcut_overlay_snoozed_until: Option<i64>,+ /// Compatibility capability written by the desktop remote-control registry.+ /// Consumer visibility is controlled by `show_shortcut_overlay` above.#[serde(rename = "allowHidingShortcutOverlay", default)]pub allow_hiding_shortcut_overlay: bool,/// Where the user dragged the overlay: one of top/bottom x left/center/right.@@ -1594,6 +1596,7 @@ Rules:shortcut_overlay_anchor: default_overlay_anchor(),shortcut_overlay_display: String::new(),show_shortcut_overlay: true,+ shortcut_overlay_snoozed_until: None,allow_hiding_shortcut_overlay: false,device_id: uuid::Uuid::new_v4().to_string(),auto_update: true,@@ -2642,10 +2645,19 @@ mod tests {assert_eq!(missing.shortcut_overlay_anchor, "top-center");}- /// Stored dismissals from before the overlay became permanent must not- /// resurrect: the keys are gone, and an old file carrying them still loads.#[test]- fn retired_overlay_dismissal_keys_are_ignored() {+ fn shortcut_overlay_preferences_survive_old_and_new_stores() {+ let defaults = SettingsStore::default();+ assert!(defaults.show_shortcut_overlay);+ assert_eq!(defaults.shortcut_overlay_snoozed_until, None);++ let missing: SettingsStore = serde_json::from_value(json!({+ "aiPresets": []+ }))+ .unwrap();+ assert!(missing.show_shortcut_overlay);+ assert_eq!(missing.shortcut_overlay_snoozed_until, None);+let legacy: SettingsStore = serde_json::from_value(json!({"aiPresets": [],"showShortcutOverlay": false,@@ -2653,7 +2665,8 @@ mod tests {"shortcutOverlayMinimalReshowVersion": 1,})).unwrap();- assert_eq!(legacy.shortcut_overlay_anchor, "top-center");+ assert!(!legacy.show_shortcut_overlay);+ assert_eq!(legacy.shortcut_overlay_snoozed_until, Some(4_102_444_800));}#[test]diff --git a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swiftindex 0f400d852..3756da306 100644--- a/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift+++ b/apps/screenpipe-app-tauri/src-tauri/swift/shortcut_reminder.swift@@ -1138,7 +1138,7 @@ struct ShortcutReminderView: View {Rectangle().fill(.white.opacity(0.28)).frame(width: 1).padding(.vertical, s(4))DockIconButton(icon: "gearshape", active: metrics.hoveredControl == "settings", scale: scale) {- onAction("open_overlay_settings")+ onAction("show_settings_menu")}}.frame(width: kBaseExpandedW * scale, height: kBaseDockH * scale)@@ -2795,7 +2795,11 @@ class ShortcutReminderController: NSObject, NSWindowDelegate {metrics: metrics,scale: gOverlayScale,onAction: { [weak self] action in- self?.sendAction(action)+ if action == "show_settings_menu" {+ self?.showShortcutSettingsMenu()+ } else {+ self?.sendAction(action)+ }})let contentView = panel.contentView!@@ -3039,6 +3043,49 @@ class ShortcutReminderController: NSObject, NSWindowDelegate {}}+ /// Wispr-style native menu: one temporary escape beside the floating bar,+ /// with the durable choice kept in Settings. Using AppKit's menu avoids a+ /// second floating panel and inherits keyboard, screen-edge and VoiceOver+ /// behavior from macOS.+ private func showShortcutSettingsMenu() {+ guard let contentView = panel?.contentView else { return }+ let menu = NSMenu(title: "shortcut reminder")+ menu.autoenablesItems = false++ let snooze = NSMenuItem(+ title: "Hide for 1 hour",+ action: #selector(hideShortcutReminderForHour),+ keyEquivalent: ""+ )+ snooze.target = self+ snooze.isEnabled = true+ menu.addItem(snooze)+ menu.addItem(.separator())++ let settings = NSMenuItem(+ title: "Settings…",+ action: #selector(openShortcutReminderSettings),+ keyEquivalent: ""+ )+ settings.target = self+ settings.isEnabled = true+ menu.addItem(settings)++ menu.popUp(+ positioning: nil,+ at: NSPoint(x: contentView.bounds.maxX - 4, y: contentView.bounds.minY + 4),+ in: contentView+ )+ }++ @objc private func hideShortcutReminderForHour() {+ sendAction("dismiss_hour")+ }++ @objc private func openShortcutReminderSettings() {+ sendAction("open_overlay_settings")+ }+private func sendAction(_ action: String) {guard let cb = gShortcutCallback else { return }action.withCString { cb($0) }diff --git a/crates/screenpipe-overlay-win/src/actions.rs b/crates/screenpipe-overlay-win/src/actions.rsindex 934bf8f66..0d43385c9 100644--- a/crates/screenpipe-overlay-win/src/actions.rs+++ b/crates/screenpipe-overlay-win/src/actions.rs@@ -16,6 +16,8 @@ use crate::state::{Anchor, Control, OverlayState};pub const NOTIFICATION_ACTION_PREFIX: &str = "notification_action:";pub const ANCHOR_PREFIX: &str = "set_overlay_anchor:";pub const MEETING_NOTE_PREFIX: &str = "open_meeting_note:";+pub const SETTINGS_MENU_HIDE_HOUR: usize = 1;+pub const SETTINGS_MENU_OPEN_SETTINGS: usize = 2;/// The action string for a control, or `None` when the control has nothing to/// report — either because it is a status cell rather than a button, or because@@ -27,7 +29,9 @@ pub fn action_for(state: &OverlayState, control: Control) -> Option<String> {Control::Pill | Control::Timeline => "open_timeline",Control::Search => "open_search",Control::Chat => "open_chat",- Control::Settings => "open_overlay_settings",+ // The native window owns the compact settings menu. Its selected item+ // is translated by `settings_menu_action` below.+ Control::Settings => return None,Control::RestartRecording => "restart_recording",Control::DismissIncident => "dismiss_incident",// The audio meter is a status cell, not a button — same as the mac@@ -63,6 +67,16 @@ pub fn action_for(state: &OverlayState, control: Control) -> Option<String> {Some(fixed.to_string())}+/// Translate the native settings-menu command id into the same app actions+/// used by the macOS panel and web fallback.+pub fn settings_menu_action(command: usize) -> Option<String> {+ match command {+ SETTINGS_MENU_HIDE_HOUR => Some("dismiss_hour".to_string()),+ SETTINGS_MENU_OPEN_SETTINGS => Some("open_overlay_settings".to_string()),+ _ => None,+ }+}+/// Reported after a drag settles. Kebab-case so it lands in `shortcutOverlayAnchor`/// in the shape `overlay-anchor.ts` and the settings store already use.pub fn anchor_action(anchor: Anchor) -> String {@@ -102,16 +116,26 @@ mod tests {assert_eq!(action_for(&s, Control::Chat).unwrap(), "open_chat");assert_eq!(action_for(&s, Control::Timeline).unwrap(), "open_timeline");assert_eq!(action_for(&s, Control::Pill).unwrap(), "open_timeline");- assert_eq!(- action_for(&s, Control::Settings).unwrap(),- "open_overlay_settings"- );+ assert_eq!(action_for(&s, Control::Settings), None);assert_eq!(action_for(&s, Control::RestartRecording).unwrap(),"restart_recording");}+ #[test]+ fn settings_menu_matches_the_other_native_overlay() {+ assert_eq!(+ settings_menu_action(SETTINGS_MENU_HIDE_HOUR).unwrap(),+ "dismiss_hour"+ );+ assert_eq!(+ settings_menu_action(SETTINGS_MENU_OPEN_SETTINGS).unwrap(),+ "open_overlay_settings"+ );+ assert_eq!(settings_menu_action(99), None);+ }+#[test]fn the_first_notification_button_is_the_primary_one() {// Button 0 is drawn rightmost and is the primary — clicking "open note"diff --git a/crates/screenpipe-overlay-win/src/window.rs b/crates/screenpipe-overlay-win/src/window.rsindex 961496774..b5d0bfbac 100644--- a/crates/screenpipe-overlay-win/src/window.rs+++ b/crates/screenpipe-overlay-win/src/window.rs@@ -22,7 +22,7 @@ use std::sync::atomic::{AtomicBool, Ordering};use std::sync::mpsc::{channel, Receiver, Sender};use std::sync::{Arc, Mutex};-use windows::core::Result;+use windows::core::{w, Result};use windows::Win32::Foundation::{COLORREF, HWND, LPARAM, LRESULT, POINT, RECT, SIZE, WPARAM};use windows::Win32::Graphics::Direct2D::Common::{D2D1_COLOR_F, D2D_POINT_2F};use windows::Win32::Graphics::Direct2D::{@@ -43,17 +43,22 @@ use windows::Win32::UI::Input::KeyboardAndMouse::{ReleaseCapture, SetCapture, TrackMouseEvent, TME_LEAVE, TRACKMOUSEEVENT,};use windows::Win32::UI::WindowsAndMessaging::{- CreateWindowExW, DefWindowProcW, DestroyWindow, DispatchMessageW, GetCursorPos, GetMessageW,- GetWindowLongPtrW, GetWindowRect, KillTimer, LoadCursorW, PostMessageW, PostQuitMessage,- RegisterClassExW, SetTimer, SetWindowLongPtrW, SetWindowPos, ShowWindow, TranslateMessage,- UpdateLayeredWindow, CS_HREDRAW, CS_VREDRAW, GWLP_USERDATA, HWND_TOPMOST, IDC_ARROW, MSG,- SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SW_HIDE, SW_SHOWNOACTIVATE, ULW_ALPHA, WINDOWPOS,- WM_APP, WM_DESTROY, WM_DISPLAYCHANGE, WM_DPICHANGED, WM_LBUTTONDOWN, WM_LBUTTONUP,- WM_MOUSEMOVE, WM_SETTINGCHANGE, WM_TIMER, WM_WINDOWPOSCHANGING, WNDCLASSEXW, WS_EX_LAYERED,- WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW, WS_EX_TOPMOST, WS_EX_TRANSPARENT, WS_POPUP,+ AppendMenuW, CreatePopupMenu, CreateWindowExW, DefWindowProcW, DestroyMenu, DestroyWindow,+ DispatchMessageW, GetCursorPos, GetMessageW, GetWindowLongPtrW, GetWindowRect, KillTimer,+ LoadCursorW, PostMessageW, PostQuitMessage, RegisterClassExW, SetTimer, SetWindowLongPtrW,+ SetWindowPos, ShowWindow, TrackPopupMenu, TranslateMessage, UpdateLayeredWindow, CS_HREDRAW,+ CS_VREDRAW, GWLP_USERDATA, HWND_TOPMOST, IDC_ARROW, MF_SEPARATOR, MF_STRING, MSG,+ SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SW_HIDE, SW_SHOWNOACTIVATE, TPM_RETURNCMD,+ TPM_RIGHTALIGN, TPM_TOPALIGN, ULW_ALPHA, WINDOWPOS, WM_APP, WM_DESTROY, WM_DISPLAYCHANGE,+ WM_DPICHANGED, WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MOUSEMOVE, WM_SETTINGCHANGE, WM_TIMER,+ WM_WINDOWPOSCHANGING, WNDCLASSEXW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,+ WS_EX_TOPMOST, WS_EX_TRANSPARENT, WS_POPUP,};-use crate::actions::{action_for, anchor_action};+use crate::actions::{+ action_for, anchor_action, settings_menu_action, SETTINGS_MENU_HIDE_HOUR,+ SETTINGS_MENU_OPEN_SETTINGS,+};use crate::anim::Equalizer;use crate::drag_stage;use crate::layout::{self, Layout, SHADOW_PAD};@@ -82,6 +87,45 @@ const HOVER_POLL_MS: u32 = 90;/// Pointer travel before a press on the pill becomes a drag rather than a click.const DRAG_THRESHOLD: f32 = 4.0;+/// Show the same two-choice native menu as the macOS overlay. Returning the+/// selected app action keeps menu presentation inside the Win32 window while+/// preserving the cross-platform callback contract.+unsafe fn show_settings_menu(hwnd: HWND) -> Option<String> {+ let menu = CreatePopupMenu().ok()?;+ let result = (|| {+ AppendMenuW(+ menu,+ MF_STRING,+ SETTINGS_MENU_HIDE_HOUR,+ w!("Hide for 1 hour"),+ )+ .ok()?;+ AppendMenuW(menu, MF_SEPARATOR, 0, w!("")).ok()?;+ AppendMenuW(+ menu,+ MF_STRING,+ SETTINGS_MENU_OPEN_SETTINGS,+ w!("Settings..."),+ )+ .ok()?;++ let mut point = POINT::default();+ GetCursorPos(&mut point).ok()?;+ let command = TrackPopupMenu(+ menu,+ TPM_RETURNCMD | TPM_RIGHTALIGN | TPM_TOPALIGN,+ point.x,+ point.y,+ 0,+ hwnd,+ None,+ );+ settings_menu_action(command.0 as usize)+ })();+ let _ = DestroyMenu(menu);+ result+}+/// Gap in DIP between the pinned pill and the edge of the work area. Shared/// with the drag stage so a landing target is drawn exactly where the pill it/// stands for will come to rest.@@ -1279,7 +1323,11 @@ extern "system" fn wndproc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: LPARAM)// Only fire when the release lands on the same control// the press did — dragging off a button cancels it.if ctx.layout.hit_test(x, y) == Some(pressed) {- action = action_for(&ctx.state, pressed);+ action = if pressed == Control::Settings {+ show_settings_menu(hwnd)+ } else {+ action_for(&ctx.state, pressed)+ };// Pinning is the overlay's own state, so it is applied// here rather than reported and echoed back.if pressed == Control::TranscriptPin {diff --git a/docs/assets/pr/shortcut-overlay-hide-menu.png b/docs/assets/pr/shortcut-overlay-hide-menu.pngnew file mode 100644index 000000000..a8473601aBinary files /dev/null and b/docs/assets/pr/shortcut-overlay-hide-menu.png differ