The best way to control Claude Code, Codex and more from any computer or phone
fix(desktop): follow live system light/dark changes on Linux (#24193)
Co-authored-by: eboye <624357+eboye@users.noreply.github.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: maria-rcks <maria@kuuro.net>
Vasilj Milošević committed
Oct 30, 2026 at 22:04 UTC
e1d85af8a3fca5001d8bc276fbc2220734f18694
4 files changed
+334
-21
apps/desktop/src/electron/ElectronTheme.test.ts
new
+81
@@ -0,0 +1,81 @@
1
+import { assert, describe, it } from "@effect/vitest";
2
+import * as Effect from "effect/Effect";
3
+import { vi } from "vite-plus/test";
4
+
5
+import type { LinuxColorScheme } from "./LinuxColorScheme.ts";
6
+
7
+const { nativeTheme } = vi.hoisted(() => ({
8
+ nativeTheme: { themeSource: "system" as "system" | "light" | "dark" },
9
+}));
10
+
11
+vi.mock("electron", () => ({ nativeTheme }));
12
+
13
+import * as ElectronTheme from "./ElectronTheme.ts";
14
+
15
+function setup() {
16
+ nativeTheme.themeSource = "system";
17
+ const portal: { report: (scheme: LinuxColorScheme) => void; stopped: boolean } = {
18
+ report: () => undefined,
19
+ stopped: false,
20
+ };
21
+ const watch = (onChange: (scheme: LinuxColorScheme) => void) => {
22
+ portal.report = onChange;
23
+ return {
24
+ stop: () => {
25
+ portal.stopped = true;
26
+ },
27
+ };
28
+ };
29
+ return { portal, watch };
30
+}
31
+
32
+describe("ElectronTheme", () => {
33
+ it.effect("resolves the system appearance from the desktop color scheme as it changes", () =>
34
+ Effect.gen(function* () {
35
+ const { portal, watch } = setup();
36
+ const theme = yield* ElectronTheme.makeWith(watch);
37
+ yield* theme.setSource("system");
38
+
39
+ portal.report("dark");
40
+ assert.equal(nativeTheme.themeSource, "dark");
41
+ portal.report("light");
42
+ assert.equal(nativeTheme.themeSource, "light");
43
+ portal.report(null);
44
+ assert.equal(nativeTheme.themeSource, "system");
45
+ }).pipe(Effect.scoped),
46
+ );
47
+
48
+ it.effect("keeps an explicit appearance over the desktop color scheme", () =>
49
+ Effect.gen(function* () {
50
+ const { portal, watch } = setup();
51
+ const theme = yield* ElectronTheme.makeWith(watch);
52
+ portal.report("dark");
53
+
54
+ yield* theme.setSource("light");
55
+ portal.report("dark");
56
+ assert.equal(nativeTheme.themeSource, "light");
57
+
58
+ yield* theme.setSource("system");
59
+ assert.equal(nativeTheme.themeSource, "dark");
60
+ }).pipe(Effect.scoped),
61
+ );
62
+
63
+ it.effect("stops following the desktop when the layer is released", () =>
64
+ Effect.gen(function* () {
65
+ const { portal, watch } = setup();
66
+ yield* ElectronTheme.makeWith(watch).pipe(Effect.scoped);
67
+ assert.isTrue(portal.stopped);
68
+ }),
69
+ );
70
+
71
+ it.effect("leaves the system appearance to Electron when the portal is unavailable", () =>
72
+ Effect.gen(function* () {
73
+ setup();
74
+ const theme = yield* ElectronTheme.makeWith(() => {
75
+ throw new Error("no session bus");
76
+ });
77
+ yield* theme.setSource("system");
78
+ assert.equal(nativeTheme.themeSource, "system");
79
+ }).pipe(Effect.scoped),
80
+ );
81
+});
apps/desktop/src/electron/ElectronTheme.ts
+62
-21
@@ -1,4 +1,5 @@
1
import { DesktopThemeSchema, type DesktopTheme } from "@t3tools/contracts";
2
+import * as HostProcess from "@t3tools/shared/HostProcess";
3
import * as Context from "effect/Context";
4
import * as Effect from "effect/Effect";
5
import * as Layer from "effect/Layer";
@@ -7,6 +8,8 @@ import * as Scope from "effect/Scope";
8
9
import * as Electron from "electron";
10
11
+import { watchLinuxColorScheme, type LinuxColorScheme } from "./LinuxColorScheme.ts";
12
+
13
export class ElectronThemeSetSourceError extends Schema.TaggedError<ElectronThemeSetSourceError>()(
14
"ElectronThemeSetSourceError",
15
{
@@ -28,30 +31,68 @@ export class ElectronTheme extends Context.Service<
31
}
32
>()("@t3tools/desktop/electron/ElectronTheme") {}
33
31
-/** @public */
32
-export const make = ElectronTheme.of({
33
- shouldUseDarkColors: Effect.sync(() => Electron.nativeTheme.shouldUseDarkColors),
34
- setSource: Effect.fn("ElectronTheme.setSource")(function (theme) {
35
- return Effect.try({
36
- try: () => {
37
- Electron.nativeTheme.themeSource = theme;
38
- },
39
- catch: (cause) => new ElectronThemeSetSourceError({ source: theme, cause }),
40
- });
41
- }),
42
- onUpdated: Effect.fn("ElectronTheme.onUpdated")(function (listener) {
43
- return Effect.acquireRelease(
44
- Effect.suspend(() => {
45
- Electron.nativeTheme.on("updated", listener);
46
- return Effect.void;
34
+type WatchSystemColorScheme = (onChange: (scheme: LinuxColorScheme) => void) => {
35
+ readonly stop: () => void;
36
+};
37
+
38
+export const makeWith = Effect.fn("ElectronTheme.make")(function* (
39
+ watchSystemColorScheme: WatchSystemColorScheme | undefined,
40
+) {
41
+ let source: DesktopTheme = Electron.nativeTheme.themeSource;
42
+ let systemScheme: LinuxColorScheme = null;
43
+ // On Linux, Electron reads the desktop color scheme once and then ignores the settings
44
+ // portal (electron/electron#48736), so "system" is resolved from the portal directly.
45
+ const apply = () => {
46
+ Electron.nativeTheme.themeSource = source === "system" ? (systemScheme ?? source) : source;
47
+ };
48
+
49
+ if (watchSystemColorScheme) {
50
+ yield* Effect.acquireRelease(
51
+ Effect.sync(() => {
52
+ try {
53
+ return watchSystemColorScheme((scheme) => {
54
+ systemScheme = scheme;
55
+ apply();
56
+ });
57
+ } catch {
58
+ return undefined;
59
+ }
60
}),
48
- () =>
61
+ (watcher) => Effect.sync(() => watcher?.stop()),
62
+ );
63
+ }
64
+
65
+ return ElectronTheme.of({
66
+ shouldUseDarkColors: Effect.sync(() => Electron.nativeTheme.shouldUseDarkColors),
67
+ setSource: Effect.fn("ElectronTheme.setSource")(function (theme) {
68
+ return Effect.try({
69
+ try: () => {
70
+ source = theme;
71
+ apply();
72
+ },
73
+ catch: (cause) => new ElectronThemeSetSourceError({ source: theme, cause }),
74
+ });
75
+ }),
76
+ onUpdated: Effect.fn("ElectronTheme.onUpdated")(function (listener) {
77
+ return Effect.acquireRelease(
78
Effect.suspend(() => {
50
- Electron.nativeTheme.removeListener("updated", listener);
79
+ Electron.nativeTheme.on("updated", listener);
80
return Effect.void;
81
}),
53
- );
54
- }),
82
+ () =>
83
+ Effect.suspend(() => {
84
+ Electron.nativeTheme.removeListener("updated", listener);
85
+ return Effect.void;
86
+ }),
87
+ );
88
+ }),
89
+ });
90
+});
91
+
92
+/** @public */
93
+export const make = Effect.gen(function* () {
94
+ const platform = yield* HostProcess.Platform;
95
+ return yield* makeWith(platform === "linux" ? watchLinuxColorScheme : undefined);
96
});
97
57
-export const layer = Layer.succeed(ElectronTheme, make);
98
+export const layer = Layer.effect(ElectronTheme, make);
apps/desktop/src/electron/LinuxColorScheme.test.ts
new
+100
@@ -0,0 +1,100 @@
1
+// @effect-diagnostics nodeBuiltinImport:off -- Event-driven fake of the portal transport.
2
+import * as NodeEvents from "node:events";
3
+import { DBusError, Message, MessageType, Variant, type MessageBus } from "dbus-next";
4
+import { expect, it, vi } from "vite-plus/test";
5
+
6
+import { watchLinuxColorScheme, type LinuxColorScheme } from "./LinuxColorScheme.ts";
7
+
8
+const PATH = "/org/freedesktop/portal/desktop";
9
+const SETTINGS = "org.freedesktop.portal.Settings";
10
+
11
+class FakeBus extends NodeEvents.EventEmitter {
12
+ calls: Message[] = [];
13
+ disconnect = vi.fn();
14
+ readonly settings: { readOne?: unknown; read?: unknown };
15
+ constructor(settings: { readOne?: unknown; read?: unknown }) {
16
+ super();
17
+ this.settings = settings;
18
+ }
19
+
20
+ readonly readOneCalled = Promise.withResolvers<void>();
21
+
22
+ async call(message: Message) {
23
+ this.calls.push(message);
24
+ if (message.member === "AddMatch")
25
+ return new Message({ type: MessageType.METHOD_RETURN, replySerial: "1" });
26
+ if (message.member === "ReadOne") this.readOneCalled.resolve();
27
+ const value = await (message.member === "ReadOne" ? this.settings.readOne : this.settings.read);
28
+ if (value === undefined) throw new DBusError("org.freedesktop.DBus.Error.UnknownMethod", "");
29
+ return new Message({
30
+ type: MessageType.METHOD_RETURN,
31
+ replySerial: "1",
32
+ signature: "v",
33
+ body: [value],
34
+ });
35
+ }
36
+
37
+ changed(namespace: string, key: string, value: number) {
38
+ this.emit(
39
+ "message",
40
+ new Message({
41
+ type: MessageType.SIGNAL,
42
+ path: PATH,
43
+ interface: SETTINGS,
44
+ member: "SettingChanged",
45
+ body: [namespace, key, new Variant("u", value)],
46
+ }),
47
+ );
48
+ }
49
+}
50
+
51
+function watch(bus: FakeBus) {
52
+ const schemes: LinuxColorScheme[] = [];
53
+ const { ready, stop } = watchLinuxColorScheme(
54
+ (scheme) => schemes.push(scheme),
55
+ bus as unknown as MessageBus,
56
+ );
57
+ return { schemes, ready, stop };
58
+}
59
+
60
+it("reads the current color scheme and follows portal changes", async () => {
61
+ const bus = new FakeBus({ readOne: new Variant("u", 1) });
62
+ const { schemes, ready, stop } = watch(bus);
63
+ await ready;
64
+
65
+ bus.changed("org.freedesktop.appearance", "color-scheme", 2);
66
+ bus.changed("org.freedesktop.appearance", "accent-color", 1);
67
+ bus.changed("org.gnome.desktop.interface", "color-scheme", 1);
68
+ bus.changed("org.freedesktop.appearance", "color-scheme", 1);
69
+ // GNOME's light mode reports "no preference".
70
+ bus.changed("org.freedesktop.appearance", "color-scheme", 0);
71
+ bus.changed("org.freedesktop.appearance", "color-scheme", 3);
72
+ expect(schemes).toEqual(["dark", "light", "dark", "light", null]);
73
+
74
+ stop();
75
+ bus.changed("org.freedesktop.appearance", "color-scheme", 1);
76
+ expect(schemes).toEqual(["dark", "light", "dark", "light", null]);
77
+ expect(bus.disconnect).toHaveBeenCalledOnce();
78
+});
79
+
80
+it("falls back to the nested Read reply on portals without ReadOne", async () => {
81
+ const bus = new FakeBus({ read: new Variant("v", new Variant("u", 2)) });
82
+ const { schemes, ready } = watch(bus);
83
+ await ready;
84
+
85
+ expect(schemes).toEqual(["light"]);
86
+ expect(bus.calls.map((call) => call.member)).toEqual(["AddMatch", "ReadOne", "Read"]);
87
+});
88
+
89
+it("keeps a change that arrives while the initial read is pending", async () => {
90
+ const reply = Promise.withResolvers<Variant>();
91
+ const bus = new FakeBus({ readOne: reply.promise });
92
+ const { schemes, ready } = watch(bus);
93
+
94
+ await bus.readOneCalled.promise;
95
+ bus.changed("org.freedesktop.appearance", "color-scheme", 1);
96
+ reply.resolve(new Variant("u", 0));
97
+ await ready;
98
+
99
+ expect(schemes).toEqual(["dark"]);
100
+});
apps/desktop/src/electron/LinuxColorScheme.ts
new
+91
@@ -0,0 +1,91 @@
1
+import { Message, MessageType, Variant, sessionBus, type MessageBus } from "dbus-next";
2
+
3
+const PORTAL = "org.freedesktop.portal.Desktop";
4
+const PATH = "/org/freedesktop/portal/desktop";
5
+const SETTINGS = "org.freedesktop.portal.Settings";
6
+const DBUS = "org.freedesktop.DBus";
7
+const NAMESPACE = "org.freedesktop.appearance";
8
+const KEY = "color-scheme";
9
+
10
+export type LinuxColorScheme = "dark" | "light" | null;
11
+
12
+// The portal reports 1 for prefer-dark, 2 for prefer-light and 0 for no preference. GNOME's
13
+// light mode is 0, and the spec asks apps to use their default then, so only 1 is dark.
14
+// The deprecated Read method nests the value in a second variant.
15
+function decodeColorScheme(value: unknown): LinuxColorScheme {
16
+ let scheme = value;
17
+ while (scheme instanceof Variant) scheme = scheme.value;
18
+ return scheme === 1 ? "dark" : scheme === 0 || scheme === 2 ? "light" : null;
19
+}
20
+
21
+const settingsCall = (member: "ReadOne" | "Read") =>
22
+ new Message({
23
+ destination: PORTAL,
24
+ path: PATH,
25
+ interface: SETTINGS,
26
+ member,
27
+ signature: "ss",
28
+ body: [NAMESPACE, KEY],
29
+ });
30
+
31
+/**
32
+ * Follows the desktop color scheme through the XDG settings portal. Without a session bus or
33
+ * portal it reports nothing, so Chromium's own resolution stays in charge.
34
+ */
35
+export function watchLinuxColorScheme(
36
+ onChange: (scheme: LinuxColorScheme) => void,
37
+ bus: MessageBus = sessionBus(),
38
+) {
39
+ let closed = false;
40
+ let changed = false;
41
+ const report = (value: unknown) => {
42
+ if (!closed) onChange(decodeColorScheme(value));
43
+ };
44
+ const onMessage = (message: Message) => {
45
+ if (
46
+ message.type !== MessageType.SIGNAL ||
47
+ message.path !== PATH ||
48
+ message.interface !== SETTINGS ||
49
+ message.member !== "SettingChanged"
50
+ )
51
+ return;
52
+ const [namespace, key, value] = message.body;
53
+ if (namespace !== NAMESPACE || key !== KEY) return;
54
+ changed = true;
55
+ report(value);
56
+ };
57
+ const ignore = () => undefined;
58
+
59
+ bus.on("error", ignore);
60
+ bus.on("message", onMessage);
61
+ const ready = (async () => {
62
+ await bus.call(
63
+ new Message({
64
+ destination: DBUS,
65
+ path: "/org/freedesktop/DBus",
66
+ interface: DBUS,
67
+ member: "AddMatch",
68
+ signature: "s",
69
+ body: [
70
+ `type='signal',interface='${SETTINGS}',member='SettingChanged',path='${PATH}',arg0='${NAMESPACE}',arg1='${KEY}'`,
71
+ ],
72
+ }),
73
+ );
74
+ // ReadOne needs Settings portal version 2; older portals only offer Read.
75
+ const reply = await bus
76
+ .call(settingsCall("ReadOne"))
77
+ .catch(() => bus.call(settingsCall("Read")));
78
+ // The portal answers reads through its backend asynchronously, so a change signal can
79
+ // overtake this reply; the reply then carries the older value.
80
+ if (reply && !changed) report(reply.body[0]);
81
+ })().catch(ignore);
82
+
83
+ return {
84
+ ready,
85
+ stop: () => {
86
+ closed = true;
87
+ bus.removeListener("message", onMessage);
88
+ bus.disconnect();
89
+ },
90
+ };
91
+}