Commit 3ee2e1011dcff6dc46f5a1e0610d6265fb485702 | the-knife

author	Julius Marminge <julius0216@outlook.com> 2026-02-25 22:50:25-08:00
committer	Julius Marminge <jmarminge@gmail.com> 2026-02-26 13:20:36-08:00
log	3ee2e1011dcff6dc46f5a1e0610d6265fb485702
tree	dce7784650d0ef6705776dd889693ac852c9e0ee
parent	e5542b7a880aa40ab5a4b5ad8012822c11643471

effect native open service

2 files changed, 82 insertions(+), 55 deletions(-)

apps
- server
  - src
    open.test.ts
    open.ts

apps/server/src/open.test.ts+61-33

 @@ -1,45 +1,73 @@
-import { describe, expect, it } from "vitest";
+import { assert, describe, it } from "@effect/vitest";
 import { launchDetached, resolveEditorLaunch } from "./open";
+import { Effect } from "effect";
+import { assertSuccess } from "@effect/vitest/utils";
 describe("resolveEditorLaunch", () => {
-  it("returns cursor command for cursor editor", () => {
+  it.effect("returns cursor command for cursor editor", () =>
-    expect(resolveEditorLaunch({ cwd: "/tmp/workspace", editor: "cursor" }, "darwin")).toEqual({
+    Effect.gen(function* () {
-      command: "cursor",
+      const launch = yield* resolveEditorLaunch(
-      args: ["/tmp/workspace"],
+        { cwd: "/tmp/workspace", editor: "cursor" },
-    });
+        "darwin",
-  });
+      );
+      assert.deepEqual(launch, {
+        command: "cursor",
+        args: ["/tmp/workspace"],
+      });
+    }),
+  );
+  it.effect("maps file-manager editor to OS open commands", () =>
+    Effect.gen(function* () {
+      const launch1 = yield* resolveEditorLaunch(
+        { cwd: "/tmp/workspace", editor: "file-manager" },
+        "darwin",
+      );
+      assert.deepEqual(launch1, {
+        command: "open",
+        args: ["/tmp/workspace"],
+      });
+      const launch2 = yield* resolveEditorLaunch(
+        { cwd: "C:\\workspace", editor: "file-manager" },
+        "win32",
+      );
+      assert.deepEqual(launch2, {
+        command: "explorer",
+        args: ["C:\\workspace"],
+      });
-  it("maps file-manager editor to OS open commands", () => {
+      const launch3 = yield* resolveEditorLaunch(
-    expect(
+        { cwd: "/tmp/workspace", editor: "file-manager" },
-      resolveEditorLaunch({ cwd: "/tmp/workspace", editor: "file-manager" }, "darwin"),
+        "linux",
-    ).toEqual({
+      );
-      command: "open",
+      assert.deepEqual(launch3, {
-      args: ["/tmp/workspace"],
-    });
-    expect(resolveEditorLaunch({ cwd: "C:\\workspace", editor: "file-manager" }, "win32")).toEqual({
-      command: "explorer",
-      args: ["C:\\workspace"],
-    });
-    expect(resolveEditorLaunch({ cwd: "/tmp/workspace", editor: "file-manager" }, "linux")).toEqual(
-      {
         command: "xdg-open",
         args: ["/tmp/workspace"],
-      },
+      });
-    );
+    }),
-  });
+  );
 });
 describe("launchDetached", () => {
-  it("resolves when command can be spawned", async () => {
+  it.effect("resolves when command can be spawned", () =>
-    await expect(launchDetached(process.execPath, ["-e", "process.exit(0)"])).resolves.toBe(
+    Effect.gen(function* () {
-      undefined,
+      const result = yield* launchDetached({
-    );
+        command: process.execPath,
-  });
+        args: ["-e", "process.exit(0)"],
+      }).pipe(Effect.result);
+      assertSuccess(result, undefined);
+    }),
+  );
-  it("rejects when command does not exist", async () => {
+  it.effect("rejects when command does not exist", () =>
-    await expect(launchDetached(`t3code-no-such-command-${Date.now()}`, [])).rejects.toBeInstanceOf(
+    Effect.gen(function* () {
-      Error,
+      const result = yield* launchDetached({
-    );
+        command: `t3code-no-such-command-${Date.now()}`,
-  });
+        args: [],
+      }).pipe(Effect.result);
+      assert.equal(result._tag, "Failure");
+    }),
+  );
 });

apps/server/src/open.ts+21-22

 @@ -3,6 +3,10 @@ import { spawn } from "node:child_process";
 import { EDITORS, type EditorId } from "@t3tools/contracts";
 import { ServiceMap, Schema, Effect, Layer } from "effect";
+// ==============================
+// Definitions
+// ==============================
 export class OpenError extends Schema.TaggedErrorClass<OpenError>()("OpenError", {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 @@ -25,13 +29,17 @@ export interface OpenShape {
 export class Open extends ServiceMap.Service<Open, OpenShape>()("server/Open") {}
-export function resolveEditorLaunch(
+// ==============================
+// Implementations
+// ==============================
+export const resolveEditorLaunch = Effect.fnUntraced(function* (
   input: OpenInEditorInput,
   platform: NodeJS.Platform = process.platform,
-): EditorLaunch {
+): Effect.fn.Return<EditorLaunch, OpenError> {
   const editorDef = EDITORS.find((editor) => editor.id === input.editor);
   if (!editorDef) {
-    throw new OpenError({ message: `Unknown editor: ${input.editor}` });
+    return yield* new OpenError({ message: `Unknown editor: ${input.editor}` });
   }
   if (editorDef.command) {
 @@ -39,7 +47,7 @@ export function resolveEditorLaunch(
   }
   if (editorDef.id !== "file-manager") {
-    throw new OpenError({ message: `Unsupported editor: ${input.editor}` });
+    return yield* new OpenError({ message: `Unsupported editor: ${input.editor}` });
   }
   switch (platform) {
 @@ -50,24 +58,25 @@ export function resolveEditorLaunch(
     default:
       return { command: "xdg-open", args: [input.cwd] };
   }
-}
+});
-export function launchDetached(command: string, args: ReadonlyArray<string>): Promise<void> {
+export const launchDetached = (launch: EditorLaunch) =>
-  return new Promise((resolve, reject) => {
+  Effect.callback<void, OpenError>((resume) => {
-    const child = spawn(command, [...args], {
+    const child = spawn(launch.command, [...launch.args], {
       detached: true,
       stdio: "ignore",
     });
     const handleSpawn = () => {
       child.unref();
-      resolve();
+      resume(Effect.void);
     };
     child.once("spawn", handleSpawn);
-    child.once("error", (error) => reject(error));
+    child.once("error", (cause) =>
+      resume(Effect.fail(new OpenError({ message: "failed to spawn detached process", cause }))),
+    );
   });
-}
 const make = Effect.gen(function* () {
   const open = yield* Effect.promise(() => import("open"));
 @@ -78,17 +87,7 @@ const make = Effect.gen(function* () {
         try: () => open.default(target),
         catch: (cause) => new OpenError({ message: "Browser auto-open failed", cause }),
       }),
-    openInEditor: (input) =>
+    openInEditor: (input) => Effect.flatMap(resolveEditorLaunch(input), launchDetached),
-      Effect.tryPromise({
-        try: () => {
-          const launch = resolveEditorLaunch(input);
-          return launchDetached(launch.command, launch.args);
-        },
-        catch: (cause) =>
-          cause instanceof OpenError
-            ? cause
-            : new OpenError({ message: "Failed to open editor", cause }),
-      }),
   } satisfies OpenShape;
 });