The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Syncing…
fix(desktop): desktop IPC only answers the main app window (#34094)
Co-authored-by: Claude Fable 5.2 <noreply@anthropic.com>
Julius Marminge committed
Nov 10, 2026 at 15:48 UTC
04f6cfca87203192ccf2c36f7ba8c80baf9ba9da
7 files changed
+133
-14
apps/desktop/src/ipc/DesktopIpc.test.ts
new
+67
@@ -0,0 +1,67 @@
1
+import * as Effect from "effect/Effect";
2
+import * as Layer from "effect/Layer";
3
+import * as Schema from "effect/Schema";
4
+import { assert, it } from "@effect/vitest";
5
+import { vi } from "vite-plus/test";
6
+
7
+vi.mock("electron", () => ({}));
8
+
9
+import * as ElectronWindow from "../electron/ElectronWindow.ts";
10
+import * as DesktopIpc from "./DesktopIpc.ts";
11
+
12
+it.effect("answers only the main window's top frame", () =>
13
+ Effect.gen(function* () {
14
+ const mainFrame = {};
15
+ const invoke = new Map<string, DesktopIpc.DesktopIpcHandleListener>();
16
+ const sync = new Map<string, DesktopIpc.DesktopIpcSyncListener>();
17
+ const ipc = yield* DesktopIpc.DesktopIpc.pipe(
18
+ Effect.provide(
19
+ DesktopIpc.layer({
20
+ removeHandler: (channel) => void invoke.delete(channel),
21
+ handle: (channel, listener) => void invoke.set(channel, listener),
22
+ removeAllListeners: (channel) => void sync.delete(channel),
23
+ on: (channel, listener) => void sync.set(channel, listener),
24
+ }).pipe(
25
+ Layer.provide(
26
+ Layer.mock(ElectronWindow.ElectronWindow, {
27
+ main: Effect.succeedSome({
28
+ webContents: { id: 1, mainFrame },
29
+ } as unknown as Electron.BrowserWindow),
30
+ }),
31
+ ),
32
+ ),
33
+ ),
34
+ );
35
+ yield* ipc.handle(
36
+ DesktopIpc.makeIpcMethod({
37
+ channel: "token",
38
+ payload: Schema.Void,
39
+ result: Schema.String,
40
+ handler: () => Effect.succeed("secret"),
41
+ }),
42
+ );
43
+ yield* ipc.handleSync({ channel: "token-sync", handler: () => Effect.succeed("secret") });
44
+
45
+ const senders = {
46
+ app: { sender: { id: 1 }, senderFrame: mainFrame },
47
+ appSubframe: { sender: { id: 1 }, senderFrame: {} },
48
+ previewGuest: { sender: { id: 2 }, senderFrame: {} },
49
+ };
50
+ const results: Record<string, unknown> = {};
51
+ for (const [name, sender] of Object.entries(senders)) {
52
+ const event = { ...sender, returnValue: "unset" as unknown };
53
+ sync.get("token-sync")!(event);
54
+ results[name] = [
55
+ yield* Effect.promise(() =>
56
+ Promise.resolve(invoke.get("token")!(sender, undefined)).catch(() => "rejected"),
57
+ ),
58
+ event.returnValue,
59
+ ];
60
+ }
61
+ assert.deepEqual(results, {
62
+ app: ["secret", "secret"],
63
+ appSubframe: ["rejected", undefined],
64
+ previewGuest: ["rejected", undefined],
65
+ });
66
+ }).pipe(Effect.scoped),
67
+);
apps/desktop/src/ipc/DesktopIpc.ts
+51
-3
@@ -1,17 +1,23 @@
1
import * as Context from "effect/Context";
2
import * as Effect from "effect/Effect";
3
import * as Layer from "effect/Layer";
4
+import * as Option from "effect/Option";
5
import * as Schema from "effect/Schema";
6
import * as Scope from "effect/Scope";
7
8
+import * as ElectronWindow from "../electron/ElectronWindow.ts";
9
+
10
export interface DesktopIpcInvokeEvent {
11
readonly sender: { readonly id: number };
12
+ readonly senderFrame?: unknown;
13
}
14
11
-export interface DesktopIpcSyncEvent {
15
+export interface DesktopIpcSyncEvent extends DesktopIpcInvokeEvent {
16
returnValue: unknown;
17
}
18
19
+export type DesktopIpcSenderGuard = (event: DesktopIpcInvokeEvent) => Effect.Effect<boolean>;
20
+
21
export type DesktopIpcHandleListener = (
22
event: DesktopIpcInvokeEvent,
23
raw: unknown,
@@ -52,6 +58,15 @@ export class DesktopIpcUnregistrationError extends Schema.TaggedError<DesktopIpc
58
}
59
}
60
61
+export class DesktopIpcUntrustedSenderError extends Schema.TaggedError<DesktopIpcUntrustedSenderError>()(
62
+ "DesktopIpcUntrustedSenderError",
63
+ { channel: Schema.String },
64
+) {
65
+ override get message(): string {
66
+ return `Rejected ${this.channel} from a sender that is not the app window.`;
67
+ }
68
+}
69
+
70
export const DesktopIpcError = Schema.Union([
71
DesktopIpcRegistrationError,
72
DesktopIpcUnregistrationError,
@@ -80,7 +95,11 @@ export class DesktopIpc extends Context.Service<
95
}
96
>()("@t3tools/desktop/ipc/DesktopIpc") {}
97
83
-export const make = (ipcMain: DesktopIpcMain): DesktopIpc["Service"] =>
98
+// ipcMain is shared by every webContents, including preview guests that load arbitrary pages.
99
+export const make = (
100
+ ipcMain: DesktopIpcMain,
101
+ isTrustedSender: DesktopIpcSenderGuard,
102
+): DesktopIpc["Service"] =>
103
DesktopIpc.of({
104
handle: Effect.fn("desktop.ipc.registerInvoke")(function* <E, R>({
105
channel,
@@ -98,6 +117,9 @@ export const make = (ipcMain: DesktopIpcMain): DesktopIpc["Service"] =>
117
runPromise(
118
Effect.gen(function* () {
119
yield* Effect.annotateCurrentSpan({ channel });
120
+ if (!(yield* isTrustedSender(event))) {
121
+ return yield* new DesktopIpcUntrustedSenderError({ channel });
122
+ }
123
return yield* handler(raw, event);
124
}).pipe(Effect.annotateLogs({ channel }), Effect.withSpan("desktop.ipc.invoke")),
125
),
@@ -131,6 +153,11 @@ export const make = (ipcMain: DesktopIpcMain): DesktopIpc["Service"] =>
153
event.returnValue = runSync(
154
Effect.gen(function* () {
155
yield* Effect.annotateCurrentSpan({ channel });
156
+ // Throwing here would surface as an uncaught main-process exception.
157
+ if (!(yield* isTrustedSender(event))) {
158
+ yield* Effect.logWarning("Rejected sync IPC from an untrusted sender.");
159
+ return undefined;
160
+ }
161
return yield* handler();
162
}).pipe(
163
Effect.annotateLogs({ channel }),
@@ -152,7 +179,28 @@ export const make = (ipcMain: DesktopIpcMain): DesktopIpc["Service"] =>
179
}),
180
});
181
155
-export const layer = (ipcMain: DesktopIpcMain) => Layer.succeed(DesktopIpc, make(ipcMain));
182
+export const layer = (ipcMain: DesktopIpcMain) =>
183
+ Layer.effect(
184
+ DesktopIpc,
185
+ Effect.gen(function* () {
186
+ const electronWindow = yield* ElectronWindow.ElectronWindow;
187
+ return make(ipcMain, (event) =>
188
+ Effect.map(
189
+ electronWindow.main,
190
+ (main) =>
191
+ Option.isSome(main) &&
192
+ main.value.webContents.id === event.sender.id &&
193
+ main.value.webContents.mainFrame === event.senderFrame,
194
+ ),
195
+ );
196
+ }),
197
+ );
198
+
199
+export const layerTest = (ipcMain: DesktopIpcMain) =>
200
+ Layer.succeed(
201
+ DesktopIpc,
202
+ make(ipcMain, () => Effect.succeed(true)),
203
+ );
204
205
export interface DesktopIpcMethodRegistration<
206
Payload,
apps/desktop/src/ipc/methods/notificationBadge.test.ts
+1
-1
@@ -80,7 +80,7 @@ it.effect("validates IPC and clears on native focus, quit, and disposal", () =>
80
Effect.provideService(HostProcess.Platform, "linux"),
81
Effect.provide([
82
ElectronApp.layer,
83
- DesktopIpc.layer({
83
+ DesktopIpc.layerTest({
84
handle: (channel, handler) => {
85
handlers.set(channel, handler);
86
},
apps/desktop/src/ipc/methods/preview.test.ts
+10
-7
@@ -42,14 +42,17 @@ describe("preview IPC methods", () => {
42
Effect.scoped(
43
Effect.gen(function* () {
44
let listener: DesktopIpc.DesktopIpcHandleListener | undefined;
45
- const ipc = DesktopIpc.make({
46
- removeHandler: vi.fn(),
47
- handle: (_channel, registered) => {
48
- listener = registered;
45
+ const ipc = DesktopIpc.make(
46
+ {
47
+ removeHandler: vi.fn(),
48
+ handle: (_channel, registered) => {
49
+ listener = registered;
50
+ },
51
+ removeAllListeners: vi.fn(),
52
+ on: vi.fn(),
53
},
50
- removeAllListeners: vi.fn(),
51
- on: vi.fn(),
52
- });
54
+ () => Effect.succeed(true),
55
+ );
56
yield* ipc.handle(method);
57
return yield* Effect.promise(async () =>
58
structuredClone(await listener!({ sender: { id: 7 } }, { tabId: "capture-tab" })),
apps/desktop/src/ipc/methods/window.test.ts
+1
-1
@@ -202,7 +202,7 @@ describe("installRelayTelemetryEnabled", () => {
202
yield* installRelayTelemetryEnabled().pipe(
203
Effect.provideService(HostProcess.Environment, env),
204
Effect.provide(
205
- Layer.mergeAll(DesktopIpc.layer(ipcMain), DesktopManagedPolicy.layerTest(policy)),
205
+ Layer.mergeAll(DesktopIpc.layerTest(ipcMain), DesktopManagedPolicy.layerTest(policy)),
206
),
207
);
208
const event = { returnValue: undefined as unknown };
apps/desktop/src/main.ts
+1
-1
@@ -139,7 +139,7 @@ const layerElectron = Layer.mergeAll(
139
ElectronTheme.layer,
140
ElectronUpdater.layer,
141
ElectronWindow.layer,
142
- DesktopIpc.layer(Electron.ipcMain),
142
+ DesktopIpc.layer(Electron.ipcMain).pipe(Layer.provide(ElectronWindow.layer)),
143
);
144
145
const layerDesktopFoundation = Layer.mergeAll(
apps/desktop/src/window/DesktopWindow.ts
+2
-1
@@ -907,6 +907,8 @@ export const make = Effect.gen(function* () {
907
void runPromise(revealWhenReady);
908
});
909
910
+ // Desktop IPC only answers the main window, so register it before its renderer can call in.
911
+ yield* electronWindow.setMain(window);
912
loadApplication();
913
if (environment.isDevelopment) {
914
window.webContents.openDevTools({ mode: "detach" });
@@ -925,7 +927,6 @@ export const make = Effect.gen(function* () {
927
const createMain = Effect.gen(function* () {
928
const window = yield* createWindow();
929
if (Option.isSome(window)) {
928
- yield* electronWindow.setMain(window.value);
930
mainClosedDuringStartup = false;
931
yield* logWindowInfo("main window created");
932
}