alchemy 2.0.0-beta.39 → 2.0.0-beta.40

package/src/Sidecar/Lock.ts

@@ -1,11 +1,8 @@
+import * as lockfile from "@alchemy.run/node-utils";
 import * as Context from "effect/Context";
-import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
-import * as Fiber from "effect/Fiber";
-import * as FileSystem from "effect/FileSystem";
+import type * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import * as Schedule from "effect/Schedule";
 import * as Schema from "effect/Schema";
 import type * as Scope from "effect/Scope";
 import * as RpcPaths from "./RpcPaths.ts";
@@ -13,13 +10,7 @@ import * as RpcPaths from "./RpcPaths.ts";
 export class LockError extends Schema.TaggedErrorClass<LockError>()(
   "LockError",
   {
-    reason: Schema.Literals([
-      "Cancelled",
-      "Conflict",
-      "Invalid",
-      "Timeout",
-      "PlatformError",
-    ]),
+    reason: Schema.Literals(["Conflict", "PlatformError"]),
     message: Schema.String,
     cause: Schema.optional(Schema.DefectWithStack),
   },
@@ -30,161 +21,46 @@ export class Lock extends Context.Service<
   {
     readonly check: Effect.Effect<boolean>;
     readonly acquire: Effect.Effect<
-      Fiber.Fiber<number, LockError>,
+      Fiber.Fiber<never, LockError>,
       LockError,
       Scope.Scope
     >;
   }
 >()("Lock") {}
 
-const LOCK_TTL = Duration.seconds(10);
-const TOUCH_INTERVAL = Duration.seconds(1);
+const STALE_MS = 10_000;
+const UPDATE_MS = 1_000;
 
 const make = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
   const paths = yield* RpcPaths.RpcPaths;
 
-  const readLockFile = fs.readFileString(paths.lock).pipe(
-    Effect.mapError(
-      (e) =>
-        new LockError({
-          reason: "PlatformError",
-          message:
-            e.reason._tag === "NotFound"
-              ? "Lock file not found"
-              : "Failed to read lock file",
-          cause: e,
-        }),
-    ),
-    Effect.flatMap((text) => {
-      const pid = Number.parseInt(text);
-      return Number.isNaN(pid)
-        ? Effect.fail(
-            new LockError({
-              reason: "Invalid",
-              message: "Lock file is invalid",
-            }),
-          )
-        : Effect.succeed(pid);
-    }),
-  );
-
-  const isLockProcessAlive = readLockFile.pipe(
-    Effect.flatMap((pid) =>
-      Effect.sync(() => {
-        try {
-          process.kill(pid, 0);
-          return true;
-        } catch {
-          return false;
-        }
+  const check = Effect.tryPromise(() =>
+    lockfile.check(paths.lock, { stale: STALE_MS, realpath: false }),
+  ).pipe(Effect.orElseSucceed(() => false));
+
+  const acquire = Effect.gen(function* () {
+    yield* Effect.acquireRelease(
+      Effect.tryPromise({
+        try: () =>
+          lockfile.lock(paths.lock, {
+            stale: STALE_MS,
+            update: UPDATE_MS,
+            retries: 0,
+            realpath: false,
+          }),
+        catch: (cause) =>
+          new LockError({
+            reason: "Conflict",
+            message: "Lock already held by another process",
+            cause,
+          }),
       }),
-    ),
-    Effect.orElseSucceed(() => false),
-  );
-
-  const isLockFileStale = fs.stat(paths.lock).pipe(
-    Effect.map((stat) => {
-      const mtime = Option.getOrElse(stat.mtime, () => new Date(0));
-      return mtime.getTime() < Date.now() - Duration.toMillis(LOCK_TTL);
-    }),
-    Effect.orElseSucceed(() => true),
-  );
-
-  const isLockValid = Effect.zipWith(
-    isLockProcessAlive,
-    isLockFileStale,
-    (alive, stale) => alive && !stale,
-    {
-      concurrent: true,
-    },
-  );
-
-  const makeLockFile = fs
-    .writeFileString(paths.lock, process.pid.toString(), { flag: "wx" })
-    .pipe(
-      Effect.mapError((e) =>
-        e.reason._tag === "AlreadyExists"
-          ? new LockError({
-              reason: "Conflict",
-              message: "Lock already held by another process",
-            })
-          : new LockError({
-              reason: "PlatformError",
-              message: "Failed to create lock file",
-              cause: e,
-            }),
-      ),
+      (release) => Effect.promise(() => release().catch(() => {})),
     );
+    return yield* Effect.never;
+  }).pipe(Effect.forkScoped);
 
-  const assertOwnLock = readLockFile.pipe(
-    Effect.flatMap((pid) =>
-      pid === process.pid
-        ? Effect.void
-        : Effect.fail(
-            new LockError({
-              reason: "Conflict",
-              message: "Lock not held by this process",
-            }),
-          ),
-    ),
-  );
-
-  const removeLock = fs.remove(paths.lock, { force: true }).pipe(
-    Effect.mapError(
-      (e) =>
-        new LockError({
-          reason: "PlatformError",
-          message: "Failed to remove lock file",
-          cause: e,
-        }),
-    ),
-  );
-
-  const releaseLock = assertOwnLock.pipe(Effect.andThen(() => removeLock));
-
-  const acquireLock = makeLockFile.pipe(
-    Effect.catchIf(
-      (e) => e.reason === "Conflict",
-      (e) =>
-        isLockValid.pipe(
-          Effect.flatMap((valid) =>
-            valid
-              ? Effect.fail(e)
-              : removeLock.pipe(Effect.andThen(() => makeLockFile)),
-          ),
-        ),
-    ),
-  );
-
-  const touchLock = assertOwnLock.pipe(
-    Effect.flatMap(() => {
-      const now = Date.now();
-      return fs.utimes(paths.lock, now, now).pipe(
-        Effect.mapError(
-          (e) =>
-            new LockError({
-              reason: "PlatformError",
-              message: "Failed to update lock file",
-              cause: e,
-            }),
-        ),
-      );
-    }),
-  );
-
-  return Lock.of({
-    check: isLockValid,
-    acquire: acquireLock.pipe(
-      Effect.flatMap(() =>
-        touchLock.pipe(
-          Effect.repeat(Schedule.spaced(TOUCH_INTERVAL)),
-          Effect.ensuring(releaseLock.pipe(Effect.ignore)),
-          Effect.forkScoped,
-        ),
-      ),
-    ),
-  });
+  return Lock.of({ check, acquire });
 });
 
 export const LockLive = Layer.effect(Lock, make);

package/src/Sidecar/RpcHandler.ts

@@ -2,14 +2,18 @@ import type { RpcCompatible } from "capnweb";
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import { flow } from "effect/Function";
+import * as Redacted from "effect/Redacted";
 import * as Schema from "effect/Schema";
 
 type RpcHandler<Args extends Array<any>, Success, Error> = (
   ...args: Args
 ) => Effect.Effect<Success, Error>;
 
-type SerializedRpcHandler<Args extends Array<any>, Success, Error> = (
-  ...args: Args
+type SerializedArgs<T> = string & { __serializedArgs: T };
+
+type SerializedRpcHandler<Args, Success, Error> = (
+  args: SerializedArgs<Args>,
 ) => Promise<SerializedExit<RpcCompatible<Success>, RpcCompatible<Error>>>;
 
 type SerializedCause<Error> =
@@ -60,45 +64,59 @@ export type RpcHandlerDecoders<T extends RpcHandlers> = {
     : never;
 };
 
-const serializeRpcHandler =
-  <Args extends Array<any>, Success, Error>(
-    handler: RpcHandler<Args, Success, Error>,
-    schema: RpcHandlerEncoder<Success, Error>,
-  ): SerializedRpcHandler<Args, Success, Error> =>
-  (...args) =>
-    handler(...args).pipe(
-      Effect.exit,
-      Effect.map((exit): SerializedExit<Success, Error> => {
-        if (exit._tag === "Success") {
-          return {
-            _tag: "Success",
-            value: Schema.encodeSync(schema.success)(exit.value),
-          } as const;
-        }
-        return {
-          _tag: "Failure",
-          cause: exit.cause.reasons.map((reason): SerializedCause<Error> => {
-            switch (reason._tag) {
-              case "Fail":
-                return {
-                  _tag: "Fail",
-                  error: Schema.encodeSync(schema.error)(reason.error),
-                };
-              case "Die":
-                return {
-                  _tag: "Die",
-                  defect: Schema.encodeSync(Schema.DefectWithStack)(
-                    reason.defect,
-                  ),
-                };
-              case "Interrupt":
-                return { _tag: "Interrupt", fiberId: reason.fiberId };
+const serializeRpcHandler = <Args extends Array<any>, Success, Error>(
+  handler: RpcHandler<Args, Success, Error>,
+  schema: RpcHandlerEncoder<Success, Error>,
+): SerializedRpcHandler<Args, Success, Error> =>
+  flow(
+    (args) =>
+      Effect.sync(
+        () =>
+          JSON.parse(args, (_, value) => {
+            if (
+              typeof value === "object" &&
+              value !== null &&
+              "_tag" in value &&
+              value._tag === "Redacted"
+            ) {
+              return Redacted.make(value.value);
             }
-          }),
+            return value;
+          }) as Args,
+      ),
+    Effect.flatMap((args) => handler(...args)),
+    Effect.exit,
+    Effect.map((exit): SerializedExit<Success, Error> => {
+      if (exit._tag === "Success") {
+        return {
+          _tag: "Success",
+          value: Schema.encodeSync(schema.success)(exit.value),
         } as const;
-      }),
-      Effect.runPromise,
-    );
+      }
+      return {
+        _tag: "Failure",
+        cause: exit.cause.reasons.map((reason): SerializedCause<Error> => {
+          switch (reason._tag) {
+            case "Fail":
+              return {
+                _tag: "Fail",
+                error: Schema.encodeSync(schema.error)(reason.error),
+              };
+            case "Die":
+              return {
+                _tag: "Die",
+                defect: Schema.encodeSync(Schema.DefectWithStack)(
+                  reason.defect,
+                ),
+              };
+            case "Interrupt":
+              return { _tag: "Interrupt", fiberId: reason.fiberId };
+          }
+        }),
+      } as const;
+    }),
+    Effect.runPromise,
+  );
 
 export const serializeRpcHandlers = <T extends RpcHandlers>(
   handlers: T,
@@ -119,7 +137,16 @@ const deserializeRpcHandler =
   (...args) =>
     Effect.promise(async () => {
       try {
-        return await handler(...args);
+        const serializedArgs = JSON.stringify(args, (_, value) => {
+          if (Redacted.isRedacted(value)) {
+            return {
+              _tag: "Redacted",
+              value: Redacted.value(value),
+            };
+          }
+          return value;
+        }) as SerializedArgs<Args>;
+        return await handler(serializedArgs);
       } catch (error) {
         console.error("Error calling handler", error);
         throw error;

package/src/Util/PlatformServices.ts

@@ -9,7 +9,6 @@ import type { HttpServer } from "effect/unstable/http/HttpServer";
 import type { ServeError } from "effect/unstable/http/HttpServerError";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
 import type { WebSocketConstructor } from "effect/unstable/socket/Socket";
-import { installLocalhostDns } from "./LocalhostDns.ts";
 
 const isBun = typeof Bun !== "undefined";
 
@@ -53,7 +52,6 @@ export const runMain = <E, A>(
     readonly teardown?: Teardown | undefined;
   },
 ): void => {
-  installLocalhostDns();
   if (isBun) {
     void import("@effect/platform-bun/BunRuntime").then((BunRuntime) =>
       BunRuntime.runMain(effect, options),