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 * as MacPermissions from "./permissions/MacPermissions.ts"; |
| 2 | import { handleStdioError } from "./app/stdioErrors.ts"; |
| 3 | |
| 4 | for (const stream of [process.stdout, process.stderr]) { |
| 5 | stream.on("error", handleStdioError); |
| 6 | } |
| 7 | |
| 8 | import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient"; |
| 9 | import * as NodeRuntime from "@effect/platform-node/NodeRuntime"; |
| 10 | import * as NodeCrypto from "@effect/platform-node/NodeCrypto"; |
| 11 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
| 12 | // @effect-diagnostics-next-line nodeBuiltinImport:off - Version output must flush before Electron exits, without acquiring the runtime. |
| 13 | import * as NodeFS from "node:fs"; |
| 14 | import * as NodeOS from "node:os"; |
| 15 | import * as SecureRandom from "effect/crypto/SecureRandom"; |
| 16 | import * as Effect from "effect/Effect"; |
| 17 | import * as FileSystem from "effect/FileSystem"; |
| 18 | import * as Layer from "effect/Layer"; |
| 19 | |
| 20 | import * as Electron from "electron"; |
| 21 | |
| 22 | import * as NetService from "@t3tools/shared/Net"; |
| 23 | import * as HostProcess from "@t3tools/shared/HostProcess"; |
| 24 | |
| 25 | import * as DesktopIpc from "./ipc/DesktopIpc.ts"; |
| 26 | import * as ElectronApp from "./electron/ElectronApp.ts"; |
| 27 | import * as ElectronDialog from "./electron/ElectronDialog.ts"; |
| 28 | import * as ElectronMenu from "./electron/ElectronMenu.ts"; |
| 29 | import * as ElectronPowerMonitor from "./electron/ElectronPowerMonitor.ts"; |
| 30 | import * as ElectronProtocol from "./electron/ElectronProtocol.ts"; |
| 31 | import * as ElectronSafeStorage from "./electron/ElectronSafeStorage.ts"; |
| 32 | import * as ElectronShell from "./electron/ElectronShell.ts"; |
| 33 | import * as ElectronTheme from "./electron/ElectronTheme.ts"; |
| 34 | import * as ElectronUpdater from "./electron/ElectronUpdater.ts"; |
| 35 | import * as ElectronWindow from "./electron/ElectronWindow.ts"; |
| 36 | import * as DesktopApp from "./app/DesktopApp.ts"; |
| 37 | import * as DesktopAppActivation from "./app/DesktopAppActivation.ts"; |
| 38 | import * as DesktopWebLinks from "./app/DesktopWebLinks.ts"; |
| 39 | import * as DesktopAppIdentity from "./app/DesktopAppIdentity.ts"; |
| 40 | import * as DesktopConnectionCatalogStore from "./app/DesktopConnectionCatalogStore.ts"; |
| 41 | import * as DesktopClerk from "./app/DesktopClerk.ts"; |
| 42 | import * as DesktopCliCommand from "./app/DesktopCliCommand.ts"; |
| 43 | import * as DesktopApplicationMenu from "./window/DesktopApplicationMenu.ts"; |
| 44 | import * as DesktopAssets from "./app/DesktopAssets.ts"; |
| 45 | import * as DesktopPrimaryPaste from "./app/DesktopPrimaryPaste.ts"; |
| 46 | import * as DesktopBackendConfiguration from "./backend/DesktopBackendConfiguration.ts"; |
| 47 | import * as DesktopBackendPool from "./backend/DesktopBackendPool.ts"; |
| 48 | import * as DesktopLocalEnvironmentAuth from "./backend/DesktopLocalEnvironmentAuth.ts"; |
| 49 | import * as DesktopNetworkInterfaces from "./backend/DesktopNetworkInterfaces.ts"; |
| 50 | import * as DesktopEnvironment from "./app/DesktopEnvironment.ts"; |
| 51 | import * as DesktopManagedPolicy from "./app/DesktopManagedPolicy.ts"; |
| 52 | import * as DesktopLifecycle from "./app/DesktopLifecycle.ts"; |
| 53 | import * as DesktopLinuxUrlHandler from "./app/DesktopLinuxUrlHandler.ts"; |
| 54 | import * as DesktopShutdown from "./app/DesktopShutdown.ts"; |
| 55 | import * as DesktopObservability from "./app/DesktopObservability.ts"; |
| 56 | import * as DesktopServerExposure from "./backend/DesktopServerExposure.ts"; |
| 57 | import * as DesktopClientSettings from "./settings/DesktopClientSettings.ts"; |
| 58 | import * as DesktopSavedEnvironments from "./settings/DesktopSavedEnvironments.ts"; |
| 59 | import * as DesktopSnapShot from "./snapShot/DesktopSnapShot.ts"; |
| 60 | import * as DesktopAppSettings from "./settings/DesktopAppSettings.ts"; |
| 61 | import * as DesktopPreReadyFileSystem from "./app/DesktopPreReadyFileSystem.ts"; |
| 62 | import * as DesktopPreReadyPlatform from "./app/DesktopPreReadyPlatform.ts"; |
| 63 | import * as DesktopShellEnvironment from "./shell/DesktopShellEnvironment.ts"; |
| 64 | import * as DesktopSshEnvironment from "./ssh/DesktopSshEnvironment.ts"; |
| 65 | import * as DesktopSshPasswordPrompts from "./ssh/DesktopSshPasswordPrompts.ts"; |
| 66 | import * as DesktopState from "./app/DesktopState.ts"; |
| 67 | import * as DesktopLegacyLocalStorage from "./app/DesktopLegacyLocalStorage.ts"; |
| 68 | import * as DesktopTelemetryPublisher from "./telemetry/DesktopTelemetryPublisher.ts"; |
| 69 | import * as DesktopRendererHistory from "./telemetry/DesktopRendererHistory.ts"; |
| 70 | import * as DesktopUpdatePolicy from "./updates/DesktopUpdatePolicy.ts"; |
| 71 | import * as DesktopUpdates from "./updates/DesktopUpdates.ts"; |
| 72 | import * as BrowserImport from "./preview/BrowserImport/BrowserImport.ts"; |
| 73 | import * as LinuxBrowserSecret from "./preview/BrowserImport/LinuxBrowserSecret.ts"; |
| 74 | import * as AppleSpeech from "./speech/AppleSpeech.ts"; |
| 75 | import * as BrowserSession from "./preview/BrowserSession.ts"; |
| 76 | import * as DesktopBrowserHost from "./preview/DesktopBrowserHost.ts"; |
| 77 | import * as LoopbackTunnel from "./preview/LoopbackTunnel.ts"; |
| 78 | import * as PreviewManager from "./preview/Manager.ts"; |
| 79 | import * as PreviewPasskeys from "./preview/Passkeys.ts"; |
| 80 | import * as DesktopWindow from "./window/DesktopWindow.ts"; |
| 81 | import * as DesktopWslBackend from "./wsl/DesktopWslBackend.ts"; |
| 82 | import * as DesktopWslEnvironment from "./wsl/DesktopWslEnvironment.ts"; |
| 83 | import * as DesktopWslServerTree from "./wsl/DesktopWslServerTree.ts"; |
| 84 | |
| 85 | if (process.argv.includes("--version")) { |
| 86 | try { |
| 87 | NodeFS.writeSync(process.stdout.fd, `${Electron.app.getVersion()}\n`); |
| 88 | } catch (error) { |
| 89 | if (!(error instanceof Error) || !("code" in error) || error.code !== "EPIPE") throw error; |
| 90 | } |
| 91 | Electron.app.exit(0); |
| 92 | } |
| 93 | |
| 94 | const layerDesktopEnvironment = Layer.unwrap( |
| 95 | Effect.gen(function* () { |
| 96 | const metadata = yield* Effect.service(ElectronApp.ElectronApp).pipe( |
| 97 | Effect.flatMap((app) => app.metadata), |
| 98 | ); |
| 99 | const platform = yield* HostProcess.Platform; |
| 100 | const processArch = yield* HostProcess.Architecture; |
| 101 | return DesktopEnvironment.layer({ |
| 102 | dirname: __dirname, |
| 103 | homeDirectory: NodeOS.homedir(), |
| 104 | platform, |
| 105 | processArch, |
| 106 | ...metadata, |
| 107 | }); |
| 108 | }), |
| 109 | ); |
| 110 | |
| 111 | const layerDesktopSshEnvironment = Layer.unwrap( |
| 112 | Effect.gen(function* () { |
| 113 | const environment = yield* DesktopEnvironment.DesktopEnvironment; |
| 114 | const env = yield* HostProcess.Environment; |
| 115 | return DesktopSshEnvironment.layer({ |
| 116 | // Per connect: the login shell's environment is installed after this layer is built. |
| 117 | resolveCliRunner: Effect.sync(() => |
| 118 | DesktopSshEnvironment.resolveDesktopSshCliRunner(environment, env), |
| 119 | ), |
| 120 | resolveLauncherId: yield* Effect.cached( |
| 121 | DesktopSshEnvironment.readOrCreateLauncherId( |
| 122 | environment.path.join(environment.stateDir, "ssh-launcher-id"), |
| 123 | ).pipe( |
| 124 | Effect.provide( |
| 125 | yield* Effect.context<FileSystem.FileSystem | SecureRandom.SecureRandom>(), |
| 126 | ), |
| 127 | ), |
| 128 | ), |
| 129 | }); |
| 130 | }), |
| 131 | ); |
| 132 | |
| 133 | const layerElectron = Layer.mergeAll( |
| 134 | ElectronApp.layer, |
| 135 | ElectronDialog.layer, |
| 136 | ElectronMenu.layer, |
| 137 | ElectronPowerMonitor.layer, |
| 138 | ElectronProtocol.layer, |
| 139 | ElectronSafeStorage.layer, |
| 140 | ElectronShell.layer, |
| 141 | ElectronTheme.layer, |
| 142 | ElectronUpdater.layer, |
| 143 | ElectronWindow.layer, |
| 144 | DesktopIpc.layer(Electron.ipcMain).pipe(Layer.provide(ElectronWindow.layer)), |
| 145 | ); |
| 146 | |
| 147 | const layerDesktopFoundation = Layer.mergeAll( |
| 148 | MacPermissions.layer, |
| 149 | DesktopManagedPolicy.layer, |
| 150 | DesktopState.layer, |
| 151 | DesktopShutdown.layer, |
| 152 | DesktopLegacyLocalStorage.layer, |
| 153 | DesktopAppSettings.layer, |
| 154 | DesktopClientSettings.layer, |
| 155 | DesktopConnectionCatalogStore.layer.pipe(Layer.provideMerge(DesktopSavedEnvironments.layer)), |
| 156 | DesktopAssets.layer, |
| 157 | DesktopPrimaryPaste.layer, |
| 158 | DesktopObservability.layer, |
| 159 | DesktopRendererHistory.layer, |
| 160 | AppleSpeech.layer, |
| 161 | ).pipe(Layer.provideMerge(layerDesktopEnvironment)); |
| 162 | |
| 163 | const layerDesktopSsh = layerDesktopSshEnvironment.pipe( |
| 164 | Layer.provideMerge(DesktopSshPasswordPrompts.layer()), |
| 165 | ); |
| 166 | |
| 167 | const layerDesktopServerExposure = DesktopServerExposure.layer.pipe( |
| 168 | Layer.provideMerge(DesktopNetworkInterfaces.layer), |
| 169 | Layer.provideMerge(layerDesktopFoundation), |
| 170 | ); |
| 171 | |
| 172 | const layerDesktopPreview = PreviewManager.layer.pipe( |
| 173 | Layer.provideMerge(LoopbackTunnel.layer), |
| 174 | Layer.provideMerge(DesktopBrowserHost.layer), |
| 175 | // IPC needs both services on the same BrowserSession. |
| 176 | Layer.provideMerge(BrowserImport.layer.pipe(Layer.provide(LinuxBrowserSecret.layer))), |
| 177 | Layer.provideMerge(BrowserSession.layer), |
| 178 | Layer.provideMerge(PreviewPasskeys.layer), |
| 179 | Layer.provideMerge(layerDesktopFoundation), |
| 180 | ); |
| 181 | |
| 182 | const layerDesktopWindow = DesktopWindow.layer.pipe( |
| 183 | Layer.provideMerge(layerDesktopServerExposure), |
| 184 | Layer.provideMerge(layerDesktopPreview), |
| 185 | ); |
| 186 | |
| 187 | const layerDesktopSnapShot = DesktopSnapShot.layer.pipe( |
| 188 | Layer.provideMerge(layerDesktopWindow), |
| 189 | Layer.provideMerge(layerDesktopFoundation), |
| 190 | ); |
| 191 | const layerDesktopAppActivation = DesktopAppActivation.layer.pipe( |
| 192 | Layer.provide(layerDesktopWindow), |
| 193 | ); |
| 194 | |
| 195 | const layerDesktopBackend = DesktopBackendPool.layer.pipe( |
| 196 | Layer.provideMerge(DesktopAppIdentity.layer), |
| 197 | Layer.provideMerge(DesktopBackendConfiguration.layer), |
| 198 | Layer.provideMerge(DesktopWslEnvironment.layer), |
| 199 | Layer.provideMerge(DesktopWslServerTree.layer), |
| 200 | Layer.provideMerge(DesktopTelemetryPublisher.layer), |
| 201 | Layer.provideMerge(DesktopShellEnvironment.layer), |
| 202 | Layer.provideMerge(layerDesktopWindow), |
| 203 | ); |
| 204 | |
| 205 | const layerDesktopWslBackend = DesktopWslBackend.layer.pipe( |
| 206 | Layer.provideMerge(layerDesktopBackend), |
| 207 | ); |
| 208 | |
| 209 | const layerDesktopLocalEnvironmentAuth = DesktopLocalEnvironmentAuth.layer.pipe( |
| 210 | Layer.provideMerge(layerDesktopBackend), |
| 211 | ); |
| 212 | |
| 213 | const layerDesktopApplication = Layer.mergeAll( |
| 214 | DesktopLifecycle.layer, |
| 215 | layerDesktopAppActivation, |
| 216 | DesktopWebLinks.layer, |
| 217 | DesktopApplicationMenu.layer, |
| 218 | DesktopLinuxUrlHandler.layer, |
| 219 | DesktopCliCommand.layer, |
| 220 | ).pipe( |
| 221 | Layer.provideMerge(layerDesktopSnapShot), |
| 222 | Layer.provideMerge( |
| 223 | DesktopUpdates.layer.pipe( |
| 224 | Layer.provide(DesktopUpdatePolicy.layer), |
| 225 | // The same layer as the foundation's, so the policy is still read once. |
| 226 | Layer.provide(DesktopManagedPolicy.layer), |
| 227 | ), |
| 228 | ), |
| 229 | // Updates closes the same tunnels the SSH IPC opens before quitAndInstall. |
| 230 | Layer.provideMerge(layerDesktopSsh), |
| 231 | Layer.provideMerge(layerDesktopWslBackend), |
| 232 | Layer.provideMerge(layerDesktopLocalEnvironmentAuth), |
| 233 | ); |
| 234 | |
| 235 | // Clerk resolves userData before Electron is ready, so it gets the synchronous FileSystem. |
| 236 | const layerDesktopClerk = DesktopClerk.layer.pipe( |
| 237 | Layer.provide(DesktopPreReadyFileSystem.layer), |
| 238 | Layer.provideMerge(ElectronShell.layer), |
| 239 | Layer.provideMerge(layerDesktopEnvironment), |
| 240 | Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 241 | Layer.provideMerge(ElectronApp.layer), |
| 242 | ); |
| 243 | |
| 244 | const layerDesktopApplicationRuntime = layerDesktopApplication.pipe( |
| 245 | Layer.provideMerge(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)), |
| 246 | Layer.provideMerge(NodeHttpClient.layerUndici), |
| 247 | Layer.provideMerge(NetService.layer), |
| 248 | Layer.provideMerge(layerElectron), |
| 249 | ); |
| 250 | |
| 251 | // Pre-ready setup and Clerk must not yield before Clerk registers its scheme. |
| 252 | const layerDesktopRuntime = layerDesktopClerk.pipe( |
| 253 | Layer.flatMap((clerkContext) => |
| 254 | layerDesktopApplicationRuntime.pipe(Layer.provideMerge(Layer.succeedContext(clerkContext))), |
| 255 | ), |
| 256 | Layer.provideMerge(DesktopPreReadyPlatform.layer), |
| 257 | ); |
| 258 | |
| 259 | DesktopApp.program.pipe(Effect.provide(layerDesktopRuntime), NodeRuntime.runMain); |