@devries-cameron20 / t3code-1 / commits / 04f6cfca87
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

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 }