alchemy 2.0.0-beta.3 → 2.0.0-beta.4

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

package/src/Daemon/Errors.ts

@@ -1,48 +0,0 @@
-import * as Data from "effect/Data";
-import * as Schema from "effect/Schema";
-
-// Schema-based errors used in the RPC contract (shared between client and server)
-
-export class ProcessAlreadyExists extends Schema.TaggedClass<ProcessAlreadyExists>()(
-  "ProcessAlreadyExists",
-  { id: Schema.String },
-) {}
-
-export class ProcessNotFound extends Schema.TaggedClass<ProcessNotFound>()(
-  "ProcessNotFound",
-  { id: Schema.String },
-) {}
-
-// Data-based errors used internally by the daemon runtime
-
-export class DaemonAlreadyRunning extends Data.TaggedError(
-  "DaemonAlreadyRunning",
-)<{
-  readonly pid: number | undefined;
-}> {
-  get message() {
-    return this.pid !== undefined
-      ? `Daemon already running (pid ${this.pid})`
-      : "Daemon already running";
-  }
-}
-
-export class LockCompromised extends Data.TaggedError("LockCompromised")<{
-  readonly lockDir: string;
-}> {}
-
-export class DaemonSocketNotReady extends Data.TaggedError(
-  "DaemonSocketNotReady",
-) {
-  get message() {
-    return "Daemon socket is not ready yet";
-  }
-}
-
-export class DaemonConnectFailed extends Data.TaggedError(
-  "DaemonConnectFailed",
-) {
-  get message() {
-    return "Failed to connect to daemon";
-  }
-}

package/src/Daemon/Lock.ts

@@ -1,162 +0,0 @@
-import * as Deferred from "effect/Deferred";
-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 * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as Ref from "effect/Ref";
-import * as Schedule from "effect/Schedule";
-import { ensureAlchemyDir, LOCK_DIR_NAME, PID_FILE_NAME } from "./Config.ts";
-import { DaemonAlreadyRunning } from "./Errors.ts";
-
-const STALE_THRESHOLD = Duration.seconds(10);
-const LOCK_UPDATE_INTERVAL = Duration.seconds(4);
-
-export const acquireLock = (shutdownSignal: Deferred.Deferred<void>) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const dir = yield* ensureAlchemyDir;
-    const lockDir = path.join(dir, LOCK_DIR_NAME);
-    const pidFile = path.join(lockDir, PID_FILE_NAME);
-
-    const tryMkdir = Effect.gen(function* () {
-      yield* fs.makeDirectory(lockDir);
-      yield* fs.writeFileString(pidFile, String(process.pid));
-    });
-
-    yield* tryMkdir.pipe(
-      Effect.catchTag("PlatformError", (err) => {
-        if (err.reason._tag !== "AlreadyExists") return Effect.fail(err);
-
-        return Effect.gen(function* () {
-          const stale = yield* isLockStale(pidFile);
-          if (!stale) {
-            const pid = yield* readLockPid(lockDir);
-            return yield* new DaemonAlreadyRunning({ pid });
-          }
-
-          const pid = yield* readLockPid(lockDir);
-          if (pid !== undefined) {
-            const alive = yield* isProcessAlive(pid);
-            if (alive) {
-              return yield* new DaemonAlreadyRunning({ pid });
-            }
-          }
-
-          yield* Effect.logWarning(
-            `Removing stale lock (previous pid: ${pid ?? "unknown"})`,
-          );
-          yield* fs.remove(lockDir, { recursive: true, force: true });
-
-          yield* tryMkdir.pipe(
-            Effect.catchTag("PlatformError", (retryErr) =>
-              retryErr.reason._tag !== "AlreadyExists"
-                ? Effect.fail<DaemonAlreadyRunning | typeof retryErr>(retryErr)
-                : Effect.gen(function* () {
-                    const winnerPid = yield* readLockPid(lockDir);
-                    return yield* new DaemonAlreadyRunning({ pid: winnerPid });
-                  }),
-            ),
-          );
-        });
-      }),
-    );
-
-    const updaterFiber = yield* startLockUpdater(lockDir, shutdownSignal);
-
-    yield* Effect.addFinalizer(() =>
-      Effect.gen(function* () {
-        yield* Fiber.interrupt(updaterFiber).pipe(Effect.ignore);
-        yield* fs
-          .remove(lockDir, { recursive: true, force: true })
-          .pipe(Effect.ignore);
-      }),
-    );
-  });
-
-export const isProcessAlive = (pid: number): Effect.Effect<boolean> =>
-  Effect.sync(() => {
-    try {
-      process.kill(pid, 0);
-      return true;
-    } catch {
-      return false;
-    }
-  });
-
-const readLockPid = (lockDir: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const pidFile = path.join(lockDir, PID_FILE_NAME);
-    const contents = yield* fs
-      .readFileString(pidFile)
-      .pipe(Effect.catchTag("PlatformError", () => Effect.succeed("")));
-    const pid = parseInt(contents.trim(), 10);
-    return isNaN(pid) ? undefined : pid;
-  });
-
-const isLockStale = (pidFile: string) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const info = yield* fs
-      .stat(pidFile)
-      .pipe(Effect.catchTag("PlatformError", () => Effect.succeed(undefined)));
-    if (info === undefined) return true;
-    const mtime = Option.getOrElse(info.mtime, () => new Date(0));
-    const age = Date.now() - mtime.getTime();
-    return age > Duration.toMillis(STALE_THRESHOLD);
-  });
-
-const startLockUpdater = (
-  lockDir: string,
-  shutdownSignal: Deferred.Deferred<void>,
-) =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const pidFile = path.join(lockDir, PID_FILE_NAME);
-    const lastMtime = yield* Ref.make<number>(Date.now());
-
-    const touch = Effect.gen(function* () {
-      const info = yield* fs
-        .stat(pidFile)
-        .pipe(
-          Effect.catchTag("PlatformError", () => Effect.succeed(undefined)),
-        );
-
-      if (info === undefined) {
-        yield* Effect.logError("Lock compromised: pid file disappeared");
-        yield* Deferred.succeed(shutdownSignal, void 0);
-        return;
-      }
-
-      const currentMtime = Option.getOrElse(info.mtime, () => new Date(0));
-      const expected = yield* Ref.get(lastMtime);
-
-      if (Math.abs(currentMtime.getTime() - expected) > 1000) {
-        yield* Effect.logError(
-          `Lock compromised: mtime changed externally (expected ${expected}, got ${currentMtime.getTime()})`,
-        );
-        yield* Deferred.succeed(shutdownSignal, void 0);
-        return;
-      }
-
-      const now = new Date();
-      yield* fs.utimes(pidFile, now, now).pipe(
-        Effect.catchTag("PlatformError", (err) => {
-          Effect.logWarning(`Failed to update lock mtime: ${err.message}`);
-          return Effect.void;
-        }),
-      );
-      yield* Ref.set(lastMtime, now.getTime());
-    });
-
-    return yield* touch.pipe(
-      Effect.repeat(Schedule.spaced(LOCK_UPDATE_INTERVAL)),
-      Effect.asVoid,
-      Effect.forkChild,
-    );
-  });

package/src/Daemon/ProcessRegistry.ts

@@ -1,284 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as HashMap from "effect/HashMap";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as PubSub from "effect/PubSub";
-import * as Ref from "effect/Ref";
-import * as Scope from "effect/Scope";
-import * as Stream from "effect/Stream";
-import * as ChildProcess from "effect/unstable/process/ChildProcess";
-import {
-  ChildProcessSpawner,
-  type ChildProcessHandle,
-} from "effect/unstable/process/ChildProcessSpawner";
-import { type SQLiteConnection } from "../SQLite/index.ts";
-import { ensureAlchemyDir, PROCESSES_DIR } from "./Config.ts";
-import { ProcessAlreadyExists, ProcessNotFound } from "./Errors.ts";
-
-interface OutputMessage {
-  readonly fd: "stdout" | "stderr";
-  readonly text: string;
-}
-
-interface ManagedProcess {
-  readonly id: string;
-  readonly handle: ChildProcessHandle;
-  readonly pubsub: PubSub.PubSub<OutputMessage>;
-  readonly stdoutLogPath: string;
-  readonly stderrLogPath: string;
-  readonly cursors: Ref.Ref<
-    HashMap.HashMap<string, { stdoutOffset: number; stderrOffset: number }>
-  >;
-}
-
-type Registry = Ref.Ref<HashMap.HashMap<string, ManagedProcess>>;
-
-export const makeProcessRegistry = (db: SQLiteConnection) =>
-  Effect.gen(function* () {
-    const registry: Registry = yield* Ref.make(
-      HashMap.empty<string, ManagedProcess>(),
-    );
-
-    const fs = yield* FileSystem.FileSystem;
-    const pathSvc = yield* Path.Path;
-    const spawner = yield* ChildProcessSpawner;
-    const alchemyDir = yield* ensureAlchemyDir;
-    const processesDir = pathSvc.join(alchemyDir, PROCESSES_DIR);
-    yield* fs.makeDirectory(processesDir, { recursive: true });
-
-    const spawnProcess = (req: {
-      id: string;
-      command: string;
-      args: ReadonlyArray<string>;
-      cwd?: string;
-      env?: Record<string, string>;
-    }) =>
-      Effect.gen(function* () {
-        const current = yield* Ref.get(registry);
-        const existing = HashMap.get(current, req.id);
-
-        if (Option.isSome(existing)) {
-          const alive = yield* existing.value.handle.isRunning;
-          if (alive) {
-            return yield* Effect.fail(new ProcessAlreadyExists({ id: req.id }));
-          }
-          yield* Ref.update(registry, HashMap.remove(req.id));
-        }
-
-        const logDir = pathSvc.join(processesDir, req.id);
-        yield* fs.makeDirectory(logDir, { recursive: true });
-        const stdoutLogPath = pathSvc.join(logDir, "stdout.log");
-        const stderrLogPath = pathSvc.join(logDir, "stderr.log");
-
-        yield* fs
-          .writeFile(stdoutLogPath, new Uint8Array(0))
-          .pipe(Effect.ignore);
-        yield* fs
-          .writeFile(stderrLogPath, new Uint8Array(0))
-          .pipe(Effect.ignore);
-
-        const cmd = ChildProcess.make(req.command, req.args as string[], {
-          cwd: req.cwd,
-          env: req.env,
-        });
-        const childScope = yield* Scope.make();
-        const handle = yield* Scope.provide(spawner.spawn(cmd), childScope);
-
-        const insertStmt = yield* db.prepare(
-          "INSERT OR REPLACE INTO processes (id, pid, command, args, cwd) VALUES (?, ?, ?, ?, ?)",
-        );
-        yield* insertStmt.run(
-          req.id,
-          handle.pid,
-          req.command,
-          JSON.stringify(req.args),
-          req.cwd ?? null,
-        );
-
-        const pubsub = yield* PubSub.unbounded<OutputMessage>();
-        const cursors = yield* Ref.make(
-          HashMap.empty<
-            string,
-            { stdoutOffset: number; stderrOffset: number }
-          >(),
-        );
-
-        const collectStream = (
-          stream: Stream.Stream<Uint8Array, any>,
-          fd: "stdout" | "stderr",
-          logPath: string,
-        ) =>
-          Effect.scoped(
-            Effect.gen(function* () {
-              const logFile = yield* fs.open(logPath, { flag: "a" });
-
-              yield* stream.pipe(
-                Stream.runForEach((chunk) =>
-                  Effect.gen(function* () {
-                    yield* logFile.writeAll(chunk);
-                    const text = new TextDecoder().decode(chunk);
-                    yield* PubSub.publish(pubsub, { fd, text });
-                  }),
-                ),
-                Effect.ignore,
-              );
-            }),
-          );
-
-        yield* collectStream(handle.stdout, "stdout", stdoutLogPath).pipe(
-          Effect.forkDetach,
-        );
-        yield* collectStream(handle.stderr, "stderr", stderrLogPath).pipe(
-          Effect.forkDetach,
-        );
-
-        const managed: ManagedProcess = {
-          id: req.id,
-          handle,
-          pubsub,
-          stdoutLogPath,
-          stderrLogPath,
-          cursors,
-        };
-
-        yield* Ref.update(registry, HashMap.set(req.id, managed));
-
-        return { pid: handle.pid };
-      });
-
-    const killProcess = (req: { id: string; killSignal?: string }) =>
-      Effect.gen(function* () {
-        const current = yield* Ref.get(registry);
-        const existing = HashMap.get(current, req.id);
-
-        if (Option.isNone(existing)) {
-          return yield* Effect.fail(new ProcessNotFound({ id: req.id }));
-        }
-
-        const proc = existing.value;
-        yield* proc.handle
-          .kill(
-            req.killSignal
-              ? { killSignal: req.killSignal as ChildProcess.Signal }
-              : undefined,
-          )
-          .pipe(Effect.ignore);
-        yield* proc.handle.exitCode.pipe(Effect.ignore);
-
-        const delStmt = yield* db.prepare("DELETE FROM processes WHERE id = ?");
-        yield* delStmt.run(req.id);
-
-        yield* Ref.update(registry, HashMap.remove(req.id));
-      });
-
-    const watchProcess = (req: { id: string; clientId: string }) =>
-      Stream.unwrap(
-        Effect.gen(function* () {
-          const current = yield* Ref.get(registry);
-          const existing = HashMap.get(current, req.id);
-
-          if (Option.isNone(existing)) {
-            return yield* Effect.fail(new ProcessNotFound({ id: req.id }));
-          }
-
-          const proc = existing.value;
-
-          const allCursors = yield* Ref.get(proc.cursors);
-          const cursor = Option.getOrElse(
-            HashMap.get(allCursors, req.clientId),
-            () => ({ stdoutOffset: 0, stderrOffset: 0 }),
-          );
-
-          const replayFile = (
-            logPath: string,
-            fd: "stdout" | "stderr",
-            offset: number,
-          ) =>
-            Effect.gen(function* () {
-              const content = yield* fs
-                .readFile(logPath)
-                .pipe(
-                  Effect.catchTag("PlatformError", () =>
-                    Effect.succeed(new Uint8Array(0)),
-                  ),
-                );
-              if (offset >= content.byteLength)
-                return { messages: [] as OutputMessage[], newOffset: offset };
-              const chunk = content.slice(offset);
-              const text = new TextDecoder().decode(chunk);
-              return {
-                messages: [{ fd, text } as OutputMessage],
-                newOffset: content.byteLength,
-              };
-            });
-
-          const stdoutReplay = yield* replayFile(
-            proc.stdoutLogPath,
-            "stdout",
-            cursor.stdoutOffset,
-          );
-          const stderrReplay = yield* replayFile(
-            proc.stderrLogPath,
-            "stderr",
-            cursor.stderrOffset,
-          );
-
-          const replayMessages = [
-            ...stdoutReplay.messages,
-            ...stderrReplay.messages,
-          ].filter((m) => m.text.length > 0);
-
-          const cursorUpdate = Stream.fromEffect(
-            Effect.as(
-              Ref.update(
-                proc.cursors,
-                HashMap.set(req.clientId, {
-                  stdoutOffset: stdoutReplay.newOffset,
-                  stderrOffset: stderrReplay.newOffset,
-                }),
-              ),
-              undefined as never,
-            ),
-          ).pipe(Stream.filter((_): _ is never => false));
-
-          const replayStream = Stream.concat(
-            Stream.fromIterable(replayMessages),
-            cursorUpdate,
-          );
-
-          const isRunning = yield* proc.handle.isRunning.pipe(
-            Effect.catchTag("PlatformError", () => Effect.succeed(false)),
-          );
-
-          if (!isRunning) {
-            return replayStream;
-          }
-
-          const liveStream = Stream.fromPubSub(proc.pubsub).pipe(
-            Stream.tap((msg) =>
-              Ref.update(proc.cursors, (cursorsMap) => {
-                const cur = Option.getOrElse(
-                  HashMap.get(cursorsMap, req.clientId),
-                  () => ({
-                    stdoutOffset: cursor.stdoutOffset,
-                    stderrOffset: cursor.stderrOffset,
-                  }),
-                );
-                const byteLen = new TextEncoder().encode(msg.text).byteLength;
-                return HashMap.set(cursorsMap, req.clientId, {
-                  stdoutOffset:
-                    cur.stdoutOffset + (msg.fd === "stdout" ? byteLen : 0),
-                  stderrOffset:
-                    cur.stderrOffset + (msg.fd === "stderr" ? byteLen : 0),
-                });
-              }),
-            ),
-          );
-
-          return Stream.concat(replayStream, liveStream);
-        }),
-      );
-
-    return { registry, spawnProcess, killProcess, watchProcess };
-  });

package/src/Daemon/RpcSchema.ts

@@ -1,43 +0,0 @@
-import * as Schema from "effect/Schema";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
-import { ProcessAlreadyExists, ProcessNotFound } from "./Errors.ts";
-
-const heartbeat = Rpc.make("heartbeat", {
-  success: Schema.Void,
-});
-
-const spawn = Rpc.make("spawn", {
-  payload: {
-    id: Schema.String,
-    command: Schema.String,
-    args: Schema.Array(Schema.String),
-    cwd: Schema.optionalKey(Schema.String),
-    env: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
-  },
-  error: ProcessAlreadyExists,
-  success: Schema.Struct({ pid: Schema.Number }),
-});
-
-const kill = Rpc.make("kill", {
-  payload: {
-    id: Schema.String,
-    killSignal: Schema.optionalKey(Schema.String),
-  },
-  error: ProcessNotFound,
-  success: Schema.Void,
-});
-
-const watch = Rpc.make("watch", {
-  payload: {
-    id: Schema.String,
-    clientId: Schema.String,
-  },
-  success: Schema.Struct({
-    fd: Schema.Literals(["stdout", "stderr"]),
-    text: Schema.String,
-  }),
-  error: ProcessNotFound,
-  stream: true,
-});
-
-export class DaemonRpcs extends RpcGroup.make(heartbeat, spawn, kill, watch) {}