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

main
ts 573 lines 26.7 KB
Raw
1 import type {
2 DesktopBridge,
3 DesktopPreviewAnnotationVoiceEvent,
4 DesktopPreviewFindResultEvent,
5 DesktopPreviewOpenLinkEvent,
6 DesktopPreviewPointerEvent,
7 DesktopPreviewRecordingInputEvent,
8 DesktopPreviewTabState,
9 DesktopSnapShotEvent,
10 } from "@t3tools/contracts";
11 import { exposeClerkBridge } from "@clerk/electron/preload";
12 import { contextBridge, ipcRenderer, webFrame, webUtils } from "electron";
13
14 import * as IpcChannels from "./ipc/channels.ts";
15 import { mergeLegacyLocalStorage } from "./legacyLocalStorageMerge.ts";
16
17 const SNAP_SHOT_EVENT_TYPES = new Set([
18 "requested",
19 "started",
20 "ready",
21 "failed",
22 "shortcut-changed",
23 ]);
24 function isSnapShotEvent(value: unknown): value is DesktopSnapShotEvent {
25 if (typeof value !== "object" || value === null) return false;
26 const { type, id } = value as { type?: unknown; id?: unknown };
27 return (
28 typeof type === "string" &&
29 SNAP_SHOT_EVENT_TYPES.has(type) &&
30 (id === undefined || typeof id === "string")
31 );
32 }
33
34 exposeClerkBridge({ passkeys: true });
35
36 // Runs before any app script reads localStorage. See DesktopLegacyLocalStorage.
37 try {
38 const legacyItems: unknown = ipcRenderer.sendSync(IpcChannels.TAKE_LEGACY_LOCAL_STORAGE_CHANNEL);
39 if (typeof legacyItems === "object" && legacyItems !== null) {
40 if (mergeLegacyLocalStorage(window.localStorage, legacyItems as Record<string, string>)) {
41 void ipcRenderer.invoke(IpcChannels.COMPLETE_LEGACY_LOCAL_STORAGE_CHANNEL);
42 }
43 }
44 } catch {}
45
46 // oxlint-disable-next-line t3code/no-global-process-runtime -- Electron exposes the client platform in its sandboxed preload process.
47 const clientPlatform = process.platform;
48
49 if (clientPlatform === "darwin") {
50 // Native buttons ignore Chromium zoom; reserve native points even after reload.
51 const syncWindowControlInset = () => {
52 document.documentElement.style.setProperty(
53 "--desktop-window-controls-inset",
54 `${90 / webFrame.getZoomFactor()}px`,
55 );
56 };
57 window.addEventListener("DOMContentLoaded", syncWindowControlInset, { once: true });
58 window.addEventListener("resize", syncWindowControlInset);
59 }
60
61 const syncHtmlFullscreen = () => {
62 const element = document.fullscreenElement;
63 // A preview guest's fullscreen surfaces here as its <webview>, which stays inside the window.
64 void ipcRenderer.invoke(
65 IpcChannels.SYNC_HTML_FULLSCREEN_CHANNEL,
66 element !== null && element.tagName !== "WEBVIEW",
67 );
68 };
69 // A reload or renderer crash never reports the old document's exit, so each document reports its start.
70 syncHtmlFullscreen();
71 document.addEventListener("fullscreenchange", syncHtmlFullscreen);
72
73 let primaryPasteEnabled = true;
74 try {
75 primaryPasteEnabled =
76 ipcRenderer.sendSync(IpcChannels.GET_PRIMARY_PASTE_ENABLED_CHANNEL) !== false;
77 } catch {}
78
79 if (!primaryPasteEnabled) {
80 // Blink pastes the PRIMARY selection on a middle-click mouseup unless it is default-prevented.
81 window.addEventListener(
82 "mouseup",
83 (event) => {
84 if (event.button === 1) event.preventDefault();
85 },
86 true,
87 );
88 }
89
90 function unwrapEnsureSshEnvironmentResult(result: unknown) {
91 if (
92 typeof result === "object" &&
93 result !== null &&
94 "type" in result &&
95 result.type === IpcChannels.SSH_PASSWORD_PROMPT_CANCELLED_RESULT
96 ) {
97 const message =
98 "message" in result && typeof result.message === "string"
99 ? result.message
100 : "SSH authentication cancelled.";
101 throw new Error(message);
102 }
103 return result as Awaited<ReturnType<DesktopBridge["ensureSshEnvironment"]>>;
104 }
105
106 contextBridge.exposeInMainWorld("desktopBridge", {
107 getAppBranding: () => {
108 const result = ipcRenderer.sendSync(IpcChannels.GET_APP_BRANDING_CHANNEL);
109 if (typeof result !== "object" || result === null) {
110 return null;
111 }
112 return result as ReturnType<DesktopBridge["getAppBranding"]>;
113 },
114 getRelayTelemetryEnabled: () => {
115 const enabled = ipcRenderer.sendSync(IpcChannels.GET_RELAY_TELEMETRY_ENABLED_CHANNEL);
116 return enabled === null ? null : enabled === true;
117 },
118 getPathForFile: (file: File) => webUtils.getPathForFile(file),
119 getClientPlatform: () => clientPlatform,
120 restartAudioService: () => ipcRenderer.invoke(IpcChannels.RESTART_AUDIO_SERVICE_CHANNEL),
121 setNotificationBadge: (badge) =>
122 ipcRenderer.invoke(IpcChannels.SET_NOTIFICATION_BADGE_CHANNEL, badge),
123 onNotificationBadgeClear: (listener) => {
124 const handler = () => listener();
125 ipcRenderer.on(IpcChannels.SET_NOTIFICATION_BADGE_CHANNEL, handler);
126 return () => ipcRenderer.removeListener(IpcChannels.SET_NOTIFICATION_BADGE_CHANNEL, handler);
127 },
128 onTrackpadScrollBegin: (listener) => {
129 const handler = () => listener();
130 ipcRenderer.on(IpcChannels.TRACKPAD_SCROLL_BEGIN_CHANNEL, handler);
131 return () => ipcRenderer.removeListener(IpcChannels.TRACKPAD_SCROLL_BEGIN_CHANNEL, handler);
132 },
133 onTrackpadScrollEnd: (listener) => {
134 const handler = () => listener();
135 ipcRenderer.on(IpcChannels.TRACKPAD_SCROLL_END_CHANNEL, handler);
136 return () => ipcRenderer.removeListener(IpcChannels.TRACKPAD_SCROLL_END_CHANNEL, handler);
137 },
138 revealWindow: () => ipcRenderer.invoke(IpcChannels.REVEAL_WINDOW_CHANNEL),
139 getPrimaryPasteEnabled: () => primaryPasteEnabled,
140 getSystemLocale: () => {
141 const result = ipcRenderer.sendSync(IpcChannels.GET_SYSTEM_LOCALE_CHANNEL);
142 return typeof result === "string" ? result : null;
143 },
144 getPreferredSystemLanguages: () => {
145 const result: unknown = ipcRenderer.sendSync(
146 IpcChannels.GET_PREFERRED_SYSTEM_LANGUAGES_CHANNEL,
147 );
148 return Array.isArray(result) ? result.filter((tag) => typeof tag === "string") : [];
149 },
150 getLocalEnvironmentBootstraps: () => {
151 const result = ipcRenderer.sendSync(IpcChannels.GET_LOCAL_ENVIRONMENT_BOOTSTRAPS_CHANNEL);
152 if (!Array.isArray(result)) {
153 return [];
154 }
155 return result as ReturnType<DesktopBridge["getLocalEnvironmentBootstraps"]>;
156 },
157 getLocalEnvironmentBearerToken: () =>
158 ipcRenderer.invoke(IpcChannels.GET_LOCAL_ENVIRONMENT_BEARER_TOKEN_CHANNEL),
159 getLocalEnvironmentEnabled: () =>
160 ipcRenderer.sendSync(IpcChannels.GET_LOCAL_ENVIRONMENT_ENABLED_CHANNEL) !== false,
161 setLocalEnvironmentEnabled: (enabled) =>
162 ipcRenderer.invoke(IpcChannels.SET_LOCAL_ENVIRONMENT_ENABLED_CHANNEL, enabled),
163 getHostEnvironmentId: () => ipcRenderer.invoke(IpcChannels.GET_HOST_ENVIRONMENT_ID_CHANNEL),
164 getClientSettings: () => ipcRenderer.invoke(IpcChannels.GET_CLIENT_SETTINGS_CHANNEL),
165 setClientSettings: (settings) =>
166 ipcRenderer.invoke(IpcChannels.SET_CLIENT_SETTINGS_CHANNEL, settings),
167 requestSnapShotPermissions: (includeAccessibility) =>
168 ipcRenderer.invoke(IpcChannels.REQUEST_SNAP_SHOT_PERMISSIONS_CHANNEL, includeAccessibility),
169 getSnapShotState: () => ipcRenderer.invoke(IpcChannels.GET_SNAP_SHOT_STATE_CHANNEL),
170 setupSnapShot: (action) => ipcRenderer.invoke(IpcChannels.SETUP_SNAP_SHOT_CHANNEL, action),
171 previewSnapShotConfig: (request) =>
172 ipcRenderer.invoke(IpcChannels.PREVIEW_SNAP_SHOT_CONFIG_CHANNEL, request),
173 applySnapShotConfig: (id) => ipcRenderer.invoke(IpcChannels.APPLY_SNAP_SHOT_CONFIG_CHANNEL, id),
174 checkSnapShotShortcut: (shortcut) =>
175 ipcRenderer.invoke(IpcChannels.CHECK_SNAP_SHOT_SHORTCUT_CHANNEL, shortcut),
176 setSnapShotShortcutSuppressed: (suppressed) =>
177 ipcRenderer.invoke(IpcChannels.SET_SNAP_SHOT_SHORTCUT_SUPPRESSED_CHANNEL, suppressed),
178 listPendingSnapShots: () => ipcRenderer.invoke(IpcChannels.LIST_PENDING_SNAP_SHOTS_CHANNEL),
179 readSnapShot: (id) => ipcRenderer.invoke(IpcChannels.READ_SNAP_SHOT_CHANNEL, id),
180 setSnapShotAnimationDestination: (destination) =>
181 ipcRenderer.invoke(IpcChannels.SET_SNAP_SHOT_ANIMATION_DESTINATION_CHANNEL, destination),
182 dismissSnapShotAnimation: (id) =>
183 ipcRenderer.invoke(IpcChannels.DISMISS_SNAP_SHOT_ANIMATION_CHANNEL, id),
184 acknowledgeSnapShot: (id) => ipcRenderer.invoke(IpcChannels.ACKNOWLEDGE_SNAP_SHOT_CHANNEL, id),
185 getConnectionCatalog: () => ipcRenderer.invoke(IpcChannels.GET_CONNECTION_CATALOG_CHANNEL),
186 setConnectionCatalog: (catalog) =>
187 ipcRenderer.invoke(IpcChannels.SET_CONNECTION_CATALOG_CHANNEL, catalog),
188 discoverSshHosts: () => ipcRenderer.invoke(IpcChannels.DISCOVER_SSH_HOSTS_CHANNEL),
189 resolveSshHost: (alias) => ipcRenderer.invoke(IpcChannels.RESOLVE_SSH_HOST_CHANNEL, alias),
190 ensureSshEnvironment: async (target, options) =>
191 unwrapEnsureSshEnvironmentResult(
192 await ipcRenderer.invoke(IpcChannels.ENSURE_SSH_ENVIRONMENT_CHANNEL, {
193 target,
194 ...(options === undefined ? {} : { options }),
195 }),
196 ),
197 disconnectSshEnvironment: (target) =>
198 ipcRenderer.invoke(IpcChannels.DISCONNECT_SSH_ENVIRONMENT_CHANNEL, target),
199 fetchSshEnvironmentDescriptor: (httpBaseUrl) =>
200 ipcRenderer.invoke(IpcChannels.FETCH_SSH_ENVIRONMENT_DESCRIPTOR_CHANNEL, { httpBaseUrl }),
201 bootstrapSshBearerSession: (httpBaseUrl, credential) =>
202 ipcRenderer.invoke(IpcChannels.BOOTSTRAP_SSH_BEARER_SESSION_CHANNEL, {
203 httpBaseUrl,
204 credential,
205 }),
206 fetchSshSessionState: (httpBaseUrl, bearerToken) =>
207 ipcRenderer.invoke(IpcChannels.FETCH_SSH_SESSION_STATE_CHANNEL, { httpBaseUrl, bearerToken }),
208 onSshPasswordPrompt: (listener) => {
209 const wrappedListener = (_event: Electron.IpcRendererEvent, request: unknown) => {
210 if (typeof request !== "object" || request === null) return;
211 listener(request as Parameters<typeof listener>[0]);
212 };
213
214 ipcRenderer.on(IpcChannels.SSH_PASSWORD_PROMPT_CHANNEL, wrappedListener);
215 return () => {
216 ipcRenderer.removeListener(IpcChannels.SSH_PASSWORD_PROMPT_CHANNEL, wrappedListener);
217 };
218 },
219 onSshPasswordPromptSettled: (listener) => {
220 const wrappedListener = (_event: Electron.IpcRendererEvent, requestId: unknown) => {
221 if (typeof requestId !== "string") return;
222 listener(requestId);
223 };
224
225 ipcRenderer.on(IpcChannels.SSH_PASSWORD_PROMPT_SETTLED_CHANNEL, wrappedListener);
226 return () => {
227 ipcRenderer.removeListener(IpcChannels.SSH_PASSWORD_PROMPT_SETTLED_CHANNEL, wrappedListener);
228 };
229 },
230 resolveSshPasswordPrompt: (requestId, password) =>
231 ipcRenderer.invoke(IpcChannels.RESOLVE_SSH_PASSWORD_PROMPT_CHANNEL, { requestId, password }),
232 getServerExposureState: () => ipcRenderer.invoke(IpcChannels.GET_SERVER_EXPOSURE_STATE_CHANNEL),
233 setServerExposureMode: (mode) =>
234 ipcRenderer.invoke(IpcChannels.SET_SERVER_EXPOSURE_MODE_CHANNEL, mode),
235 setTailscaleServeEnabled: (input) =>
236 ipcRenderer.invoke(IpcChannels.SET_TAILSCALE_SERVE_ENABLED_CHANNEL, input),
237 getAdvertisedEndpoints: () => ipcRenderer.invoke(IpcChannels.GET_ADVERTISED_ENDPOINTS_CHANNEL),
238 getWslState: () => ipcRenderer.invoke(IpcChannels.GET_WSL_STATE_CHANNEL),
239 setWslBackendEnabled: (enabled) =>
240 ipcRenderer.invoke(IpcChannels.SET_WSL_BACKEND_ENABLED_CHANNEL, enabled),
241 setWslDistro: (distro) => ipcRenderer.invoke(IpcChannels.SET_WSL_DISTRO_CHANNEL, distro),
242 setWslOnly: (enabled) => ipcRenderer.invoke(IpcChannels.SET_WSL_ONLY_CHANNEL, enabled),
243 pickFolder: (options) => ipcRenderer.invoke(IpcChannels.PICK_FOLDER_CHANNEL, options),
244 toLocalBackendPath: (backendId, path) =>
245 ipcRenderer.invoke(IpcChannels.TO_LOCAL_BACKEND_PATH_CHANNEL, { backendId, path }),
246 pickProjectFavicon: (initialPath) =>
247 ipcRenderer.invoke(IpcChannels.PICK_PROJECT_FAVICON_CHANNEL, initialPath),
248 pickThemeFiles: () => ipcRenderer.invoke(IpcChannels.PICK_THEME_FILES_CHANNEL, undefined),
249 setTheme: (theme) => ipcRenderer.invoke(IpcChannels.SET_THEME_CHANNEL, theme),
250 showContextMenu: (items, position, source) =>
251 ipcRenderer.invoke(IpcChannels.CONTEXT_MENU_CHANNEL, {
252 items,
253 ...(position === undefined ? {} : { position }),
254 ...(source === undefined ? {} : { source }),
255 }),
256 receiveProviderAuthCallback: (url: string) =>
257 ipcRenderer.invoke(IpcChannels.RECEIVE_PROVIDER_AUTH_CALLBACK_CHANNEL, url),
258 cancelProviderAuthCallback: (url: string) =>
259 ipcRenderer.invoke(IpcChannels.CANCEL_PROVIDER_AUTH_CALLBACK_CHANNEL, url),
260 startFileDrag: (input) => ipcRenderer.invoke(IpcChannels.START_FILE_DRAG_CHANNEL, input),
261 openExternal: (url: string) => ipcRenderer.invoke(IpcChannels.OPEN_EXTERNAL_CHANNEL, url),
262 readMedia: (url: string) => ipcRenderer.invoke(IpcChannels.READ_MEDIA_CHANNEL, url),
263 checkSystemPermission: (pane: string) =>
264 ipcRenderer.invoke(IpcChannels.CHECK_SYSTEM_PERMISSION_CHANNEL, pane),
265 appleSpeech: {
266 supportedLocales: () =>
267 ipcRenderer.invoke(IpcChannels.APPLE_SPEECH_AVAILABLE_CHANNEL, undefined),
268 prepare: (locale: string) =>
269 ipcRenderer.invoke(IpcChannels.APPLE_SPEECH_PREPARE_CHANNEL, locale),
270 transcribe: (input: { locale: string; pcm: Uint8Array }) =>
271 ipcRenderer.invoke(IpcChannels.APPLE_SPEECH_TRANSCRIBE_CHANNEL, input),
272 },
273 openSystemSettings: (pane: string) =>
274 ipcRenderer.invoke(IpcChannels.OPEN_SYSTEM_SETTINGS_CHANNEL, pane),
275 probeRemoteEditors: () => ipcRenderer.invoke(IpcChannels.PROBE_REMOTE_EDITORS_CHANNEL, undefined),
276 pasteAsText: () => ipcRenderer.invoke(IpcChannels.PASTE_AS_TEXT_CHANNEL, undefined),
277 onMenuAction: (listener) => {
278 const wrappedListener = (_event: Electron.IpcRendererEvent, action: unknown) => {
279 if (typeof action !== "string") return;
280 listener(action);
281 };
282
283 ipcRenderer.on(IpcChannels.MENU_ACTION_CHANNEL, wrappedListener);
284 return () => {
285 ipcRenderer.removeListener(IpcChannels.MENU_ACTION_CHANNEL, wrappedListener);
286 };
287 },
288 onSnapShotEvent: (listener) => {
289 const wrappedListener = (_event: Electron.IpcRendererEvent, event: unknown) => {
290 if (!isSnapShotEvent(event)) return;
291 listener(event);
292 };
293
294 ipcRenderer.on(IpcChannels.SNAP_SHOT_EVENT_CHANNEL, wrappedListener);
295 return () => {
296 ipcRenderer.removeListener(IpcChannels.SNAP_SHOT_EVENT_CHANNEL, wrappedListener);
297 };
298 },
299 onQuitShortcut: (listener) => {
300 const wrappedListener = (_event: Electron.IpcRendererEvent, hint: unknown) => {
301 if (typeof hint !== "object" || hint === null || !("state" in hint)) return;
302 if (hint.state === "up") {
303 listener({ state: "up" });
304 return;
305 }
306 if (
307 hint.state === "down" &&
308 "mode" in hint &&
309 (hint.mode === "hold" || hint.mode === "double-click")
310 ) {
311 listener({ state: "down", mode: hint.mode });
312 }
313 };
314
315 ipcRenderer.on(IpcChannels.QUIT_SHORTCUT_CHANNEL, wrappedListener);
316 return () => {
317 ipcRenderer.removeListener(IpcChannels.QUIT_SHORTCUT_CHANNEL, wrappedListener);
318 };
319 },
320 getWindowFullscreenState: () =>
321 ipcRenderer.sendSync(IpcChannels.GET_WINDOW_FULLSCREEN_STATE_CHANNEL) === true,
322 getWindowZoomFactor: () => webFrame.getZoomFactor(),
323 onWindowFullscreenStateChange: (listener) => {
324 const wrappedListener = (_event: Electron.IpcRendererEvent, fullscreen: unknown) => {
325 if (typeof fullscreen !== "boolean") return;
326 listener(fullscreen);
327 };
328
329 ipcRenderer.on(IpcChannels.WINDOW_FULLSCREEN_STATE_CHANNEL, wrappedListener);
330 return () => {
331 ipcRenderer.removeListener(IpcChannels.WINDOW_FULLSCREEN_STATE_CHANNEL, wrappedListener);
332 };
333 },
334 getUpdateState: () => ipcRenderer.invoke(IpcChannels.UPDATE_GET_STATE_CHANNEL),
335 setUpdateChannel: (channel, minimumVersion) =>
336 ipcRenderer.invoke(IpcChannels.UPDATE_SET_CHANNEL_CHANNEL, { channel, minimumVersion }),
337 checkForUpdate: () => ipcRenderer.invoke(IpcChannels.UPDATE_CHECK_CHANNEL),
338 downloadUpdate: () => ipcRenderer.invoke(IpcChannels.UPDATE_DOWNLOAD_CHANNEL),
339 installUpdate: (expectedVersion) =>
340 ipcRenderer.invoke(IpcChannels.UPDATE_INSTALL_CHANNEL, expectedVersion),
341 cliCommand: {
342 getState: () => ipcRenderer.invoke(IpcChannels.CLI_COMMAND_GET_STATE_CHANNEL),
343 install: () => ipcRenderer.invoke(IpcChannels.CLI_COMMAND_INSTALL_CHANNEL),
344 uninstall: () => ipcRenderer.invoke(IpcChannels.CLI_COMMAND_UNINSTALL_CHANNEL),
345 addToPath: () => ipcRenderer.invoke(IpcChannels.CLI_COMMAND_ADD_TO_PATH_CHANNEL),
346 },
347 onUpdateState: (listener) => {
348 const wrappedListener = (_event: Electron.IpcRendererEvent, state: unknown) => {
349 if (typeof state !== "object" || state === null) return;
350 listener(state as Parameters<typeof listener>[0]);
351 };
352
353 ipcRenderer.on(IpcChannels.UPDATE_STATE_CHANNEL, wrappedListener);
354 return () => {
355 ipcRenderer.removeListener(IpcChannels.UPDATE_STATE_CHANNEL, wrappedListener);
356 };
357 },
358 webLinks: {
359 setReady: (ready) => ipcRenderer.invoke(IpcChannels.WEB_LINK_READY_CHANNEL, ready),
360 onOpen: (listener) => {
361 const wrappedListener = (_event: Electron.IpcRendererEvent, url: unknown) => {
362 if (typeof url === "string") listener(url);
363 };
364 ipcRenderer.on(IpcChannels.WEB_LINK_OPEN_CHANNEL, wrappedListener);
365 return () => {
366 ipcRenderer.removeListener(IpcChannels.WEB_LINK_OPEN_CHANNEL, wrappedListener);
367 };
368 },
369 },
370 appActivation: {
371 setReady: (ready) =>
372 ipcRenderer.invoke(IpcChannels.DESKTOP_APP_ACTIVATION_READY_CHANNEL, ready),
373 complete: (response) =>
374 ipcRenderer.invoke(IpcChannels.DESKTOP_APP_ACTIVATION_COMPLETE_CHANNEL, response),
375 onRequest: (listener) => {
376 const wrappedListener = (_event: Electron.IpcRendererEvent, request: unknown) => {
377 if (typeof request !== "object" || request === null) return;
378 listener(request as Parameters<typeof listener>[0]);
379 };
380 ipcRenderer.on(IpcChannels.DESKTOP_APP_ACTIVATION_REQUEST_CHANNEL, wrappedListener);
381 return () => {
382 ipcRenderer.removeListener(
383 IpcChannels.DESKTOP_APP_ACTIVATION_REQUEST_CHANNEL,
384 wrappedListener,
385 );
386 };
387 },
388 },
389 preview: {
390 setForwardedShortcuts: (shortcuts) =>
391 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_FORWARDED_SHORTCUTS_CHANNEL, shortcuts),
392 createTab: (tabId, defaults) =>
393 ipcRenderer.invoke(IpcChannels.PREVIEW_CREATE_TAB_CHANNEL, {
394 tabId,
395 zoomFactor: defaults?.zoomFactor,
396 serverTab: defaults?.serverTab,
397 colorScheme: defaults?.colorScheme,
398 }),
399 closeTab: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_CLOSE_TAB_CHANNEL, { tabId }),
400 registerWebview: (tabId, webContentsId) =>
401 ipcRenderer.invoke(IpcChannels.PREVIEW_REGISTER_WEBVIEW_CHANNEL, { tabId, webContentsId }),
402 navigate: (tabId, url) =>
403 ipcRenderer.invoke(IpcChannels.PREVIEW_NAVIGATE_CHANNEL, { tabId, url }),
404 goBack: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_GO_BACK_CHANNEL, { tabId }),
405 goForward: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_GO_FORWARD_CHANNEL, { tabId }),
406 refresh: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_REFRESH_CHANNEL, { tabId }),
407 stopLoading: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_STOP_LOADING_CHANNEL, { tabId }),
408 zoomIn: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_ZOOM_IN_CHANNEL, { tabId }),
409 zoomOut: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_ZOOM_OUT_CHANNEL, { tabId }),
410 resetZoom: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_RESET_ZOOM_CHANNEL, { tabId }),
411 setZoomFactor: (tabId, zoomFactor) =>
412 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_ZOOM_FACTOR_CHANNEL, { tabId, zoomFactor }),
413 hardReload: (tabId) => ipcRenderer.invoke(IpcChannels.PREVIEW_HARD_RELOAD_CHANNEL, { tabId }),
414 setColorScheme: (tabId, colorScheme) =>
415 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_COLOR_SCHEME_CHANNEL, { tabId, colorScheme }),
416 setAudioMuted: (tabId, audioMuted) =>
417 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_AUDIO_MUTED_CHANNEL, { tabId, audioMuted }),
418 findInPage: (tabId, text, { forward, newSession }) =>
419 ipcRenderer.invoke(IpcChannels.PREVIEW_FIND_IN_PAGE_CHANNEL, {
420 tabId,
421 text,
422 forward,
423 newSession,
424 }),
425 stopFindInPage: (tabId) =>
426 ipcRenderer.invoke(IpcChannels.PREVIEW_STOP_FIND_IN_PAGE_CHANNEL, { tabId }),
427 setShown: (tabId, shown) =>
428 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_SHOWN_CHANNEL, { tabId, shown }),
429 setCaptureDrawn: (tabId, drawn) =>
430 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_CAPTURE_DRAWN_CHANNEL, { tabId, drawn }),
431 openDevTools: (tabId) =>
432 ipcRenderer.invoke(IpcChannels.PREVIEW_OPEN_DEVTOOLS_CHANNEL, { tabId }),
433 listBrowserImportSources: () => ipcRenderer.invoke(IpcChannels.PREVIEW_IMPORT_SOURCES_CHANNEL),
434 importBrowserCookies: (input) =>
435 ipcRenderer.invoke(IpcChannels.PREVIEW_IMPORT_COOKIES_CHANNEL, input),
436 clearCookies: (environmentId, profileId) =>
437 ipcRenderer.invoke(IpcChannels.PREVIEW_CLEAR_COOKIES_CHANNEL, { environmentId, profileId }),
438 clearCache: (environmentId, profileId) =>
439 ipcRenderer.invoke(IpcChannels.PREVIEW_CLEAR_CACHE_CHANNEL, { environmentId, profileId }),
440 getPreviewConfig: (environmentId, profileId, tunnelLoopback) =>
441 ipcRenderer.invoke(IpcChannels.PREVIEW_GET_CONFIG_CHANNEL, {
442 environmentId,
443 profileId,
444 tunnelLoopback,
445 }),
446 onTunnelAccessRequest: (listener) => {
447 const wrappedListener = (_event: Electron.IpcRendererEvent, request: unknown) => {
448 if (typeof request !== "object" || request === null) return;
449 listener(request as Parameters<typeof listener>[0]);
450 };
451 ipcRenderer.on(IpcChannels.PREVIEW_TUNNEL_ACCESS_REQUEST_CHANNEL, wrappedListener);
452 return () =>
453 ipcRenderer.removeListener(
454 IpcChannels.PREVIEW_TUNNEL_ACCESS_REQUEST_CHANNEL,
455 wrappedListener,
456 );
457 },
458 resolveTunnelAccess: (requestId, url) =>
459 ipcRenderer.invoke(IpcChannels.PREVIEW_TUNNEL_ACCESS_RESOLVE_CHANNEL, { requestId, url }),
460 forwardPort: (environmentId, remotePort) =>
461 ipcRenderer.invoke(IpcChannels.PORT_FORWARD_START_CHANNEL, { environmentId, remotePort }),
462 stopPortForward: (environmentId, remotePort) =>
463 ipcRenderer.invoke(IpcChannels.PORT_FORWARD_STOP_CHANNEL, { environmentId, remotePort }),
464 listPortForwards: () => ipcRenderer.invoke(IpcChannels.PORT_FORWARD_LIST_CHANNEL),
465 sharesLoopback: (environmentId) =>
466 ipcRenderer.invoke(IpcChannels.PORT_FORWARD_SHARES_LOOPBACK_CHANNEL, { environmentId }),
467 onPortForwards: (listener) => {
468 const wrappedListener = (_event: Electron.IpcRendererEvent, forwards: unknown) => {
469 if (!Array.isArray(forwards)) return;
470 listener(forwards);
471 };
472 ipcRenderer.on(IpcChannels.PORT_FORWARD_CHANGE_CHANNEL, wrappedListener);
473 return () =>
474 ipcRenderer.removeListener(IpcChannels.PORT_FORWARD_CHANGE_CHANNEL, wrappedListener);
475 },
476 setAnnotationTheme: (theme) =>
477 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_ANNOTATION_THEME_CHANNEL, { theme }),
478 setAnnotationSendEnabled: (tabId, enabled) =>
479 ipcRenderer.invoke(IpcChannels.PREVIEW_SET_ANNOTATION_SEND_ENABLED_CHANNEL, {
480 tabId,
481 enabled,
482 }),
483 annotationVoice: {
484 onEvent: (listener) => {
485 const onEvent = (_event: Electron.IpcRendererEvent, tabId: string, value: unknown) => {
486 if (typeof tabId !== "string" || typeof value !== "object" || value === null) return;
487 listener(tabId, value as DesktopPreviewAnnotationVoiceEvent);
488 };
489 ipcRenderer.on(IpcChannels.PREVIEW_ANNOTATION_VOICE_EVENT_CHANNEL, onEvent);
490 return () => ipcRenderer.off(IpcChannels.PREVIEW_ANNOTATION_VOICE_EVENT_CHANNEL, onEvent);
491 },
492 update: (state) =>
493 ipcRenderer.invoke(IpcChannels.PREVIEW_ANNOTATION_VOICE_STATE_CHANNEL, state),
494 },
495 pickElement: (tabId, voice) =>
496 ipcRenderer.invoke(IpcChannels.PREVIEW_PICK_ELEMENT_CHANNEL, { tabId, voice }),
497 cancelPickElement: (tabId) =>
498 ipcRenderer.invoke(IpcChannels.PREVIEW_CANCEL_PICK_ELEMENT_CHANNEL, { tabId }),
499 captureScreenshot: (tabId) =>
500 ipcRenderer.invoke(IpcChannels.PREVIEW_CAPTURE_SCREENSHOT_CHANNEL, { tabId }),
501 revealArtifact: (path) =>
502 ipcRenderer.invoke(IpcChannels.PREVIEW_REVEAL_ARTIFACT_CHANNEL, { path }),
503 copyArtifactToClipboard: (path) =>
504 ipcRenderer.invoke(IpcChannels.PREVIEW_COPY_ARTIFACT_CHANNEL, { path }),
505 pictureInPicture: {
506 open: (tabId) =>
507 ipcRenderer.invoke(IpcChannels.PREVIEW_PICTURE_IN_PICTURE_OPEN_CHANNEL, { tabId }),
508 close: (tabId) =>
509 ipcRenderer.invoke(IpcChannels.PREVIEW_PICTURE_IN_PICTURE_CLOSE_CHANNEL, { tabId }),
510 },
511 recording: {
512 onInput: (listener) => {
513 const wrappedListener = (_event: Electron.IpcRendererEvent, event: unknown) => {
514 if (typeof event !== "object" || event === null) return;
515 listener(event as DesktopPreviewRecordingInputEvent);
516 };
517 ipcRenderer.on(IpcChannels.PREVIEW_RECORDING_INPUT_CHANNEL, wrappedListener);
518 return () =>
519 ipcRenderer.removeListener(IpcChannels.PREVIEW_RECORDING_INPUT_CHANNEL, wrappedListener);
520 },
521 startScreencast: (tabId) =>
522 ipcRenderer.invoke(IpcChannels.PREVIEW_RECORDING_START_CHANNEL, { tabId }),
523 stopScreencast: (tabId) =>
524 ipcRenderer.invoke(IpcChannels.PREVIEW_RECORDING_STOP_CHANNEL, { tabId }),
525 save: (tabId, mimeType, data) =>
526 ipcRenderer.invoke(IpcChannels.PREVIEW_RECORDING_SAVE_CHANNEL, {
527 tabId,
528 mimeType,
529 data,
530 }),
531 },
532 onStateChange: (listener) => {
533 const wrappedListener = (
534 _event: Electron.IpcRendererEvent,
535 tabId: unknown,
536 state: unknown,
537 ) => {
538 if (typeof tabId !== "string" || typeof state !== "object" || state === null) return;
539 listener(tabId, state as DesktopPreviewTabState);
540 };
541 ipcRenderer.on(IpcChannels.PREVIEW_STATE_CHANGE_CHANNEL, wrappedListener);
542 return () =>
543 ipcRenderer.removeListener(IpcChannels.PREVIEW_STATE_CHANGE_CHANNEL, wrappedListener);
544 },
545 onPointerEvent: (listener) => {
546 const wrappedListener = (_event: Electron.IpcRendererEvent, pointerEvent: unknown) => {
547 if (typeof pointerEvent !== "object" || pointerEvent === null) return;
548 listener(pointerEvent as DesktopPreviewPointerEvent);
549 };
550 ipcRenderer.on(IpcChannels.PREVIEW_POINTER_EVENT_CHANNEL, wrappedListener);
551 return () =>
552 ipcRenderer.removeListener(IpcChannels.PREVIEW_POINTER_EVENT_CHANNEL, wrappedListener);
553 },
554 onOpenLink: (listener) => {
555 const wrappedListener = (_event: Electron.IpcRendererEvent, linkEvent: unknown) => {
556 if (typeof linkEvent !== "object" || linkEvent === null) return;
557 listener(linkEvent as DesktopPreviewOpenLinkEvent);
558 };
559 ipcRenderer.on(IpcChannels.PREVIEW_OPEN_LINK_CHANNEL, wrappedListener);
560 return () =>
561 ipcRenderer.removeListener(IpcChannels.PREVIEW_OPEN_LINK_CHANNEL, wrappedListener);
562 },
563 onFindResult: (listener) => {
564 const wrappedListener = (_event: Electron.IpcRendererEvent, findEvent: unknown) => {
565 if (typeof findEvent !== "object" || findEvent === null) return;
566 listener(findEvent as DesktopPreviewFindResultEvent);
567 };
568 ipcRenderer.on(IpcChannels.PREVIEW_FIND_RESULT_CHANNEL, wrappedListener);
569 return () =>
570 ipcRenderer.removeListener(IpcChannels.PREVIEW_FIND_RESULT_CHANNEL, wrappedListener);
571 },
572 },
573 } satisfies DesktopBridge);