The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 03:37 UTC
| 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); |