[codex] refactor desktop Electron Effect services

apps/desktop/src/app/DesktopConnectionCatalogStore.test.ts

@@ -237,7 +237,6 @@ describe("DesktopConnectionCatalogStore", () => {
           error,
           DesktopConnectionCatalogStore.DesktopConnectionCatalogStoreDocumentDecodeError,
         );
-        assert.equal(error.operation, "decode-catalog-document");
         assert.equal(error.catalogPath, catalogPath);
         assert.exists(error.cause);
         assert.equal(yield* fileSystem.readFileString(catalogPath), "{not-json");
@@ -272,7 +271,6 @@ describe("DesktopConnectionCatalogStore", () => {
         error,
         DesktopConnectionCatalogStore.DesktopConnectionCatalogStoreReadError,
       );
-      assert.equal(error.operation, "read-catalog");
       assert.equal(error.catalogPath, `${baseDir}/userdata/connection-catalog.json`);
       assert.strictEqual(error.cause, permissionError);
       assert.equal(
@@ -368,7 +366,6 @@ describe("DesktopConnectionCatalogStore", () => {
           error,
           DesktopConnectionCatalogStore.DesktopConnectionCatalogStoreDecodeError,
         );
-        assert.equal(error.operation, "decode-encrypted-catalog");
         assert.equal(error.resource, "encryptedCatalog");
         assert.equal(error.catalogPath, catalogPath);
         assert.exists(error.cause);

apps/desktop/src/app/DesktopConnectionCatalogStore.ts

@@ -92,7 +92,6 @@ const writeError = (
 export class DesktopConnectionCatalogStoreDecodeError extends Schema.TaggedErrorClass<DesktopConnectionCatalogStoreDecodeError>()(
   "DesktopConnectionCatalogStoreDecodeError",
   {
-    operation: Schema.Literal("decode-encrypted-catalog"),
     resource: Schema.Literal("encryptedCatalog"),
     catalogPath: Schema.String,
     cause: Schema.Defect(),
@@ -106,7 +105,6 @@ export class DesktopConnectionCatalogStoreDecodeError extends Schema.TaggedError
 export class DesktopConnectionCatalogStoreReadError extends Schema.TaggedErrorClass<DesktopConnectionCatalogStoreReadError>()(
   "DesktopConnectionCatalogStoreReadError",
   {
-    operation: Schema.Literal("read-catalog"),
     catalogPath: Schema.String,
     cause: Schema.Defect(),
   },
@@ -119,7 +117,6 @@ export class DesktopConnectionCatalogStoreReadError extends Schema.TaggedErrorCl
 export class DesktopConnectionCatalogStoreDocumentDecodeError extends Schema.TaggedErrorClass<DesktopConnectionCatalogStoreDocumentDecodeError>()(
   "DesktopConnectionCatalogStoreDocumentDecodeError",
   {
-    operation: Schema.Literal("decode-catalog-document"),
     catalogPath: Schema.String,
     cause: Schema.Defect(),
   },
@@ -167,16 +164,13 @@ export class DesktopConnectionCatalogStore extends Context.Service<
       | DesktopConnectionCatalogStoreDocumentDecodeError
       | DesktopConnectionCatalogStoreDecodeError
       | DesktopConnectionCatalogStoreMigrationError
-      | ElectronSafeStorage.ElectronSafeStorageAvailabilityError
-      | ElectronSafeStorage.ElectronSafeStorageDecryptError
+      | ElectronSafeStorage.ElectronSafeStorageError
     >;
     readonly set: (
       catalog: string,
     ) => Effect.Effect<
       boolean,
-      | DesktopConnectionCatalogStoreWriteError
-      | ElectronSafeStorage.ElectronSafeStorageAvailabilityError
-      | ElectronSafeStorage.ElectronSafeStorageEncryptError
+      DesktopConnectionCatalogStoreWriteError | ElectronSafeStorage.ElectronSafeStorageError
     >;
     readonly clear: Effect.Effect<void>;
   }
@@ -190,7 +184,6 @@ function decodeSecretBytes(
     Effect.mapError(
       (cause) =>
         new DesktopConnectionCatalogStoreDecodeError({
-          operation: "decode-encrypted-catalog",
           resource: "encryptedCatalog",
           catalogPath,
           cause,
@@ -212,7 +205,6 @@ const readDocument = (
         ? Effect.succeed<string | null>(null)
         : Effect.fail(
             new DesktopConnectionCatalogStoreReadError({
-              operation: "read-catalog",
               catalogPath,
               cause: error,
             }),
@@ -226,7 +218,6 @@ const readDocument = (
             Effect.mapError(
               (cause) =>
                 new DesktopConnectionCatalogStoreDocumentDecodeError({
-                  operation: "decode-catalog-document",
                   catalogPath,
                   cause,
                 }),

apps/desktop/src/app/DesktopLifecycle.ts

@@ -8,7 +8,7 @@ import * as Scope from "effect/Scope";
 import type * as Electron from "electron";
 
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
-import * as DesktopObservability from "./DesktopObservability.ts";
+import { makeComponentLogger } from "./DesktopObservability.ts";
 import * as DesktopShutdown from "./DesktopShutdown.ts";
 import * as ElectronApp from "../electron/ElectronApp.ts";
 import * as ElectronTheme from "../electron/ElectronTheme.ts";
@@ -37,7 +37,7 @@ export class DesktopLifecycle extends Context.Service<
 >()("@t3tools/desktop/app/DesktopLifecycle") {}
 
 const { logInfo: logLifecycleInfo, logError: logLifecycleError } =
-  DesktopObservability.makeComponentLogger("desktop-lifecycle");
+  makeComponentLogger("desktop-lifecycle");
 
 function addScopedListener<Args extends ReadonlyArray<unknown>>(
   target: unknown,
@@ -122,7 +122,7 @@ function quitFromSignal(
   );
 }
 
-const make = DesktopLifecycle.of({
+export const make = DesktopLifecycle.of({
   relaunch: Effect.fn("desktop.lifecycle.relaunch")(function* (reason) {
     const electronApp = yield* ElectronApp.ElectronApp;
     const environment = yield* DesktopEnvironment.DesktopEnvironment;

apps/desktop/src/electron/ElectronApp.ts

@@ -13,41 +13,40 @@ export interface ElectronAppMetadata {
   readonly runningUnderArm64Translation: boolean;
 }
 
-export interface ElectronAppShape {
-  readonly metadata: Effect.Effect<ElectronAppMetadata>;
-  readonly name: Effect.Effect<string>;
-  readonly whenReady: Effect.Effect<void>;
-  readonly quit: Effect.Effect<void>;
-  readonly exit: (code: number) => Effect.Effect<void>;
-  readonly relaunch: (options: Electron.RelaunchOptions) => Effect.Effect<void>;
-  readonly setPath: (
-    name: Parameters<Electron.App["setPath"]>[0],
-    path: string,
-  ) => Effect.Effect<void>;
-  readonly setName: (name: string) => Effect.Effect<void>;
-  readonly setAboutPanelOptions: (
-    options: Electron.AboutPanelOptionsOptions,
-  ) => Effect.Effect<void>;
-  readonly setAppUserModelId: (id: string) => Effect.Effect<void>;
-  readonly requestSingleInstanceLock: Effect.Effect<boolean>;
-  readonly isDefaultProtocolClient: (protocol: string) => Effect.Effect<boolean>;
-  readonly setAsDefaultProtocolClient: (
-    protocol: string,
-    path?: string,
-    args?: readonly string[],
-  ) => Effect.Effect<boolean>;
-  readonly setDesktopName: (desktopName: string) => Effect.Effect<void>;
-  readonly setDockIcon: (iconPath: string) => Effect.Effect<void>;
-  readonly appendCommandLineSwitch: (switchName: string, value?: string) => Effect.Effect<void>;
-  readonly on: <Args extends ReadonlyArray<unknown>>(
-    eventName: string,
-    listener: (...args: Args) => void,
-  ) => Effect.Effect<void, never, Scope.Scope>;
-}
-
-export class ElectronApp extends Context.Service<ElectronApp, ElectronAppShape>()(
-  "@t3tools/desktop/electron/ElectronApp",
-) {}
+export class ElectronApp extends Context.Service<
+  ElectronApp,
+  {
+    readonly metadata: Effect.Effect<ElectronAppMetadata>;
+    readonly name: Effect.Effect<string>;
+    readonly whenReady: Effect.Effect<void>;
+    readonly quit: Effect.Effect<void>;
+    readonly exit: (code: number) => Effect.Effect<void>;
+    readonly relaunch: (options: Electron.RelaunchOptions) => Effect.Effect<void>;
+    readonly setPath: (
+      name: Parameters<Electron.App["setPath"]>[0],
+      path: string,
+    ) => Effect.Effect<void>;
+    readonly setName: (name: string) => Effect.Effect<void>;
+    readonly setAboutPanelOptions: (
+      options: Electron.AboutPanelOptionsOptions,
+    ) => Effect.Effect<void>;
+    readonly setAppUserModelId: (id: string) => Effect.Effect<void>;
+    readonly requestSingleInstanceLock: Effect.Effect<boolean>;
+    readonly isDefaultProtocolClient: (protocol: string) => Effect.Effect<boolean>;
+    readonly setAsDefaultProtocolClient: (
+      protocol: string,
+      path?: string,
+      args?: readonly string[],
+    ) => Effect.Effect<boolean>;
+    readonly setDesktopName: (desktopName: string) => Effect.Effect<void>;
+    readonly setDockIcon: (iconPath: string) => Effect.Effect<void>;
+    readonly appendCommandLineSwitch: (switchName: string, value?: string) => Effect.Effect<void>;
+    readonly on: <Args extends ReadonlyArray<unknown>>(
+      eventName: string,
+      listener: (...args: Args) => void,
+    ) => Effect.Effect<void, never, Scope.Scope>;
+  }
+>()("@t3tools/desktop/electron/ElectronApp") {}
 
 const addScopedAppListener = <Args extends ReadonlyArray<unknown>>(
   eventName: string,
@@ -63,7 +62,7 @@ const addScopedAppListener = <Args extends ReadonlyArray<unknown>>(
       }),
   ).pipe(Effect.asVoid);
 
-const make = ElectronApp.of({
+export const make = ElectronApp.of({
   metadata: Effect.sync(() => ({
     appVersion: Electron.app.getVersion(),
     appPath: Electron.app.getAppPath(),

apps/desktop/src/electron/ElectronDialog.ts

@@ -17,22 +17,21 @@ export interface ElectronDialogConfirmInput {
   readonly message: string;
 }
 
-export interface ElectronDialogShape {
-  readonly pickFolder: (
-    input: ElectronDialogPickFolderInput,
-  ) => Effect.Effect<Option.Option<string>>;
-  readonly confirm: (input: ElectronDialogConfirmInput) => Effect.Effect<boolean>;
-  readonly showMessageBox: (
-    options: Electron.MessageBoxOptions,
-  ) => Effect.Effect<Electron.MessageBoxReturnValue>;
-  readonly showErrorBox: (title: string, content: string) => Effect.Effect<void>;
-}
-
-export class ElectronDialog extends Context.Service<ElectronDialog, ElectronDialogShape>()(
-  "@t3tools/desktop/electron/ElectronDialog",
-) {}
+export class ElectronDialog extends Context.Service<
+  ElectronDialog,
+  {
+    readonly pickFolder: (
+      input: ElectronDialogPickFolderInput,
+    ) => Effect.Effect<Option.Option<string>>;
+    readonly confirm: (input: ElectronDialogConfirmInput) => Effect.Effect<boolean>;
+    readonly showMessageBox: (
+      options: Electron.MessageBoxOptions,
+    ) => Effect.Effect<Electron.MessageBoxReturnValue>;
+    readonly showErrorBox: (title: string, content: string) => Effect.Effect<void>;
+  }
+>()("@t3tools/desktop/electron/ElectronDialog") {}
 
-const make = ElectronDialog.of({
+export const make = ElectronDialog.of({
   pickFolder: Effect.fn("desktop.electron.dialog.pickFolder")(function* (input) {
     const openDialogOptions: Electron.OpenDialogOptions = Option.match(input.defaultPath, {
       onNone: () => ({