[codex] refactor desktop Electron Effect services (#3178)

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

@@ -4,6 +4,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as PlatformError from "effect/PlatformError";
 
 import type * as Electron from "electron";
 
@@ -105,6 +106,7 @@ const withIdentity = <A, E, R>(
     readonly calls?: ElectronAppCalls;
     readonly environment?: TestEnvironmentInput;
     readonly legacyPathExists?: boolean;
+    readonly legacyPathProbeError?: PlatformError.PlatformError;
     readonly packageJson?: string;
     readonly pngIconPath?: Option.Option<string>;
   } = {},
@@ -121,7 +123,11 @@ const withIdentity = <A, E, R>(
         Layer.provideMerge(
           FileSystem.layerNoop({
             exists: (path) =>
-              Effect.succeed(input.legacyPathExists === true && path.includes("T3 Code (Alpha)")),
+              input.legacyPathProbeError
+                ? Effect.fail(input.legacyPathProbeError)
+                : Effect.succeed(
+                    input.legacyPathExists === true && path.includes("T3 Code (Alpha)"),
+                  ),
             readFileString: () =>
               Effect.succeed(input.packageJson ?? '{"t3codeCommitHash":"abcdef1234567890"}'),
           }),
@@ -147,6 +153,33 @@ describe("DesktopAppIdentity", () => {
     ),
   );
 
+  it.effect("preserves failures while inspecting the legacy userData path", () => {
+    const legacyPath = "/Users/alice/Library/Application Support/T3 Code (Alpha)";
+    const cause = PlatformError.systemError({
+      _tag: "PermissionDenied",
+      module: "FileSystem",
+      method: "exists",
+      description: "permission denied",
+      pathOrDescriptor: legacyPath,
+    });
+
+    return withIdentity(
+      Effect.gen(function* () {
+        const identity = yield* DesktopAppIdentity.DesktopAppIdentity;
+        const error = yield* identity.resolveUserDataPath.pipe(Effect.flip);
+
+        assert.instanceOf(error, DesktopAppIdentity.DesktopUserDataPathResolutionError);
+        assert.equal(error.legacyPath, legacyPath);
+        assert.strictEqual(error.cause, cause);
+        assert.equal(
+          error.message,
+          `Failed to inspect legacy desktop user-data path at "${legacyPath}".`,
+        );
+      }),
+      { legacyPathProbeError: cause },
+    );
+  });
+
   it.effect("configures app identity from the environment commit override", () => {
     const calls: ElectronAppCalls = {
       setAboutPanelOptions: [],

apps/desktop/src/app/DesktopAppIdentity.ts

@@ -18,10 +18,22 @@ const AppPackageMetadata = Schema.Struct({
 });
 const decodeAppPackageMetadata = Schema.decodeEffect(Schema.fromJsonString(AppPackageMetadata));
 
+export class DesktopUserDataPathResolutionError extends Schema.TaggedErrorClass<DesktopUserDataPathResolutionError>()(
+  "DesktopUserDataPathResolutionError",
+  {
+    legacyPath: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return `Failed to inspect legacy desktop user-data path at "${this.legacyPath}".`;
+  }
+}
+
 export class DesktopAppIdentity extends Context.Service<
   DesktopAppIdentity,
   {
-    readonly resolveUserDataPath: Effect.Effect<string>;
+    readonly resolveUserDataPath: Effect.Effect<string, DesktopUserDataPathResolutionError>;
     readonly configure: Effect.Effect<void>;
   }
 >()("@t3tools/desktop/app/DesktopAppIdentity") {}
@@ -33,7 +45,7 @@ const normalizeCommitHash = (value: string): Option.Option<string> => {
     : Option.none();
 };
 
-const make = Effect.gen(function* () {
+export const make = Effect.gen(function* () {
   const assets = yield* DesktopAssets.DesktopAssets;
   const electronApp = yield* ElectronApp.ElectronApp;
   const environment = yield* DesktopEnvironment.DesktopEnvironment;
@@ -83,9 +95,15 @@ const make = Effect.gen(function* () {
       environment.appDataDirectory,
       environment.legacyUserDataDirName,
     );
-    const legacyPathExists = yield* fileSystem
-      .exists(legacyPath)
-      .pipe(Effect.orElseSucceed(() => false));
+    const legacyPathExists = yield* fileSystem.exists(legacyPath).pipe(
+      Effect.mapError(
+        (cause) =>
+          new DesktopUserDataPathResolutionError({
+            legacyPath,
+            cause,
+          }),
+      ),
+    );
     return legacyPathExists
       ? legacyPath
       : environment.path.join(environment.appDataDirectory, environment.userDataDirName);

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

@@ -0,0 +1,57 @@
+import * as NodeServices from "@effect/platform-node/NodeServices";
+import { assert, describe, it } from "@effect/vitest";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as PlatformError from "effect/PlatformError";
+
+import * as DesktopAssets from "./DesktopAssets.ts";
+import * as DesktopConfig from "./DesktopConfig.ts";
+import * as DesktopEnvironment from "./DesktopEnvironment.ts";
+
+const environmentLayer = DesktopEnvironment.layer({
+  dirname: "/repo/apps/desktop/dist-electron",
+  homeDirectory: "/Users/alice",
+  platform: "darwin",
+  processArch: "arm64",
+  appVersion: "1.2.3",
+  appPath: "/Applications/T3 Code.app/Contents/Resources/app.asar",
+  isPackaged: true,
+  resourcesPath: "/Applications/T3 Code.app/Contents/Resources",
+  runningUnderArm64Translation: false,
+}).pipe(Layer.provide(Layer.mergeAll(NodeServices.layer, DesktopConfig.layerTest({}))));
+
+describe("DesktopAssets", () => {
+  it.effect("preserves the failed asset candidate and filesystem cause", () =>
+    Effect.gen(function* () {
+      const fileName = "custom.bin";
+      const candidatePath = "/repo/apps/desktop/resources/custom.bin";
+      const cause = PlatformError.systemError({
+        _tag: "PermissionDenied",
+        module: "FileSystem",
+        method: "exists",
+        pathOrDescriptor: candidatePath,
+        description: "private filesystem diagnostic",
+      });
+      const fileSystemLayer = FileSystem.layerNoop({
+        exists: (path) => (path === candidatePath ? Effect.fail(cause) : Effect.succeed(false)),
+      });
+      const assetsLayer = DesktopAssets.layer.pipe(
+        Layer.provide(Layer.merge(fileSystemLayer, environmentLayer)),
+      );
+      const assets = yield* DesktopAssets.DesktopAssets.pipe(Effect.provide(assetsLayer));
+
+      const error = yield* assets.resolveResourcePath(fileName).pipe(Effect.flip);
+
+      assert.instanceOf(error, DesktopAssets.DesktopAssetProbeError);
+      assert.equal(error.fileName, fileName);
+      assert.equal(error.candidatePath, candidatePath);
+      assert.strictEqual(error.cause, cause);
+      assert.equal(
+        error.message,
+        `Failed to probe desktop asset "${fileName}" at ${candidatePath}.`,
+      );
+      assert.notInclude(error.message, "private filesystem diagnostic");
+    }),
+  );
+});

apps/desktop/src/app/DesktopAssets.ts

@@ -3,6 +3,7 @@ import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
 
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
 
@@ -12,26 +13,47 @@ export interface DesktopIconPaths {
   readonly png: Option.Option<string>;
 }
 
+export class DesktopAssetProbeError extends Schema.TaggedErrorClass<DesktopAssetProbeError>()(
+  "DesktopAssetProbeError",
+  {
+    fileName: Schema.String,
+    candidatePath: Schema.String,
+    cause: Schema.Defect(),
+  },
+) {
+  override get message(): string {
+    return `Failed to probe desktop asset "${this.fileName}" at ${this.candidatePath}.`;
+  }
+}
+
 export class DesktopAssets extends Context.Service<
   DesktopAssets,
   {
     readonly iconPaths: Effect.Effect<DesktopIconPaths>;
-    readonly resolveResourcePath: (fileName: string) => Effect.Effect<Option.Option<string>>;
+    readonly resolveResourcePath: (
+      fileName: string,
+    ) => Effect.Effect<Option.Option<string>, DesktopAssetProbeError>;
   }
 >()("@t3tools/desktop/app/DesktopAssets") {}
 
 const resolveResourcePath = Effect.fn("desktop.assets.resolveResourcePath")(function* (
   fileName: string,
 ): Effect.fn.Return<
   Option.Option<string>,
-  never,
+  DesktopAssetProbeError,
   FileSystem.FileSystem | DesktopEnvironment.DesktopEnvironment
 > {
   const fileSystem = yield* FileSystem.FileSystem;
   const environment = yield* DesktopEnvironment.DesktopEnvironment;
   const candidates = environment.resolveResourcePathCandidates(fileName);
   for (const candidate of candidates) {
-    const exists = yield* fileSystem.exists(candidate).pipe(Effect.orElseSucceed(() => false));
+    const exists = yield* fileSystem
+      .exists(candidate)
+      .pipe(
+        Effect.mapError(
+          (cause) => new DesktopAssetProbeError({ fileName, candidatePath: candidate, cause }),
+        ),
+      );
     if (exists) {
       return Option.some(candidate);
     }
@@ -43,16 +65,23 @@ const resolveIconPath = Effect.fn("desktop.assets.resolveIconPath")(function* (
   ext: keyof DesktopIconPaths,
 ): Effect.fn.Return<
   Option.Option<string>,
-  never,
+  DesktopAssetProbeError,
   FileSystem.FileSystem | DesktopEnvironment.DesktopEnvironment
 > {
   const fileSystem = yield* FileSystem.FileSystem;
   const environment = yield* DesktopEnvironment.DesktopEnvironment;
   if (environment.isDevelopment && environment.platform === "darwin" && ext === "png") {
     const developmentDockIconPath = environment.developmentDockIconPath;
-    const developmentDockIconExists = yield* fileSystem
-      .exists(developmentDockIconPath)
-      .pipe(Effect.orElseSucceed(() => false));
+    const developmentDockIconExists = yield* fileSystem.exists(developmentDockIconPath).pipe(
+      Effect.mapError(
+        (cause) =>
+          new DesktopAssetProbeError({
+            fileName: "icon.png",
+            candidatePath: developmentDockIconPath,
+            cause,
+          }),
+      ),
+    );
     if (developmentDockIconExists) {
       return Option.some(developmentDockIconPath);
     }
@@ -61,7 +90,7 @@ const resolveIconPath = Effect.fn("desktop.assets.resolveIconPath")(function* (
   return yield* resolveResourcePath(`icon.${ext}`);
 });
 
-const make = Effect.gen(function* () {
+export const make = Effect.gen(function* () {
   const context = yield* Effect.context<
     FileSystem.FileSystem | DesktopEnvironment.DesktopEnvironment
   >();

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

@@ -1,7 +1,8 @@
 import { assert, describe, it } from "@effect/vitest";
+import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { vi } from "vite-plus/test";
+import { beforeEach, vi } from "vite-plus/test";
 
 const { createClerkBridgeMock, storageAdapter, storageMock } = vi.hoisted(() => ({
   createClerkBridgeMock: vi.fn(),
@@ -24,7 +25,23 @@ vi.mock("@clerk/electron/storage", () => ({
 import * as DesktopClerk from "./DesktopClerk.ts";
 import * as DesktopEnvironment from "./DesktopEnvironment.ts";
 
+const makeDesktopClerkLayer = (isDevelopment = true) => {
+  const environment = DesktopEnvironment.DesktopEnvironment.of({
+    stateDir: "/tmp/t3-state",
+    isDevelopment,
+  } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]);
+
+  return DesktopClerk.layer.pipe(
+    Layer.provide(Layer.succeed(DesktopEnvironment.DesktopEnvironment, environment)),
+  );
+};
+
 describe("DesktopClerk", () => {
+  beforeEach(() => {
+    createClerkBridgeMock.mockReset();
+    storageMock.mockReset();
+  });
+
   it("derives the Clerk Frontend API hostname used by the desktop CSP", () => {
     const publishableKey = `pk_test_${btoa("clerk.t3.codes$")}`;
 
@@ -40,19 +57,9 @@ describe("DesktopClerk", () => {
     const cleanup = vi.fn();
     storageMock.mockReturnValue(storageAdapter);
     createClerkBridgeMock.mockReturnValue({ cleanup });
-    const environment = DesktopEnvironment.DesktopEnvironment.of({
-      stateDir: "/tmp/t3-state",
-      isDevelopment: true,
-    } as unknown as DesktopEnvironment.DesktopEnvironment["Service"]);
 
     return Effect.gen(function* () {
-      yield* Effect.scoped(
-        Layer.build(
-          DesktopClerk.layer.pipe(
-            Layer.provide(Layer.succeed(DesktopEnvironment.DesktopEnvironment, environment)),
-          ),
-        ),
-      );
+      yield* Effect.scoped(Layer.build(makeDesktopClerkLayer()));
 
       assert.deepEqual(createClerkBridgeMock.mock.calls, [
         [
@@ -69,6 +76,54 @@ describe("DesktopClerk", () => {
     });
   });
 
+  it.effect("preserves bridge initialization failures", () => {
+    const cause = new Error("bridge initialization failed");
+    storageMock.mockReturnValue(storageAdapter);
+    createClerkBridgeMock.mockImplementationOnce(() => {
+      throw cause;
+    });
+
+    return Effect.gen(function* () {
+      const error = yield* Effect.scoped(Layer.build(makeDesktopClerkLayer())).pipe(Effect.flip);
+
+      assert.instanceOf(error, DesktopClerk.DesktopClerkBridgeInitializationError);
+      assert.equal(error.stateDir, "/tmp/t3-state");
+      assert.equal(error.isDevelopment, true);
+      assert.strictEqual(error.cause, cause);
+      assert.equal(
+        error.message,
+        'Failed to initialize the desktop Clerk bridge for state directory "/tmp/t3-state" (development: true).',
+      );
+    });
+  });
+
+  it.effect("preserves bridge cleanup failures", () => {
+    const cause = new Error("bridge cleanup failed");
+    storageMock.mockReturnValue(storageAdapter);
+    createClerkBridgeMock.mockReturnValue({
+      cleanup: () => {
+        throw cause;
+      },
+    });
+
+    return Effect.gen(function* () {
+      const exit = yield* Effect.exit(Effect.scoped(Layer.build(makeDesktopClerkLayer(false))));
+
+      assert.equal(exit._tag, "Failure");
+      if (exit._tag === "Failure") {
+        const error = Cause.squash(exit.cause);
+        assert.instanceOf(error, DesktopClerk.DesktopClerkBridgeCleanupError);
+        assert.equal(error.stateDir, "/tmp/t3-state");
+        assert.equal(error.isDevelopment, false);
+        assert.strictEqual(error.cause, cause);
+        assert.equal(
+          error.message,
+          'Failed to clean up the desktop Clerk bridge for state directory "/tmp/t3-state" (development: false).',
+        );
+      }
+    });
+  });
+
   it.each([
     { isDevelopment: true, scheme: "t3code-dev" },
     { isDevelopment: false, scheme: "t3code" },