[codex] Preserve desktop asset probe failures

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
   >();