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

main
ts 259 lines 11 KB
Raw
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);