Open History to see the last commit
1import {
2 BearerConnectionCredential,
3 BearerConnectionProfile,
4 BearerConnectionTarget,
5 RelayConnectionTarget,
6 SshConnectionProfile,
7 SshConnectionTarget,
8} from "@t3tools/client-runtime/connection";
9import {
10 ConnectionCatalogDocument as RuntimeConnectionCatalogDocument,
11 type ConnectionCatalogDocument as RuntimeConnectionCatalogDocumentType,
12} from "@t3tools/client-runtime/platform";
13import type { PersistedSavedEnvironmentRecord } from "@t3tools/contracts";
14import { fromLenientJson } from "@t3tools/shared/schemaJson";
15import * as Context from "effect/Context";
16import * as SecureRandom from "effect/crypto/SecureRandom";
17import * as Effect from "effect/Effect";
18import * as Base64 from "effect/encoding/Base64";
19import * as FileSystem from "effect/FileSystem";
20import * as Layer from "effect/Layer";
21import * as Option from "effect/Option";
22import * as Path from "effect/Path";
23import * as Schema from "effect/Schema";
24
25import * as ElectronSafeStorage from "../electron/ElectronSafeStorage.ts";
26import * as DesktopSavedEnvironments from "../settings/DesktopSavedEnvironments.ts";
27import * as DesktopEnvironment from "./DesktopEnvironment.ts";
28
29const EncryptedConnectionCatalogDocument = Schema.Struct({
30 version: Schema.Literal(1),
31 encryptedCatalog: Schema.String,
32});
33type EncryptedConnectionCatalogDocument = typeof EncryptedConnectionCatalogDocument.Type;
34
35const EncryptedConnectionCatalogDocumentJson = fromLenientJson(EncryptedConnectionCatalogDocument);
36const decodeEncryptedConnectionCatalogDocumentJson = Schema.decodeEffect(
37 EncryptedConnectionCatalogDocumentJson,
38);
39const encodeEncryptedConnectionCatalogDocumentJson = Schema.encodeEffect(
40 EncryptedConnectionCatalogDocumentJson,
41);
42const RuntimeConnectionCatalogDocumentJson = Schema.fromJsonString(
43 RuntimeConnectionCatalogDocument,
44);
45const encodeRuntimeConnectionCatalogDocumentJson = Schema.encodeEffect(
46 RuntimeConnectionCatalogDocumentJson,
47);
48
49const DesktopConnectionCatalogStoreWriteOperation = Schema.Literals([
50 "create-temporary-file-name",
51 "encode-document",
52 "create-directory",
53 "write-temporary-file",
54 "replace-catalog-file",
55]);
56
57const DesktopConnectionCatalogStoreMigrationOperation = Schema.Literals([
58 "read-legacy-registry",
59 "read-legacy-secret",
60 "encode-catalog",
61 "persist-catalog",
62]);
63
64const DesktopConnectionCatalogStoreProtectionOperation = Schema.Literals([
65 "check-encryption-availability",
66 "encrypt-catalog",
67 "decrypt-catalog",
68]);
69
70export class DesktopConnectionCatalogStoreWriteError extends Schema.TaggedError<DesktopConnectionCatalogStoreWriteError>()(
71 "DesktopConnectionCatalogStoreWriteError",
72 {
73 operation: DesktopConnectionCatalogStoreWriteOperation,
74 path: Schema.String,
75 cause: Schema.Defect(),
76 },
77) {
78 override get message(): string {
79 return `Desktop connection catalog write failed during ${this.operation} at ${this.path}.`;
80 }
81}
82
83export class DesktopConnectionCatalogStoreDecodeError extends Schema.TaggedError<DesktopConnectionCatalogStoreDecodeError>()(
84 "DesktopConnectionCatalogStoreDecodeError",
85 {
86 resource: Schema.Literal("encryptedCatalog"),
87 catalogPath: Schema.String,
88 cause: Schema.Defect(),
89 },
90) {
91 override get message(): string {
92 return `Failed to decode ${this.resource} for the desktop connection catalog at ${this.catalogPath}.`;
93 }
94}
95
96export class DesktopConnectionCatalogStoreReadError extends Schema.TaggedError<DesktopConnectionCatalogStoreReadError>()(
97 "DesktopConnectionCatalogStoreReadError",
98 {
99 catalogPath: Schema.String,
100 cause: Schema.Defect(),
101 },
102) {
103 override get message(): string {
104 return `Failed to read the desktop connection catalog at ${this.catalogPath}.`;
105 }
106}
107
108export class DesktopConnectionCatalogStoreDocumentDecodeError extends Schema.TaggedError<DesktopConnectionCatalogStoreDocumentDecodeError>()(
109 "DesktopConnectionCatalogStoreDocumentDecodeError",
110 {
111 catalogPath: Schema.String,
112 cause: Schema.Defect(),
113 },
114) {
115 override get message(): string {
116 return `Failed to decode the desktop connection catalog document at ${this.catalogPath}.`;
117 }
118}
119
120export class DesktopConnectionCatalogStoreMigrationError extends Schema.TaggedError<DesktopConnectionCatalogStoreMigrationError>()(
121 "DesktopConnectionCatalogStoreMigrationError",
122 {
123 operation: DesktopConnectionCatalogStoreMigrationOperation,
124 catalogPath: Schema.String,
125 environmentId: Schema.optionalKey(Schema.String),
126 cause: Schema.Defect(),
127 },
128) {
129 override get message(): string {
130 const environment =
131 this.environmentId === undefined ? "" : ` for environment ${this.environmentId}`;
132 return `Legacy desktop saved-environment migration failed during ${this.operation}${environment} into ${this.catalogPath}.`;
133 }
134}
135
136export class DesktopConnectionCatalogStoreProtectionError extends Schema.TaggedError<DesktopConnectionCatalogStoreProtectionError>()(
137 "DesktopConnectionCatalogStoreProtectionError",
138 {
139 operation: DesktopConnectionCatalogStoreProtectionOperation,
140 catalogPath: Schema.String,
141 cause: Schema.Defect(),
142 },
143) {
144 override get message(): string {
145 return `Desktop connection catalog protection failed during ${this.operation} at ${this.catalogPath}.`;
146 }
147}
148
149export class DesktopConnectionCatalogStore extends Context.Service<
150 DesktopConnectionCatalogStore,
151 {
152 readonly get: Effect.Effect<
153 Option.Option<string>,
154 | DesktopConnectionCatalogStoreReadError
155 | DesktopConnectionCatalogStoreDocumentDecodeError
156 | DesktopConnectionCatalogStoreDecodeError
157 | DesktopConnectionCatalogStoreMigrationError
158 | DesktopConnectionCatalogStoreProtectionError
159 >;
160 readonly set: (
161 catalog: string,
162 ) => Effect.Effect<
163 boolean,
164 DesktopConnectionCatalogStoreWriteError | DesktopConnectionCatalogStoreProtectionError
165 >;
166 }
167>()("@t3tools/desktop/app/DesktopConnectionCatalogStore") {}
168
169function decodeSecretBytes(
170 catalogPath: string,
171 encoded: string,
172): Effect.Effect<Uint8Array, DesktopConnectionCatalogStoreDecodeError> {
173 return Effect.fromResult(Base64.decode(encoded)).pipe(
174 Effect.mapError(
175 (cause) =>
176 new DesktopConnectionCatalogStoreDecodeError({
177 resource: "encryptedCatalog",
178 catalogPath,
179 cause,
180 }),
181 ),
182 );
183}
184
185const readDocument = (
186 fileSystem: FileSystem.FileSystem,
187 catalogPath: string,
188): Effect.Effect<
189 Option.Option<EncryptedConnectionCatalogDocument>,
190 DesktopConnectionCatalogStoreReadError | DesktopConnectionCatalogStoreDocumentDecodeError
191> =>
192 fileSystem.readFileString(catalogPath).pipe(
193 Effect.catch((error) =>
194 error.reason._tag === "NotFound"
195 ? Effect.succeed<string | null>(null)
196 : Effect.fail(
197 new DesktopConnectionCatalogStoreReadError({
198 catalogPath,
199 cause: error,
200 }),
201 ),
202 ),
203 Effect.flatMap((raw) =>
204 raw === null
205 ? Effect.succeed(Option.none<EncryptedConnectionCatalogDocument>())
206 : decodeEncryptedConnectionCatalogDocumentJson(raw).pipe(
207 Effect.asSome,
208 Effect.mapError(
209 (cause) =>
210 new DesktopConnectionCatalogStoreDocumentDecodeError({
211 catalogPath,
212 cause,
213 }),
214 ),
215 ),
216 ),
217 );
218
219const writeDocument = Effect.fn("desktop.connectionCatalogStore.writeDocument")(function* (input: {
220 readonly fileSystem: FileSystem.FileSystem;
221 readonly path: Path.Path;
222 readonly catalogPath: string;
223 readonly document: EncryptedConnectionCatalogDocument;
224 readonly suffix: string;
225}): Effect.fn.Return<void, DesktopConnectionCatalogStoreWriteError> {
226 const directory = input.path.dirname(input.catalogPath);
227 const tempPath = `${input.catalogPath}.${process.pid}.${input.suffix}.tmp`;
228 const encoded = yield* encodeEncryptedConnectionCatalogDocumentJson(input.document).pipe(
229 Effect.mapError(
230 (cause) =>
231 new DesktopConnectionCatalogStoreWriteError({
232 operation: "encode-document",
233 path: input.catalogPath,
234 cause,
235 }),
236 ),
237 );
238 yield* input.fileSystem.makeDirectory(directory, { recursive: true }).pipe(
239 Effect.mapError(
240 (cause) =>
241 new DesktopConnectionCatalogStoreWriteError({
242 operation: "create-directory",
243 path: directory,
244 cause,
245 }),
246 ),
247 );
248 yield* Effect.gen(function* () {
249 yield* input.fileSystem.writeFileString(tempPath, `${encoded}\n`).pipe(
250 Effect.mapError(
251 (cause) =>
252 new DesktopConnectionCatalogStoreWriteError({
253 operation: "write-temporary-file",
254 path: tempPath,
255 cause,
256 }),
257 ),
258 );
259 yield* input.fileSystem.rename(tempPath, input.catalogPath).pipe(
260 Effect.mapError(
261 (cause) =>
262 new DesktopConnectionCatalogStoreWriteError({
263 operation: "replace-catalog-file",
264 path: input.catalogPath,
265 cause,
266 }),
267 ),
268 );
269 }).pipe(
270 Effect.ensuring(
271 input.fileSystem.remove(tempPath, { force: true }).pipe(
272 Effect.catch((error) =>
273 Effect.logWarning("Could not remove a temporary connection catalog file.", {
274 tempPath,
275 error,
276 }),
277 ),
278 ),
279 ),
280 );
281});
282
283function connectionId(prefix: "bearer" | "ssh", environmentId: string): string {
284 return `${prefix}:${environmentId}`;
285}
286
287const migrateSavedEnvironmentRecords = Effect.fn(
288 "desktop.connectionCatalogStore.migrateSavedEnvironmentRecords",
289)(function* (
290 records: readonly PersistedSavedEnvironmentRecord[],
291 savedEnvironments: DesktopSavedEnvironments.DesktopSavedEnvironments["Service"],
292 catalogPath: string,
293): Effect.fn.Return<
294 RuntimeConnectionCatalogDocumentType,
295 DesktopConnectionCatalogStoreMigrationError
296> {
297 const targets: Array<RuntimeConnectionCatalogDocumentType["targets"][number]> = [];
298 const profiles: Array<RuntimeConnectionCatalogDocumentType["profiles"][number]> = [];
299 const credentials: Array<RuntimeConnectionCatalogDocumentType["credentials"][number]> = [];
300
301 for (const record of records) {
302 if (record.relayManaged !== undefined) {
303 targets.push(
304 new RelayConnectionTarget({
305 environmentId: record.environmentId,
306 label: record.label,
307 }),
308 );
309 continue;
310 }
311
312 if (record.desktopSsh !== undefined) {
313 const id = connectionId("ssh", record.environmentId);
314 targets.push(
315 new SshConnectionTarget({
316 environmentId: record.environmentId,
317 label: record.label,
318 connectionId: id,
319 }),
320 );
321 profiles.push(
322 new SshConnectionProfile({
323 connectionId: id,
324 environmentId: record.environmentId,
325 label: record.label,
326 target: record.desktopSsh,
327 }),
328 );
329 continue;
330 }
331
332 const id = connectionId("bearer", record.environmentId);
333 targets.push(
334 new BearerConnectionTarget({
335 environmentId: record.environmentId,
336 label: record.label,
337 connectionId: id,
338 }),
339 );
340 profiles.push(
341 new BearerConnectionProfile({
342 connectionId: id,
343 environmentId: record.environmentId,
344 label: record.label,
345 httpBaseUrl: record.httpBaseUrl,
346 wsBaseUrl: record.wsBaseUrl,
347 }),
348 );
349 const token = yield* savedEnvironments.getSecret(record.environmentId).pipe(
350 Effect.mapError(
351 (cause) =>
352 new DesktopConnectionCatalogStoreMigrationError({
353 operation: "read-legacy-secret",
354 catalogPath,
355 environmentId: record.environmentId,
356 cause,
357 }),
358 ),
359 );
360 if (Option.isSome(token)) {
361 credentials.push({
362 connectionId: id,
363 credential: new BearerConnectionCredential({ token: token.value }),
364 });
365 }
366 }
367
368 return {
369 schemaVersion: 1,
370 targets,
371 profiles,
372 credentials,
373 remoteDpopTokens: [],
374 disabledEnvironmentIds: [],
375 };
376});
377
378/** @public */
379export const make = Effect.gen(function* () {
380 const environment = yield* DesktopEnvironment.DesktopEnvironment;
381 const fileSystem = yield* FileSystem.FileSystem;
382 const path = yield* Path.Path;
383 const safeStorage = yield* ElectronSafeStorage.ElectronSafeStorage;
384 const random = yield* SecureRandom.SecureRandom;
385 const savedEnvironments = yield* DesktopSavedEnvironments.DesktopSavedEnvironments;
386 const catalogPath = path.join(environment.stateDir, "connection-catalog.json");
387 const encryptionAvailable = safeStorage.isEncryptionAvailable.pipe(
388 Effect.mapError(
389 (cause) =>
390 new DesktopConnectionCatalogStoreProtectionError({
391 operation: "check-encryption-availability",
392 catalogPath,
393 cause,
394 }),
395 ),
396 );
397
398 const writeCatalog = Effect.fn("desktop.connectionCatalogStore.writeCatalog")(function* (
399 catalog: string,
400 ) {
401 const encryptedCatalog = Base64.encode(
402 yield* safeStorage.encryptString(catalog).pipe(
403 Effect.mapError(
404 (cause) =>
405 new DesktopConnectionCatalogStoreProtectionError({
406 operation: "encrypt-catalog",
407 catalogPath,
408 cause,
409 }),
410 ),
411 ),
412 );
413 const suffix = (yield* random.uuidV4()).replace(/-/g, "");
414 yield* writeDocument({
415 fileSystem,
416 path,
417 catalogPath,
418 document: { version: 1, encryptedCatalog },
419 suffix,
420 });
421 });
422
423 const migrateLegacyCatalog = Effect.gen(function* () {
424 if (!(yield* encryptionAvailable)) {
425 return Option.none<string>();
426 }
427 const records = yield* savedEnvironments.getRegistry.pipe(
428 Effect.mapError(
429 (cause) =>
430 new DesktopConnectionCatalogStoreMigrationError({
431 operation: "read-legacy-registry",
432 catalogPath,
433 cause,
434 }),
435 ),
436 );
437 if (records.length === 0) {
438 return Option.none<string>();
439 }
440 const catalog = yield* migrateSavedEnvironmentRecords(records, savedEnvironments, catalogPath);
441 const encoded = yield* encodeRuntimeConnectionCatalogDocumentJson(catalog).pipe(
442 Effect.mapError(
443 (cause) =>
444 new DesktopConnectionCatalogStoreMigrationError({
445 operation: "encode-catalog",
446 catalogPath,
447 cause,
448 }),
449 ),
450 );
451 yield* writeCatalog(encoded).pipe(
452 Effect.mapError(
453 (cause) =>
454 new DesktopConnectionCatalogStoreMigrationError({
455 operation: "persist-catalog",
456 catalogPath,
457 cause,
458 }),
459 ),
460 );
461 return Option.some(encoded);
462 });
463
464 return DesktopConnectionCatalogStore.of({
465 get: Effect.gen(function* () {
466 const document = yield* readDocument(fileSystem, catalogPath);
467 if (Option.isNone(document)) {
468 return yield* migrateLegacyCatalog;
469 }
470 if (!(yield* encryptionAvailable)) {
471 return Option.none<string>();
472 }
473 const decrypted = yield* decodeSecretBytes(catalogPath, document.value.encryptedCatalog).pipe(
474 Effect.flatMap((encryptedCatalog) =>
475 safeStorage.decryptString(encryptedCatalog).pipe(
476 Effect.mapError(
477 (cause) =>
478 new DesktopConnectionCatalogStoreProtectionError({
479 operation: "decrypt-catalog",
480 catalogPath,
481 cause,
482 }),
483 ),
484 ),
485 ),
486 );
487 return Option.some(decrypted);
488 }).pipe(Effect.withSpan("desktop.connectionCatalogStore.get")),
489 set: Effect.fn("desktop.connectionCatalogStore.set")(function* (catalog) {
490 if (!(yield* encryptionAvailable)) {
491 return false;
492 }
493 yield* writeCatalog(catalog);
494 return true;
495 }),
496 });
497});
498
499export const layer = Layer.effect(DesktopConnectionCatalogStore, make);