alchemy 2.0.0-beta.2 → 2.0.0-beta.4

package/src/Cloudflare/Workers/DurableObject.ts

@@ -1,527 +0,0 @@
-import type * as cf from "@cloudflare/workers-types";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import type { HttpServerError } from "effect/unstable/http/HttpServerError";
-import * as HttpServerRequest from "effect/unstable/http/HttpServerRequest";
-import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
-import type { HttpEffect } from "../../Http.ts";
-import * as Output from "../../Output.ts";
-import type { PlatformServices } from "../../Platform.ts";
-import { effectClass, taggedFunction } from "../../Util/effect.ts";
-import { makeRpcStub } from "./Rpc.ts";
-import { fromWebSocket, type DurableWebSocket } from "./WebSocket.ts";
-import { Worker, WorkerEnvironment, type WorkerServices } from "./Worker.ts";
-
-export interface DurableObjectExport {
-  readonly kind: "durableObject";
-  readonly make: (
-    state: cf.DurableObjectState,
-    env: any,
-  ) => Effect.Effect<Record<string, unknown>>;
-}
-
-export const isDurableObjectExport = (
-  value: unknown,
-): value is DurableObjectExport =>
-  typeof value === "object" &&
-  value !== null &&
-  "kind" in value &&
-  (value as any).kind === "durableObject";
-
-export type DurableObjectId = cf.DurableObjectId;
-export type DurableObjectJurisdiction = cf.DurableObjectJurisdiction;
-export type DurableObjectNamespaceGetDurableObjectOptions =
-  cf.DurableObjectNamespaceGetDurableObjectOptions;
-
-export type AlarmInvocationInfo = cf.AlarmInvocationInfo;
-
-type TypeId = "Cloudflare.DurableObjectNamespace";
-const TypeId = "Cloudflare.DurableObjectNamespace";
-
-export interface DurableObjectNamespace<Shape = unknown> {
-  Type: TypeId;
-  name: string;
-  namespaceId: Output.Output<string>;
-  getByName: (name: string) => DurableObjectStub<Shape>;
-  newUniqueId: () => DurableObjectId;
-  idFromName: (name: string) => DurableObjectId;
-  idFromString: (id: string) => DurableObjectId;
-  get: (
-    id: DurableObjectId,
-    options?: DurableObjectNamespaceGetDurableObjectOptions,
-  ) => DurableObjectStub<Shape>;
-  jurisdiction: (
-    jurisdiction: DurableObjectJurisdiction,
-  ) => DurableObjectNamespace<Shape>;
-}
-
-export interface DurableObjectShape {
-  fetch?: HttpEffect<DurableObjectState>;
-  alarm?: (
-    alarmInfo?: AlarmInvocationInfo,
-  ) => Effect.Effect<void, never, never>;
-  webSocketMessage?: (
-    socket: DurableWebSocket,
-    message: string | Uint8Array,
-  ) => Effect.Effect<void>;
-  webSocketClose?: (
-    socket: DurableWebSocket,
-    code: number,
-    reason: string,
-    wasClean: boolean,
-  ) => Effect.Effect<void>;
-}
-
-export type DurableObjectServices =
-  | DurableObjectNamespace
-  | DurableObjectState
-  | WorkerServices
-  | PlatformServices;
-
-export interface DurableObjectNamespaceClass extends Effect.Effect<
-  DurableObjectNamespace,
-  never,
-  DurableObjectNamespace
-> {
-  <Self>(): {
-    <Shape, InitReq = never>(
-      name: string,
-      impl: Effect.Effect<
-        Effect.Effect<Shape, never, DurableObjectServices>,
-        never,
-        InitReq
-      >,
-    ): Effect.Effect<
-      DurableObjectNamespace<Self>,
-      never,
-      Worker | Exclude<InitReq, DurableObjectServices>
-    > & {
-      new (_: never): Shape;
-    };
-  };
-  <Shape, InitReq = never>(
-    name: string,
-    impl: Effect.Effect<
-      Effect.Effect<Shape, never, DurableObjectServices>,
-      never,
-      InitReq
-    >,
-  ): Effect.Effect<
-    DurableObjectNamespace<Shape>,
-    never,
-    Worker | Exclude<InitReq, DurableObjectServices>
-  >;
-}
-
-export class DurableObjectNamespaceScope extends Context.Service<
-  DurableObjectNamespaceScope,
-  DurableObjectNamespace
->()("Cloudflare.DurableObjectNamespace") {}
-
-export const DurableObjectNamespace: DurableObjectNamespaceClass =
-  taggedFunction(DurableObjectNamespaceScope, ((
-    ...args:
-      | []
-      | [
-          name: string,
-          impl: Effect.Effect<
-            Effect.Effect<
-              DurableObjectNamespace<any>,
-              never,
-              DurableObjectState
-            >
-          >,
-        ]
-  ) =>
-    args.length === 0
-      ? DurableObjectNamespace
-      : effectClass(
-          Effect.gen(function* () {
-            const [namespace, impl] = args;
-            const worker = yield* Worker;
-
-            yield* worker.bind`${namespace}`({
-              // TODO(sam): automate class migrations, probably in the provider
-              bindings: [
-                {
-                  type: "durable_object_namespace",
-                  name: namespace,
-                  className: namespace,
-                  // scriptName:
-                  //   binding.scriptName === props.workerName
-                  //     ? undefined
-                  //     : binding.scriptName,
-                  // environment: binding.environment,
-                  // namespaceId: binding.namespaceId,
-                },
-              ],
-            });
-
-            const services =
-              yield* Effect.context<Effect.Services<typeof impl>>();
-
-            yield* worker.export(namespace, {
-              kind: "durableObject",
-              make: (state: cf.DurableObjectState, env: any) => {
-                const doState = fromDurableObjectState(state);
-                return constructor.pipe(
-                  Effect.provideContext(services),
-                  Effect.provideService(DurableObjectState, doState),
-                  Effect.provideService(WorkerEnvironment, env),
-                  Effect.map((methods: any) => {
-                    console.log(
-                      "[DurableObject] wrapping methods:",
-                      Object.keys(methods),
-                      "own:",
-                      Object.getOwnPropertyNames(methods),
-                    );
-                    const wrapped: Record<string, unknown> = {};
-                    for (const key of Object.getOwnPropertyNames(methods)) {
-                      const value = methods[key];
-                      if (Effect.isEffect(value)) {
-                        wrapped[key] = (
-                          value as Effect.Effect<any, any, any>
-                        ).pipe(
-                          Effect.provideService(DurableObjectState, doState),
-                        );
-                      } else if (typeof value === "function") {
-                        wrapped[key] = (...args: unknown[]) => {
-                          const result = (value as Function)(...args);
-                          if (Effect.isEffect(result)) {
-                            return (
-                              result as Effect.Effect<any, any, any>
-                            ).pipe(
-                              Effect.provideService(
-                                DurableObjectState,
-                                doState,
-                              ),
-                            );
-                          }
-                          return result;
-                        };
-                      } else {
-                        wrapped[key] = value;
-                      }
-                    }
-                    return wrapped;
-                  }),
-                );
-              },
-            } satisfies DurableObjectExport);
-
-            const binding = yield* Effect.serviceOption(WorkerEnvironment).pipe(
-              Effect.map(Option.getOrUndefined),
-              Effect.flatMap((env) => {
-                if (env === undefined) {
-                  // should be fine to return undefined here (it is only undefined at plantime)
-                  return Effect.succeed(undefined);
-                }
-                const ns = env[namespace];
-                if (!ns) {
-                  return Effect.die(
-                    new Error(
-                      `DurableObjectNamespace '${namespace}' not found`,
-                    ),
-                  );
-                } else if (typeof ns.getByName === "function") {
-                  return Effect.succeed(ns);
-                } else {
-                  return Effect.die(
-                    new Error(
-                      `DurableObjectNamespace '${namespace}' is not a DurableObjectNamespace`,
-                    ),
-                  );
-                }
-              }),
-            );
-
-            const namespaceId = worker.durableObjectNamespaces.pipe(
-              Output.map(
-                (durableObjectNamespaces) =>
-                  durableObjectNamespaces?.[namespace],
-              ),
-            );
-
-            const self = {
-              Type: TypeId,
-              LogicalId: namespace,
-              name: namespace,
-              namespaceId,
-              getByName: (name: string) => makeRpcStub(binding.getByName(name)),
-              // newUniqueId: () => use((ns) => ns.newUniqueId()),
-              // idFromName: (name: string) => use((ns) => ns.idFromName(name)),
-              // idFromString: (id: string) => use((ns) => ns.idFromString(id)),
-              // get: (
-              //   id: cf.DurableObjectId,
-              //   options?: cf.DurableObjectNamespaceGetDurableObjectOptions,
-              // ) => use((ns) => makeRpcStub(ns.get(id, options))),
-              // jurisdiction: (jurisdiction: cf.DurableObjectJurisdiction) =>
-              //   use((ns) => ns.jurisdiction(jurisdiction) as any),
-            };
-
-            const constructor = yield* impl.pipe(
-              Effect.provideService(DurableObjectNamespaceScope, self as any),
-            );
-
-            return self;
-          }),
-        )) as any);
-
-export type DurableObjectStub<Shape> = {
-  // TODO(sam): do we need to transform? hopefully not
-  [key in keyof Shape]: Shape[key];
-} & {
-  fetch: (
-    request: HttpServerRequest.HttpServerRequest,
-  ) => Effect.Effect<
-    HttpServerResponse.HttpServerResponse,
-    HttpServerError,
-    never
-  >;
-};
-
-export class DurableObjectState extends Context.Service<
-  DurableObjectState,
-  {
-    // TODO(sam): is this needed when we have Effect?
-    // waitUntil(promise: Promise<any>): Effect.Effect<void>;
-
-    // TODO(sam): what are these? Where do they come from?
-    // readonly props: Props;
-
-    readonly id: cf.DurableObjectId;
-    readonly storage: DurableObjectStorage;
-    // TODO(sam): effect-native interface for container
-    container?: cf.Container;
-    blockConcurrencyWhile<T>(
-      callback: () => Effect.Effect<T>,
-    ): Effect.Effect<T>;
-    acceptWebSocket(ws: DurableWebSocket, tags?: string[]): Effect.Effect<void>;
-    getWebSockets(tag?: string): Effect.Effect<DurableWebSocket[]>;
-    setWebSocketAutoResponse(
-      maybeReqResp?: cf.WebSocketRequestResponsePair,
-    ): Effect.Effect<void>;
-    getWebSocketAutoResponse(): Effect.Effect<cf.WebSocketRequestResponsePair | null>;
-    getWebSocketAutoResponseTimestamp(
-      ws: cf.WebSocket,
-    ): Effect.Effect<Date | null>;
-    setHibernatableWebSocketEventTimeout(
-      timeoutMs?: number,
-    ): Effect.Effect<void>;
-    getHibernatableWebSocketEventTimeout(): Effect.Effect<number | null>;
-    getTags(ws: cf.WebSocket): Effect.Effect<string[]>;
-    abort(reason?: string): Effect.Effect<void>;
-  }
->()("Cloudflare.DurableObjectState") {}
-
-export interface DurableObjectTransaction {
-  get<T = unknown>(
-    key: string,
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<T | undefined>;
-  get<T = unknown>(
-    keys: string[],
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<Map<string, T>>;
-  list<T = unknown>(
-    options?: cf.DurableObjectListOptions,
-  ): Effect.Effect<Map<string, T>>;
-  put<T>(
-    key: string,
-    value: T,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  put<T>(
-    entries: Record<string, T>,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  delete(
-    key: string,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<boolean>;
-  delete(
-    keys: string[],
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<number>;
-  rollback(): Effect.Effect<void>;
-  getAlarm(
-    options?: cf.DurableObjectGetAlarmOptions,
-  ): Effect.Effect<number | null>;
-  setAlarm(
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ): Effect.Effect<void>;
-  deleteAlarm(options?: cf.DurableObjectSetAlarmOptions): Effect.Effect<void>;
-}
-export interface DurableObjectStorage {
-  get<T = unknown>(
-    key: string,
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<T | undefined>;
-  get<T = unknown>(
-    keys: string[],
-    options?: cf.DurableObjectGetOptions,
-  ): Effect.Effect<Map<string, T>>;
-  list<T = unknown>(
-    options?: cf.DurableObjectListOptions,
-  ): Effect.Effect<Map<string, T>>;
-  put<T>(
-    key: string,
-    value: T,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  put<T>(
-    entries: Record<string, T>,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<void>;
-  delete(
-    key: string,
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<boolean>;
-  delete(
-    keys: string[],
-    options?: cf.DurableObjectPutOptions,
-  ): Effect.Effect<number>;
-  deleteAll(options?: cf.DurableObjectPutOptions): Effect.Effect<void>;
-  transaction<T>(
-    closure: (txn: DurableObjectTransaction) => Effect.Effect<T>,
-  ): Effect.Effect<T>;
-  getAlarm(
-    options?: cf.DurableObjectGetAlarmOptions,
-  ): Effect.Effect<number | null>;
-  setAlarm(
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ): Effect.Effect<void>;
-  deleteAlarm(options?: cf.DurableObjectSetAlarmOptions): Effect.Effect<void>;
-  sync(): Effect.Effect<void>;
-  sql: cf.SqlStorage;
-  kv: cf.SyncKvStorage;
-  transactionSync<T>(closure: () => T): T;
-  getCurrentBookmark(): Effect.Effect<string>;
-  getBookmarkForTime(timestamp: number | Date): Effect.Effect<string>;
-  onNextSessionRestoreBookmark(bookmark: string): Effect.Effect<string>;
-}
-
-const fromDurableObjectState = (
-  state: cf.DurableObjectState,
-): DurableObjectState["Service"] => ({
-  id: state.id,
-  container: state.container,
-  storage: fromDurableObjectStorage(state.storage),
-  blockConcurrencyWhile: <T>(callback: () => Effect.Effect<T>) =>
-    Effect.tryPromise(() =>
-      state.blockConcurrencyWhile(() => Effect.runPromise(callback())),
-    ),
-  acceptWebSocket: (ws: DurableWebSocket, tags?: string[]) =>
-    Effect.sync(() => state.acceptWebSocket(ws.ws, tags)),
-  getWebSockets: (tag?: string) =>
-    Effect.sync(() => state.getWebSockets(tag).map(fromWebSocket)),
-  setWebSocketAutoResponse: (maybeReqResp?: cf.WebSocketRequestResponsePair) =>
-    Effect.sync(() => state.setWebSocketAutoResponse(maybeReqResp)),
-  getWebSocketAutoResponse: () =>
-    Effect.sync(() => state.getWebSocketAutoResponse()),
-  getWebSocketAutoResponseTimestamp: (ws: cf.WebSocket) =>
-    Effect.sync(() => state.getWebSocketAutoResponseTimestamp(ws)),
-  setHibernatableWebSocketEventTimeout: (timeoutMs?: number) =>
-    Effect.sync(() => state.setHibernatableWebSocketEventTimeout(timeoutMs)),
-  getHibernatableWebSocketEventTimeout: () =>
-    Effect.sync(() => state.getHibernatableWebSocketEventTimeout()),
-  getTags: (ws: cf.WebSocket) => Effect.sync(() => state.getTags(ws)),
-  abort: (reason?: string) => Effect.sync(() => state.abort(reason)),
-});
-
-const fromDurableObjectTransaction = (
-  txn: cf.DurableObjectTransaction,
-): DurableObjectTransaction => ({
-  get: ((keyOrKeys: string | string[], options?: cf.DurableObjectGetOptions) =>
-    Effect.tryPromise(() => txn.get(keyOrKeys as any, options))) as any,
-  list: (options?: cf.DurableObjectListOptions) =>
-    Effect.tryPromise(() => txn.list(options)),
-  put: ((
-    keyOrEntries: string | Record<string, unknown>,
-    valueOrOptions?: unknown,
-    maybeOptions?: cf.DurableObjectPutOptions,
-  ) =>
-    typeof keyOrEntries === "string"
-      ? Effect.tryPromise(() =>
-          txn.put(keyOrEntries, valueOrOptions, maybeOptions),
-        )
-      : Effect.tryPromise(() =>
-          txn.put(
-            keyOrEntries,
-            valueOrOptions as cf.DurableObjectPutOptions | undefined,
-          ),
-        )) as any,
-  delete: ((
-    keyOrKeys: string | string[],
-    options?: cf.DurableObjectPutOptions,
-  ) => Effect.tryPromise(() => txn.delete(keyOrKeys as any, options))) as any,
-  rollback: () => Effect.sync(() => txn.rollback()),
-  getAlarm: (options?: cf.DurableObjectGetAlarmOptions) =>
-    Effect.tryPromise(() => txn.getAlarm(options)),
-  setAlarm: (
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ) => Effect.tryPromise(() => txn.setAlarm(scheduledTime, options)),
-  deleteAlarm: (options?: cf.DurableObjectSetAlarmOptions) =>
-    Effect.tryPromise(() => txn.deleteAlarm(options)),
-});
-
-const fromDurableObjectStorage = (
-  storage: cf.DurableObjectStorage,
-): DurableObjectStorage => ({
-  get: ((keyOrKeys: string | string[], options?: cf.DurableObjectGetOptions) =>
-    Effect.tryPromise(() => storage.get(keyOrKeys as any, options))) as any,
-  list: (options?: cf.DurableObjectListOptions) =>
-    Effect.tryPromise(() => storage.list(options)),
-  put: ((
-    keyOrEntries: string | Record<string, unknown>,
-    valueOrOptions?: unknown,
-    maybeOptions?: cf.DurableObjectPutOptions,
-  ) =>
-    typeof keyOrEntries === "string"
-      ? Effect.tryPromise(() =>
-          storage.put(keyOrEntries, valueOrOptions, maybeOptions),
-        )
-      : Effect.tryPromise(() =>
-          storage.put(
-            keyOrEntries,
-            valueOrOptions as cf.DurableObjectPutOptions | undefined,
-          ),
-        )) as any,
-  delete: ((
-    keyOrKeys: string | string[],
-    options?: cf.DurableObjectPutOptions,
-  ) =>
-    Effect.tryPromise(() => storage.delete(keyOrKeys as any, options))) as any,
-  deleteAll: (options?: cf.DurableObjectPutOptions) =>
-    Effect.tryPromise(() => storage.deleteAll(options)),
-  transaction: <T>(
-    closure: (txn: DurableObjectTransaction) => Effect.Effect<T>,
-  ) =>
-    Effect.tryPromise(() =>
-      storage.transaction((txn) =>
-        Effect.runPromise(closure(fromDurableObjectTransaction(txn))),
-      ),
-    ),
-  getAlarm: (options?: cf.DurableObjectGetAlarmOptions) =>
-    Effect.tryPromise(() => storage.getAlarm(options)),
-  setAlarm: (
-    scheduledTime: number | Date,
-    options?: cf.DurableObjectSetAlarmOptions,
-  ) => Effect.tryPromise(() => storage.setAlarm(scheduledTime, options)),
-  deleteAlarm: (options?: cf.DurableObjectSetAlarmOptions) =>
-    Effect.tryPromise(() => storage.deleteAlarm(options)),
-  sync: () => Effect.tryPromise(() => storage.sync()),
-  sql: storage.sql,
-  kv: storage.kv,
-  transactionSync: <T>(closure: () => T) => storage.transactionSync(closure),
-  getCurrentBookmark: () =>
-    Effect.tryPromise(() => storage.getCurrentBookmark()),
-  getBookmarkForTime: (timestamp: number | Date) =>
-    Effect.tryPromise(() => storage.getBookmarkForTime(timestamp)),
-  onNextSessionRestoreBookmark: (bookmark: string) =>
-    Effect.tryPromise(() => storage.onNextSessionRestoreBookmark(bookmark)),
-});

package/src/Daemon/Client.ts

@@ -1,116 +0,0 @@
-import * as NodeSocket from "@effect/platform-node/NodeSocket";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import * as Schedule from "effect/Schedule";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import * as Socket from "effect/unstable/socket/Socket";
-import { resolveSocketPath } from "./Config.ts";
-import { DaemonConnectFailed, DaemonSocketNotReady } from "./Errors.ts";
-import { DaemonRpcs } from "./RpcSchema.ts";
-
-export type DaemonClient = Effect.Success<ReturnType<typeof makeClient>>;
-
-export class Daemon extends Context.Service<Daemon, DaemonClient>()(
-  "alchemy/Cli/Daemon",
-) {}
-
-export const makeClient = (socketPath: string) =>
-  Effect.gen(function* () {
-    const socket = yield* NodeSocket.makeNet({ path: socketPath });
-    const protocol = yield* RpcClient.makeProtocolSocket().pipe(
-      Effect.provideService(Socket.Socket, socket),
-      Effect.provide(RpcSerialization.layerJson),
-    );
-    return yield* RpcClient.make(DaemonRpcs).pipe(
-      Effect.provideService(RpcClient.Protocol, protocol),
-    );
-  });
-
-const DAEMON_BIN = "process-manager.ts";
-const HEARTBEAT_INTERVAL = "1 seconds" as const;
-
-const resolveDaemonBin = Effect.gen(function* () {
-  const path = yield* Path.Path;
-  return path.join(path.dirname(import.meta.dirname), "bin", DAEMON_BIN);
-});
-
-/**
- * Layer that provides a connected `Daemon` client.
- *
- * On build:
- * 1. Try to connect to the existing daemon socket
- * 2. If that fails, spawn the daemon process and wait for the socket
- * 3. Connect to the socket
- * 4. Fork a heartbeat fiber that pings every second to keep the daemon alive
- * 5. When the scope closes, the heartbeat stops (daemon may idle-shutdown)
- */
-export const DaemonLive: Layer.Layer<
-  Daemon,
-  never,
-  FileSystem.FileSystem | Path.Path | ChildProcessSpawner
-> = Layer.effect(
-  Daemon,
-  Effect.gen(function* () {
-    const socketPath = yield* resolveSocketPath;
-
-    const client = yield* tryConnect(socketPath).pipe(
-      Effect.catchTag("DaemonConnectFailed", () =>
-        Effect.gen(function* () {
-          yield* Effect.logInfo("Starting daemon…");
-          yield* startDaemonProcess.pipe(Effect.forkChild);
-          yield* waitForSocket(socketPath);
-          yield* Effect.sleep("200 millis");
-          return yield* tryConnect(socketPath);
-        }),
-      ),
-      Effect.catchTag("PlatformError", (e) => Effect.die(e)),
-      Effect.catchTag("DaemonConnectFailed", () =>
-        Effect.die(new Error("Failed to connect to daemon")),
-      ),
-    );
-
-    yield* client
-      .heartbeat(void 0 as any)
-      .pipe(
-        Effect.ignore,
-        Effect.repeat(Schedule.spaced(HEARTBEAT_INTERVAL)),
-        Effect.forkScoped,
-      );
-
-    yield* Effect.logInfo("Connected to daemon");
-
-    return client;
-  }),
-);
-
-const waitForSocket = (socketPath: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    yield* fs.exists(socketPath).pipe(
-      Effect.flatMap((exists) =>
-        exists ? Effect.void : Effect.fail(new DaemonSocketNotReady()),
-      ),
-      Effect.retry(
-        Schedule.spaced("100 millis").pipe(Schedule.both(Schedule.recurs(50))),
-      ),
-      Effect.catchTag("DaemonSocketNotReady", () =>
-        Effect.fail(new DaemonConnectFailed()),
-      ),
-    );
-  });
-
-const tryConnect = (socketPath: string) =>
-  makeClient(socketPath).pipe(
-    Effect.catch(() => Effect.fail(new DaemonConnectFailed())),
-  );
-
-const startDaemonProcess = Effect.gen(function* () {
-  const binPath = yield* resolveDaemonBin;
-  const cmd = ChildProcess.make("bun", ["run", binPath]);
-  yield* cmd;
-});

package/src/Daemon/Config.ts

@@ -1,28 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-
-export const ALCHEMY_DIR = ".alchemy";
-export const SOCKET_FILE = "daemon.sock";
-export const LOCK_DIR_NAME = "daemon.lock";
-export const PID_FILE_NAME = "pid";
-export const DB_FILE = "daemon.db";
-export const PROCESSES_DIR = "processes";
-
-export const resolveAlchemyDir = Effect.gen(function* () {
-  const path = yield* Path.Path;
-  return path.resolve(ALCHEMY_DIR);
-});
-
-export const ensureAlchemyDir = Effect.gen(function* () {
-  const fs = yield* FileSystem.FileSystem;
-  const dir = yield* resolveAlchemyDir;
-  yield* fs.makeDirectory(dir, { recursive: true });
-  return dir;
-});
-
-export const resolveSocketPath = Effect.gen(function* () {
-  const path = yield* Path.Path;
-  const dir = yield* resolveAlchemyDir;
-  return path.join(dir, SOCKET_FILE);
-});