Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
feat(desktop): Chrome-style hold-to-quit (#5508)
Bilal Bakrb7dbbbaf6c39
diff --git a/apps/desktop/src/ipc/channels.ts b/apps/desktop/src/ipc/channels.tsindex 0e31082af..ac1ee8792 100644--- a/apps/desktop/src/ipc/channels.ts+++ b/apps/desktop/src/ipc/channels.ts@@ -5,6 +5,7 @@ export const CONTEXT_MENU_CHANNEL = "desktop:context-menu";export const OPEN_EXTERNAL_CHANNEL = "desktop:open-external";export const PROBE_REMOTE_EDITORS_CHANNEL = "desktop:probe-remote-editors";export const MENU_ACTION_CHANNEL = "desktop:menu-action";+export const QUIT_SHORTCUT_CHANNEL = "desktop:quit-shortcut";export const GET_WINDOW_FULLSCREEN_STATE_CHANNEL = "desktop:get-window-fullscreen-state";export const WINDOW_FULLSCREEN_STATE_CHANNEL = "desktop:window-fullscreen-state";export const UPDATE_STATE_CHANNEL = "desktop:update-state";diff --git a/apps/desktop/src/ipc/methods/wsl.test.ts b/apps/desktop/src/ipc/methods/wsl.test.tsindex 3e07ae7f3..38435e286 100644--- a/apps/desktop/src/ipc/methods/wsl.test.ts+++ b/apps/desktop/src/ipc/methods/wsl.test.ts@@ -10,8 +10,11 @@ import * as DesktopLifecycle from "../../app/DesktopLifecycle.ts";import * as DesktopShutdown from "../../app/DesktopShutdown.ts";import * as DesktopState from "../../app/DesktopState.ts";import * as ElectronApp from "../../electron/ElectronApp.ts";+import * as ElectronDialog from "../../electron/ElectronDialog.ts";import * as ElectronTheme from "../../electron/ElectronTheme.ts";+import * as ElectronWindow from "../../electron/ElectronWindow.ts";import * as DesktopAppSettings from "../../settings/DesktopAppSettings.ts";+import * as DesktopClientSettings from "../../settings/DesktopClientSettings.ts";import * as DesktopWindow from "../../window/DesktopWindow.ts";import * as DesktopWslBackend from "../../wsl/DesktopWslBackend.ts";import * as DesktopWslEnvironment from "../../wsl/DesktopWslEnvironment.ts";@@ -70,6 +73,15 @@ const unusedLifecycleRuntimeLayer = Layer.mergeAll(ElectronTheme.ElectronTheme,ElectronTheme.ElectronTheme.of({} as ElectronTheme.ElectronTheme["Service"]),),+ Layer.succeed(+ ElectronDialog.ElectronDialog,+ ElectronDialog.ElectronDialog.of({} as ElectronDialog.ElectronDialog["Service"]),+ ),+ Layer.succeed(+ ElectronWindow.ElectronWindow,+ ElectronWindow.ElectronWindow.of({} as ElectronWindow.ElectronWindow["Service"]),+ ),+ DesktopClientSettings.layerTest(),);describe("WSL IPC", () => {diff --git a/apps/desktop/src/preload.ts b/apps/desktop/src/preload.tsindex 61e345b90..cbbadb708 100644--- a/apps/desktop/src/preload.ts+++ b/apps/desktop/src/preload.ts@@ -117,6 +117,17 @@ contextBridge.exposeInMainWorld("desktopBridge", {ipcRenderer.removeListener(IpcChannels.MENU_ACTION_CHANNEL, wrappedListener);};},+ onQuitShortcut: (listener) => {+ const wrappedListener = (_event: Electron.IpcRendererEvent, state: unknown) => {+ if (state !== "down" && state !== "up") return;+ listener(state);+ };++ ipcRenderer.on(IpcChannels.QUIT_SHORTCUT_CHANNEL, wrappedListener);+ return () => {+ ipcRenderer.removeListener(IpcChannels.QUIT_SHORTCUT_CHANNEL, wrappedListener);+ };+ },getWindowFullscreenState: () =>ipcRenderer.sendSync(IpcChannels.GET_WINDOW_FULLSCREEN_STATE_CHANNEL) === true,onWindowFullscreenStateChange: (listener) => {diff --git a/apps/desktop/src/settings/DesktopClientSettings.test.ts b/apps/desktop/src/settings/DesktopClientSettings.test.tsindex 44c12cc55..23a75eb3f 100644--- a/apps/desktop/src/settings/DesktopClientSettings.test.ts+++ b/apps/desktop/src/settings/DesktopClientSettings.test.ts@@ -13,6 +13,7 @@ import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";import * as DesktopClientSettings from "./DesktopClientSettings.ts";const clientSettings: ClientSettings = {+ confirmQuit: true,confirmThreadArchive: true,confirmThreadDelete: false,dismissedProviderUpdateNotificationKeys: [],diff --git a/apps/desktop/src/window/DesktopWindow.test.ts b/apps/desktop/src/window/DesktopWindow.test.tsindex ed0fbf8b5..42ba818ac 100644--- a/apps/desktop/src/window/DesktopWindow.test.ts+++ b/apps/desktop/src/window/DesktopWindow.test.ts@@ -37,6 +37,8 @@ import * as DesktopConfig from "../app/DesktopConfig.ts";import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";import * as DesktopState from "../app/DesktopState.ts";import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";+import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts";+import * as ElectronApp from "../electron/ElectronApp.ts";import * as ElectronMenu from "../electron/ElectronMenu.ts";import * as ElectronShell from "../electron/ElectronShell.ts";import * as ElectronTheme from "../electron/ElectronTheme.ts";@@ -128,6 +130,14 @@ function makeFakeBrowserWindow() {};}+const desktopClientSettingsLayer = Layer.mock(DesktopClientSettings.DesktopClientSettings)({+ get: Effect.succeed(Option.none()),+});++const electronAppLayer = Layer.mock(ElectronApp.ElectronApp)({+ quit: Effect.void,+});+const desktopAssetsLayer = Layer.succeed(DesktopAssets.DesktopAssets, {iconPaths: Effect.succeed({ico: Option.none<string>(),@@ -253,8 +263,10 @@ function makeTestLayer(input: {desktopAssetsLayer,desktopEnvironmentLayer,desktopAppSettingsLayer,+ desktopClientSettingsLayer,desktopServerExposureLayer,DesktopState.layer,+ electronAppLayer,electronMenuLayer,Layer.succeed(ElectronShell.ElectronShell, {openExternal: (url) =>@@ -356,7 +368,9 @@ const makeSplashScenario = (createOutcomes: readonly (Electron.BrowserWindow | ndesktopAssetsLayer,desktopEnvironmentLayer,DesktopAppSettings.layerTest(),+ desktopClientSettingsLayer,desktopServerExposureLayer,+ electronAppLayer,electronMenuLayer,Layer.succeed(ElectronShell.ElectronShell, {openExternal: () => Effect.succeed(true),diff --git a/apps/desktop/src/window/DesktopWindow.ts b/apps/desktop/src/window/DesktopWindow.tsindex 2ae3d3532..9018b9b92 100644--- a/apps/desktop/src/window/DesktopWindow.ts+++ b/apps/desktop/src/window/DesktopWindow.ts@@ -8,6 +8,8 @@ import * as Ref from "effect/Ref";import * as Electron from "electron";+import { DEFAULT_CLIENT_SETTINGS } from "@t3tools/contracts";+import * as DesktopAssets from "../app/DesktopAssets.ts";import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";import { makeComponentLogger } from "../app/DesktopObservability.ts";@@ -16,9 +18,16 @@ import { getDesktopUrl } from "../electron/ElectronProtocol.ts";import * as ElectronShell from "../electron/ElectronShell.ts";import * as ElectronTheme from "../electron/ElectronTheme.ts";import * as ElectronWindow from "../electron/ElectronWindow.ts";-import { MENU_ACTION_CHANNEL, WINDOW_FULLSCREEN_STATE_CHANNEL } from "../ipc/channels.ts";+import {+ MENU_ACTION_CHANNEL,+ QUIT_SHORTCUT_CHANNEL,+ WINDOW_FULLSCREEN_STATE_CHANNEL,+} from "../ipc/channels.ts";import * as PreviewManager from "../preview/Manager.ts";import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";+import * as DesktopClientSettings from "../settings/DesktopClientSettings.ts";+import * as ElectronApp from "../electron/ElectronApp.ts";+import { makeQuitHoldHandler } from "./QuitHold.ts";const TITLEBAR_HEIGHT = 40;const TITLEBAR_COLOR = "#01000000"; // #00000000 does not work correctly on Linux@@ -51,6 +60,8 @@ type DesktopWindowRuntimeServices =| DesktopEnvironment.DesktopEnvironment| DesktopAssets.DesktopAssets| DesktopAppSettings.DesktopAppSettings+ | DesktopClientSettings.DesktopClientSettings+ | ElectronApp.ElectronApp| ElectronMenu.ElectronMenu| ElectronShell.ElectronShell| ElectronTheme.ElectronTheme@@ -261,6 +272,8 @@ export const make = Effect.gen(function* () {const electronWindow = yield* ElectronWindow.ElectronWindow;const previewManager = yield* PreviewManager.PreviewManager;const desktopSettings = yield* DesktopAppSettings.DesktopAppSettings;+ const clientSettings = yield* DesktopClientSettings.DesktopClientSettings;+ const electronApp = yield* ElectronApp.ElectronApp;// Window-side latch for the primary backend's readiness. Set by// handleBackendReady (driven by the pool's onReady callback), cleared// by handleBackendNotReady (driven by onShutdown). Only consumed by@@ -533,7 +546,32 @@ export const make = Effect.gen(function* () {// close-terminal shortcut can outlive the terminal that handled its first// press, so reject repeats before they reach the native window accelerator.// Deliberate presses still flow through the renderer or native menu.+ // Chrome-style hold-to-quit: intercept the quit accelerator before the+ // native menu sees it and only quit after the shortcut is held. The+ // renderer shows the "Hold to Quit" hint via QUIT_SHORTCUT_CHANNEL.+ const quitHoldHandler = makeQuitHoldHandler({+ platform: environment.platform,+ isEnabled: () =>+ runPromise(+ Effect.map(+ clientSettings.get,+ Option.match({+ onNone: () => DEFAULT_CLIENT_SETTINGS.confirmQuit,+ onSome: (settings) => settings.confirmQuit,+ }),+ ),+ ),+ notify: (state) => {+ if (!window.isDestroyed()) {+ window.webContents.send(QUIT_SHORTCUT_CHANNEL, state);+ }+ },+ quit: () => {+ void runPromise(electronApp.quit);+ },+ });window.webContents.on("before-input-event", (event, input) => {+ quitHoldHandler(event, input);if (input.type !== "keyDown" || !input.isAutoRepeat) return;const modifier = environment.platform === "darwin" ? input.meta : input.control;if (modifier && !input.alt && !input.shift && input.key.toLowerCase() === "w") {diff --git a/apps/desktop/src/window/QuitHold.test.ts b/apps/desktop/src/window/QuitHold.test.tsnew file mode 100644index 000000000..c900a8654--- /dev/null+++ b/apps/desktop/src/window/QuitHold.test.ts@@ -0,0 +1,201 @@+import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";++import {+ makeQuitHoldHandler,+ QUIT_DOUBLE_TAP_MS,+ QUIT_HOLD_DURATION_MS,+ QUIT_HOLD_RELEASE_GRACE_MS,+} from "./QuitHold.ts";+import type { QuitHoldKeyInput, QuitHoldState } from "./QuitHold.ts";++function makeInput(overrides: Partial<QuitHoldKeyInput>): QuitHoldKeyInput {+ return {+ type: "keyDown",+ key: "q",+ meta: true,+ control: false,+ alt: false,+ shift: false,+ isAutoRepeat: false,+ ...overrides,+ };+}++function makeHarness(options?: {+ enabled?: boolean;+ platform?: NodeJS.Platform;+ isEnabled?: () => Promise<boolean>;+}) {+ const notifications: Array<QuitHoldState> = [];+ const quit = vi.fn();+ const handler = makeQuitHoldHandler({+ platform: options?.platform ?? "darwin",+ isEnabled: options?.isEnabled ?? (() => Promise.resolve(options?.enabled ?? true)),+ notify: (state) => notifications.push(state),+ quit,+ });+ const preventDefault = vi.fn();+ const send = async (input: QuitHoldKeyInput) => {+ handler({ preventDefault }, input);+ // Let the isEnabled promise settle.+ await Promise.resolve();+ await Promise.resolve();+ };+ // Simulates the OS auto-repeating the held shortcut every `intervalMs`.+ const holdFor = async (+ durationMs: number,+ repeatOverrides: Partial<QuitHoldKeyInput> = {},+ intervalMs = 100,+ ) => {+ for (let elapsed = 0; elapsed < durationMs; elapsed += intervalMs) {+ vi.advanceTimersByTime(intervalMs);+ await send(makeInput({ isAutoRepeat: true, ...repeatOverrides }));+ }+ };+ return { notifications, quit, preventDefault, send, holdFor };+}++describe("makeQuitHoldHandler", () => {+ beforeEach(() => {+ vi.useFakeTimers();+ });+ afterEach(() => {+ vi.useRealTimers();+ });++ it("shows the hint on a tap without quitting, even when the release is never seen", async () => {+ // macOS suppresses the letter's keyUp while Cmd is held, so a tap may+ // produce no keyUp at all. Quit must still not fire.+ const harness = makeHarness();+ await harness.send(makeInput({}));+ expect(harness.preventDefault).toHaveBeenCalledTimes(1);+ expect(harness.notifications).toEqual(["down"]);++ vi.advanceTimersByTime(QUIT_HOLD_DURATION_MS + QUIT_HOLD_RELEASE_GRACE_MS);+ expect(harness.quit).not.toHaveBeenCalled();+ // The watchdog dismisses the hint once the press is clearly over.+ expect(harness.notifications).toEqual(["down", "up"]);+ });++ it("quits once the shortcut auto-repeats past the hold duration", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ await harness.holdFor(QUIT_HOLD_DURATION_MS - 200);+ expect(harness.quit).not.toHaveBeenCalled();+ await harness.holdFor(400);+ expect(harness.quit).toHaveBeenCalledTimes(1);+ // Exactly one hint cycle for the whole hold.+ expect(harness.notifications).toEqual(["down", "up"]);+ });++ it("does not quit when the hold stops before the duration", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ await harness.holdFor(500);+ await harness.send(makeInput({ type: "keyUp" }));+ expect(harness.notifications).toEqual(["down", "up"]);+ vi.advanceTimersByTime((QUIT_HOLD_DURATION_MS + QUIT_HOLD_RELEASE_GRACE_MS) * 2);+ expect(harness.quit).not.toHaveBeenCalled();+ });++ it("cancels the hold when the modifier is released first", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ await harness.send(makeInput({ type: "keyUp", key: "Meta", meta: false }));+ expect(harness.notifications).toEqual(["down", "up"]);+ vi.advanceTimersByTime((QUIT_HOLD_DURATION_MS + QUIT_HOLD_RELEASE_GRACE_MS) * 2);+ expect(harness.quit).not.toHaveBeenCalled();+ });++ it("quits immediately on a single press when disabled", async () => {+ const harness = makeHarness({ enabled: false });+ await harness.send(makeInput({}));+ expect(harness.quit).toHaveBeenCalledTimes(1);+ // The hint is dismissed in case the quit gets cancelled downstream.+ expect(harness.notifications).toEqual(["down", "up"]);+ });++ it("discards a stale isEnabled resolution from a superseded press", async () => {+ // Press #1's isEnabled is still pending when the user releases and+ // presses again; its late resolution must not act for press #2.+ const resolvers: Array<(enabled: boolean) => void> = [];+ const harness = makeHarness({+ isEnabled: () => new Promise((resolve) => resolvers.push(resolve)),+ });+ await harness.send(makeInput({}));+ await harness.send(makeInput({ type: "keyUp" }));+ // Outside the double-tap window, so the second press starts a new hold.+ vi.advanceTimersByTime(QUIT_DOUBLE_TAP_MS + 100);+ await harness.send(makeInput({}));+ expect(resolvers).toHaveLength(2);++ // Press #1 resolves late with "disabled" — it must not quit press #2.+ resolvers[0]?.(false);+ await Promise.resolve();+ await Promise.resolve();+ expect(harness.quit).not.toHaveBeenCalled();++ // Press #2 resolves enabled and completes a full hold.+ resolvers[1]?.(true);+ await harness.holdFor(QUIT_HOLD_DURATION_MS + 200);+ expect(harness.quit).toHaveBeenCalledTimes(1);+ });++ it("quits on a quick double tap, even when the first release was never seen", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ vi.advanceTimersByTime(QUIT_DOUBLE_TAP_MS - 100);+ await harness.send(makeInput({}));+ expect(harness.quit).toHaveBeenCalledTimes(1);+ });++ it("treats two slow taps as separate presses", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ await harness.send(makeInput({ type: "keyUp" }));+ vi.advanceTimersByTime(QUIT_DOUBLE_TAP_MS + 100);+ await harness.send(makeInput({}));+ expect(harness.quit).not.toHaveBeenCalled();+ expect(harness.notifications).toEqual(["down", "up", "down"]);+ });++ it("cancels the hold when another key interrupts it", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ await harness.holdFor(500);+ // Shift pressed mid-hold breaks the gesture...+ await harness.send(makeInput({ shift: true }));+ expect(harness.notifications).toEqual(["down", "up"]);+ // ...so later repeats past the threshold must not quit.+ await harness.holdFor(QUIT_HOLD_DURATION_MS);+ expect(harness.quit).not.toHaveBeenCalled();+ });++ it("does not count an interrupted press toward a double tap", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({}));+ await harness.send(makeInput({ shift: true }));+ // A fresh press right after the interruption starts a new hold, not a+ // double-tap quit.+ await harness.send(makeInput({}));+ expect(harness.quit).not.toHaveBeenCalled();+ expect(harness.notifications).toEqual(["down", "up", "down"]);+ });++ it("ignores other shortcuts", async () => {+ const harness = makeHarness();+ await harness.send(makeInput({ key: "w" }));+ await harness.send(makeInput({ shift: true }));+ await harness.send(makeInput({ meta: false }));+ expect(harness.preventDefault).not.toHaveBeenCalled();+ expect(harness.notifications).toEqual([]);+ });++ it("uses control on non-mac platforms", async () => {+ const harness = makeHarness({ platform: "linux" });+ await harness.send(makeInput({ meta: false, control: true }));+ expect(harness.preventDefault).toHaveBeenCalledTimes(1);+ await harness.holdFor(QUIT_HOLD_DURATION_MS + 200, { meta: false, control: true });+ expect(harness.quit).toHaveBeenCalledTimes(1);+ });+});diff --git a/apps/desktop/src/window/QuitHold.ts b/apps/desktop/src/window/QuitHold.tsnew file mode 100644index 000000000..ea2fc7854--- /dev/null+++ b/apps/desktop/src/window/QuitHold.ts@@ -0,0 +1,148 @@+// @effect-diagnostics globalDate:off globalTimers:off -- Synchronous before-input-event handler; key events must be timed and the watchdog scheduled outside any Effect runtime.++// Chrome-style hold-to-quit. The quit accelerator is intercepted in+// before-input-event (which runs before the native menu accelerator), and the+// app only quits once the shortcut has been held for QUIT_HOLD_DURATION_MS.+// A quick tap just shows the renderer's "Hold to Quit" hint, and a second tap+// within QUIT_DOUBLE_TAP_MS quits immediately. Quitting from the application+// menu itself is untouched and quits immediately.+export const QUIT_HOLD_DURATION_MS = 1200;+// A second quick tap of the shortcut is the user insisting: quit immediately.+export const QUIT_DOUBLE_TAP_MS = 500;+// "Still held" is proven by auto-repeat keydowns, not by the absence of a+// release: macOS suppresses a letter's keyUp while the command key is down, so+// a tap's release can go completely unseen and a release-based timer would+// quit anyway. The press is treated as released once no key event has arrived+// for QUIT_HOLD_RELEASE_GRACE_MS past the hold duration. Keyboards with+// auto-repeat disabled cannot hold-to-quit and fall back to the menu's Quit.+export const QUIT_HOLD_RELEASE_GRACE_MS = 600;++export type QuitHoldState = "down" | "up";++export interface QuitHoldKeyInput {+ readonly type: string;+ readonly key: string;+ readonly meta: boolean;+ readonly control: boolean;+ readonly alt: boolean;+ readonly shift: boolean;+ readonly isAutoRepeat: boolean;+}++export interface QuitHoldOptions {+ readonly platform: NodeJS.Platform;+ readonly isEnabled: () => Promise<boolean>;+ readonly notify: (state: QuitHoldState) => void;+ readonly quit: () => void;+}++export function makeQuitHoldHandler(+ options: QuitHoldOptions,+): (event: { preventDefault: () => void }, input: QuitHoldKeyInput) => void {+ const modifierKey = options.platform === "darwin" ? "meta" : "control";+ let watchdog: NodeJS.Timeout | undefined;+ let holding = false;+ // Set once isEnabled resolves true; auto-repeats may only quit when armed.+ let armed = false;+ let heldSince = 0;+ let lastPressAt = 0;+ // Incremented on every new press and every release/quit so a pending+ // isEnabled() resolution from a superseded press cannot arm (or quit for)+ // the current one.+ let generation = 0;++ const clearWatchdog = () => {+ if (watchdog !== undefined) {+ clearTimeout(watchdog);+ watchdog = undefined;+ }+ };++ const release = () => {+ if (!holding) return;+ generation += 1;+ holding = false;+ armed = false;+ clearWatchdog();+ options.notify("up");+ };++ // Dismisses the overlay first: if the quit is cancelled downstream the+ // renderer must not be left with a stuck "Hold to Quit" hint.+ const quitNow = () => {+ release();+ options.quit();+ };++ return (event, input) => {+ const key = input.key.toLowerCase();+ if (input.type === "keyUp") {+ if (key === "q" || key === modifierKey) release();+ return;+ }+ if (input.type !== "keyDown") return;++ const modifierDown = options.platform === "darwin" ? input.meta : input.control;+ if (!modifierDown || input.alt || input.shift || key !== "q") {+ // Any other key (or an extra modifier) pressed mid-hold breaks the+ // gesture; without this the hold timer keeps running through the+ // interruption and the next qualifying repeat would quit early. The+ // interrupted press also stops counting toward a double tap — but only+ // here, not in release(), which runs mid-restart on an unseen-release+ // re-press and must not wipe that press's own tap timestamp.+ if (holding && !input.isAutoRepeat) {+ lastPressAt = 0;+ release();+ }+ return;+ }++ event.preventDefault();++ if (input.isAutoRepeat) {+ if (armed && Date.now() - heldSince >= QUIT_HOLD_DURATION_MS) {+ quitNow();+ }+ return;+ }++ const now = Date.now();+ const previousPressAt = lastPressAt;+ lastPressAt = now;+ // A fresh keydown while "holding" means the key came back down after a+ // release macOS never delivered — so both branches below see real taps.+ if (previousPressAt !== 0 && now - previousPressAt <= QUIT_DOUBLE_TAP_MS) {+ quitNow();+ return;+ }+ if (holding) release();++ generation += 1;+ const pressGeneration = generation;+ holding = true;+ heldSince = now;+ options.notify("down");+ void options.isEnabled().then(+ (enabled) => {+ if (generation !== pressGeneration) return;+ if (!enabled) {+ // Hold-to-quit disabled: a single press quits immediately.+ quitNow();+ return;+ }+ armed = true;+ // No auto-repeat by then means the key was released (possibly with a+ // suppressed keyUp) or repeat is disabled; either way, don't quit.+ watchdog = setTimeout(() => {+ watchdog = undefined;+ release();+ }, QUIT_HOLD_DURATION_MS + QUIT_HOLD_RELEASE_GRACE_MS);+ },+ // A failed settings read must never strand the quit request.+ () => {+ if (generation !== pressGeneration) return;+ quitNow();+ },+ );+ };+}diff --git a/apps/web/src/AppRoot.test.tsx b/apps/web/src/AppRoot.test.tsxindex d6d743476..791004b74 100644--- a/apps/web/src/AppRoot.test.tsx+++ b/apps/web/src/AppRoot.test.tsx@@ -4,6 +4,7 @@ import { describe, expect, it } from "vite-plus/test";import { ElectronBrowserHost } from "./browser/ElectronBrowserHost";import { PreviewAutomationHosts } from "./components/preview/PreviewAutomationHosts";+import { QuitHoldOverlay } from "./components/QuitHoldOverlay";import { AppAtomRegistryProvider } from "./rpc/atomRegistry";import type { AppRouter } from "./router";import { AppRoot } from "./AppRoot";@@ -16,9 +17,10 @@ describe("AppRoot", () => {const children = Children.toArray((root as ReactElement<{ readonly children: ReactNode }>).props.children,);- expect(children).toHaveLength(3);+ expect(children).toHaveLength(4);expect(isValidElement(children[0]) && children[0].type).toBe(RouterProvider);expect(isValidElement(children[1]) && children[1].type).toBe(PreviewAutomationHosts);expect(isValidElement(children[2]) && children[2].type).toBe(ElectronBrowserHost);+ expect(isValidElement(children[3]) && children[3].type).toBe(QuitHoldOverlay);});});diff --git a/apps/web/src/AppRoot.tsx b/apps/web/src/AppRoot.tsxindex b1fd21f84..857125c9f 100644--- a/apps/web/src/AppRoot.tsx+++ b/apps/web/src/AppRoot.tsx@@ -2,6 +2,7 @@ import { RouterProvider } from "@tanstack/react-router";import { ElectronBrowserHost } from "./browser/ElectronBrowserHost";import { PreviewAutomationHosts } from "./components/preview/PreviewAutomationHosts";+import { QuitHoldOverlay } from "./components/QuitHoldOverlay";import { AppAtomRegistryProvider } from "./rpc/atomRegistry";import type { AppRouter } from "./router";@@ -16,6 +17,7 @@ export function AppRoot({ router }: { readonly router: AppRouter }) {<RouterProvider router={router} /><PreviewAutomationHosts /><ElectronBrowserHost />+ <QuitHoldOverlay /></AppAtomRegistryProvider>);}diff --git a/apps/web/src/components/QuitHoldOverlay.tsx b/apps/web/src/components/QuitHoldOverlay.tsxnew file mode 100644index 000000000..29c044015--- /dev/null+++ b/apps/web/src/components/QuitHoldOverlay.tsx@@ -0,0 +1,47 @@+import { useEffect, useState } from "react";++import { isMacPlatform } from "../lib/utils";++// Matches the hold duration in apps/desktop/src/window/QuitHold.ts: the hint+// from a quick tap lingers for as long as a full hold would have taken.+const HIDE_AFTER_RELEASE_MS = 1200;++/**+ * Chrome-style "Hold ⌘Q to Quit" hint. The desktop main process intercepts+ * the quit accelerator and pushes press/release states; a quick tap shows+ * this pill while a full hold quits the app.+ */+export function QuitHoldOverlay() {+ const [visible, setVisible] = useState(false);++ useEffect(() => {+ const subscribe = window.desktopBridge?.onQuitShortcut;+ if (!subscribe) return;+ let hideTimer: number | undefined;+ const unsubscribe = subscribe((state) => {+ window.clearTimeout(hideTimer);+ if (state === "down") {+ setVisible(true);+ return;+ }+ hideTimer = window.setTimeout(() => setVisible(false), HIDE_AFTER_RELEASE_MS);+ });+ return () => {+ window.clearTimeout(hideTimer);+ unsubscribe();+ };+ }, []);++ if (!visible) return null;+ const shortcut = isMacPlatform(navigator.platform) ? "⌘Q" : "Ctrl+Q";+ return (+ <div+ role="status"+ className="pointer-events-none fixed inset-x-0 top-[22%] z-100 flex justify-center"+ >+ <div className="rounded-full bg-neutral-700/95 px-8 py-4 text-2xl font-bold text-white shadow-xl">+ Hold {shortcut} to Quit+ </div>+ </div>+ );+}diff --git a/apps/web/src/components/settings/SettingsPanels.tsx b/apps/web/src/components/settings/SettingsPanels.tsxindex 9df7f88ab..d57a4da1c 100644--- a/apps/web/src/components/settings/SettingsPanels.tsx+++ b/apps/web/src/components/settings/SettingsPanels.tsx@@ -526,11 +526,15 @@ export function useSettingsRestore(onRestored?: () => void) {...(settings.confirmThreadDelete !== DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete? ["Delete confirmation"]: []),+ ...(settings.confirmQuit !== DEFAULT_UNIFIED_SETTINGS.confirmQuit+ ? ["Quit confirmation"]+ : []),...(isTextGenerationModelDirty ? ["Text generation model"] : []),],[isTextGenerationModelDirty,isBackgroundActivityDirty,+ settings.confirmQuit,settings.confirmThreadArchive,settings.confirmThreadDelete,settings.addProjectBaseDirectory,@@ -644,6 +648,7 @@ export function useSettingsRestore(onRestored?: () => void) {addProjectBaseDirectory: DEFAULT_UNIFIED_SETTINGS.addProjectBaseDirectory,confirmThreadArchive: DEFAULT_UNIFIED_SETTINGS.confirmThreadArchive,confirmThreadDelete: DEFAULT_UNIFIED_SETTINGS.confirmThreadDelete,+ confirmQuit: DEFAULT_UNIFIED_SETTINGS.confirmQuit,textGenerationModelSelection: DEFAULT_UNIFIED_SETTINGS.textGenerationModelSelection,fontFamilySans: DEFAULT_UNIFIED_SETTINGS.fontFamilySans,fontFamilyComposer: DEFAULT_UNIFIED_SETTINGS.fontFamilyComposer,@@ -2234,6 +2239,30 @@ export function GeneralSettingsPanel() {}/>+ {isElectron ? (+ <SettingsRow+ {...searchableSetting("quit-confirmation")}+ description="Require holding the quit shortcut before the desktop app quits. A quick tap shows a hint instead."+ resetAction={+ settings.confirmQuit !== DEFAULT_UNIFIED_SETTINGS.confirmQuit ? (+ <SettingResetButton+ label="quit confirmation"+ onClick={() =>+ updateSettings({ confirmQuit: DEFAULT_UNIFIED_SETTINGS.confirmQuit })+ }+ />+ ) : null+ }+ control={+ <Switch+ checked={settings.confirmQuit}+ onCheckedChange={(checked) => updateSettings({ confirmQuit: Boolean(checked) })}+ aria-label="Hold to quit"+ />+ }+ />+ ) : null}+<SettingsRow{...searchableSetting("text-generation-model")}description="Default model for generated text like thread titles and source control content. Source control settings can override it with a dedicated source control writer model."diff --git a/apps/web/src/components/settings/settingsSearch.test.ts b/apps/web/src/components/settings/settingsSearch.test.tsindex a5851b2c7..09fd7a9a6 100644--- a/apps/web/src/components/settings/settingsSearch.test.ts+++ b/apps/web/src/components/settings/settingsSearch.test.ts@@ -60,6 +60,11 @@ describe("searchSettings", () => {expect(searchSettings(" ", ITEMS)).toEqual([]);});+ it("hides desktop-only settings from browser search", () => {+ expect(SETTINGS_SEARCH_ITEMS.some((item) => item.id === "quit-confirmation")).toBe(true);+ expect(searchSettings("quit confirmation")).toEqual([]);+ });+it("keeps catalog result ids unique", () => {const ids = SETTINGS_SEARCH_ITEMS.map((item) => item.id);expect(new Set(ids).size).toBe(ids.length);diff --git a/apps/web/src/components/settings/settingsSearch.ts b/apps/web/src/components/settings/settingsSearch.tsindex e0fc3d2f0..e3aef6705 100644--- a/apps/web/src/components/settings/settingsSearch.ts+++ b/apps/web/src/components/settings/settingsSearch.ts@@ -1,3 +1,5 @@+import { isElectron } from "~/env";+export type SettingsPath =| "/settings/general"| "/settings/appearance"@@ -12,6 +14,9 @@ export interface SettingsSearchItem {readonly title: string;readonly to: SettingsPath;readonly targetId?: string;+ // Its row only renders in the desktop app, so a browser result would land on+ // an anchor that isn't there.+ readonly desktopOnly?: boolean;}/**@@ -149,6 +154,12 @@ export const SETTINGS_SEARCH_ITEMS = [title: "Delete confirmation",to: "/settings/general",},+ {+ id: "quit-confirmation",+ title: "Hold to quit",+ to: "/settings/general",+ desktopOnly: true,+ },{id: "text-generation-model",title: "Text generation model",@@ -236,5 +247,9 @@ export function searchSettings(const normalizedQuery = normalizeSearchText(query);if (normalizedQuery.length === 0) return [];- return items.filter((item) => normalizeSearchText(item.title).includes(normalizedQuery));+ return items.filter(+ (item) =>+ (isElectron || item.desktopOnly !== true) &&+ normalizeSearchText(item.title).includes(normalizedQuery),+ );}diff --git a/packages/contracts/src/ipc.ts b/packages/contracts/src/ipc.tsindex 09d7d7a46..3341c0bb0 100644--- a/packages/contracts/src/ipc.ts+++ b/packages/contracts/src/ipc.ts@@ -1080,6 +1080,12 @@ export interface DesktopBridge {*/probeRemoteEditors?: () => Promise<readonly EditorId[]>;onMenuAction: (listener: (action: string) => void) => () => void;+ /**+ * Hold-to-quit hint pushes: "down" when the quit shortcut is first pressed,+ * "up" when it is released before the hold completes. Optional: older+ * desktop builds never emit it.+ */+ onQuitShortcut?: (listener: (state: "down" | "up") => void) => () => void;getWindowFullscreenState: () => boolean;onWindowFullscreenStateChange: (listener: (fullscreen: boolean) => void) => () => void;getUpdateState: () => Promise<DesktopUpdateState>;diff --git a/packages/contracts/src/settings.ts b/packages/contracts/src/settings.tsindex ee1970639..22ce210ed 100644--- a/packages/contracts/src/settings.ts+++ b/packages/contracts/src/settings.ts@@ -112,6 +112,9 @@ export const FontFamilyPreference = Schema.String.check(Schema.isMaxLength(200))export type FontFamilyPreference = typeof FontFamilyPreference.Type;export const ClientSettingsSchema = Schema.Struct({+ // Desktop-only: require holding the quit shortcut (Cmd/Ctrl+Q) before the+ // app quits; a quick tap only shows a hint. Browser clients ignore it.+ confirmQuit: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),confirmThreadArchive: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(false))),confirmThreadDelete: Schema.Boolean.pipe(Schema.withDecodingDefault(Effect.succeed(true))),dismissedProviderUpdateNotificationKeys: Schema.Array(TrimmedNonEmptyString).pipe(@@ -756,6 +759,7 @@ export const ServerSettingsPatch = Schema.Struct({export type ServerSettingsPatch = typeof ServerSettingsPatch.Type;export const ClientSettingsPatch = Schema.Struct({+ confirmQuit: Schema.optionalKey(Schema.Boolean),confirmThreadArchive: Schema.optionalKey(Schema.Boolean),confirmThreadDelete: Schema.optionalKey(Schema.Boolean),diffIgnoreWhitespace: Schema.optionalKey(Schema.Boolean),