alchemy 2.0.0-beta.3 → 2.0.0-beta.31

package/src/AWS/Account.ts

@@ -1,56 +0,0 @@
-import * as Auth from "@distilled.cloud/aws/Auth";
-import * as STS from "@distilled.cloud/aws/sts";
-import * as Context from "effect/Context";
-import * as Data from "effect/Data";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { StageConfig } from "./StageConfig.ts";
-
-export class FailedToGetAccount extends Data.TaggedError(
-  "AWS::Account::FailedToGetAccount",
-)<{
-  message: string;
-  cause: Error;
-}> {}
-
-export type AccountID = string;
-
-export class Account extends Context.Service<Account, AccountID>()(
-  "AWS::AccountID",
-) {}
-
-export class AWSStageConfigAccountMissing extends Data.TaggedError(
-  "AWSStageConfigAccountMissing",
-)<{
-  message: string;
-  stage: string;
-}> {}
-
-export const fromStageConfig = () =>
-  Layer.effect(
-    Account,
-    Effect.gen(function* () {
-      const config = yield* StageConfig;
-      if (config.account) {
-        return config.account;
-      }
-      const profileName = config.profile;
-      if (profileName) {
-        const profile = yield* Auth.loadProfile(profileName);
-        if (profile.sso_account_id) {
-          return profile.sso_account_id;
-        }
-      }
-      const identity = yield* STS.getCallerIdentity({}).pipe(
-        Effect.catch((err) =>
-          Effect.fail(
-            new FailedToGetAccount({
-              message: "Failed to look up account ID",
-              cause: err,
-            }),
-          ),
-        ),
-      );
-      return identity.Account!;
-    }),
-  );

package/src/AWS/Profile.ts

@@ -1,5 +0,0 @@
-import * as Context from "effect/Context";
-
-export class Profile extends Context.Service<Profile, string>()(
-  "AWS::Profile",
-) {}

package/src/AWS/StageConfig.ts

@@ -1,44 +0,0 @@
-import * as Auth from "@distilled.cloud/aws/Auth";
-import type { AwsCredentialIdentity } from "@smithy/types";
-import * as Config from "effect/Config";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import type { AccountID } from "./Account.ts";
-import { AWS_REGION, type RegionID } from "./Region.ts";
-
-export const AWS_PROFILE = Config.string("AWS_PROFILE").pipe(
-  Config.withDefault("default"),
-);
-
-export class StageConfig extends Context.Service<
-  StageConfig,
-  {
-    account?: AccountID;
-    region?: RegionID;
-    profile?: string;
-    credentials?: AwsCredentialIdentity;
-    endpoint?: string;
-  }
->()("AWS::StageConfig") {}
-
-export const DefaultStageConfig = Layer.effect(
-  StageConfig,
-  Effect.suspend(() => loadDefaultStageConfig()),
-).pipe(Layer.orDie);
-
-export const loadDefaultStageConfig = () =>
-  Effect.gen(function* () {
-    const profileName = yield* AWS_PROFILE;
-    const profile = yield* Auth.loadProfile(profileName);
-    if (!profile.sso_account_id) {
-      return yield* Effect.die(
-        `AWS SSO Profile '${profileName}' is missing sso_account_id configuration`,
-      );
-    }
-    return {
-      profile: profileName,
-      account: profile.sso_account_id,
-      region: profile.region ?? (yield* AWS_REGION),
-    };
-  });

package/src/Cloudflare/Account.ts

@@ -1,38 +0,0 @@
-import * as Config from "effect/Config";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import { StageConfig } from "./StageConfig.ts";
-
-export class Account extends Context.Service<Account, string>()(
-  "cloudflare/account-id",
-) {}
-
-export const fromEnv = () =>
-  Layer.effect(
-    Account,
-    Effect.gen(function* () {
-      const accountId = yield* Config.string("CLOUDFLARE_ACCOUNT_ID");
-      if (!accountId) {
-        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
-      }
-      return accountId;
-    }),
-  );
-
-export const fromStageConfig = () =>
-  Layer.effect(
-    Account,
-    Effect.gen(function* () {
-      const stageConfig = yield* Effect.serviceOption(StageConfig).pipe(
-        Effect.map(Option.getOrUndefined),
-      );
-      const account =
-        stageConfig?.account ?? (yield* Config.string("CLOUDFLARE_ACCOUNT_ID"));
-      if (!account) {
-        return yield* Effect.die("CLOUDFLARE_ACCOUNT_ID is not set");
-      }
-      return account;
-    }),
-  );

package/src/Cloudflare/StageConfig.ts

@@ -1,8 +0,0 @@
-import * as Context from "effect/Context";
-
-export class StageConfig extends Context.Service<
-  StageConfig,
-  {
-    account?: string;
-  }
->()("Cloudflare::StageConfig") {}

package/src/Config.ts

@@ -1,31 +0,0 @@
-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";
-
-export type cwd = typeof cwd;
-
-/**
- * Placeholder for referencing the current working directory in module-scoped code.
- *
- * Will be replaced lazily with the actual current working directory (as provided by Effect context).
- */
-export const cwd = { type: "cwd" } as const;
-
-export const isCwd = (x: any): x is cwd => x?.type === "cwd";
-
-export class DotAlchemy extends Context.Service<DotAlchemy, string>()(
-  ".alchemy",
-) {}
-
-export const dotAlchemy = Layer.effect(
-  DotAlchemy,
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const dir = path.join(process.cwd(), ".alchemy");
-    yield* fs.makeDirectory(dir, { recursive: true });
-    return dir;
-  }),
-);

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