alchemy 2.0.0-beta.76 → 2.0.0-beta.77

package/src/Fly/AuthProvider.ts

@@ -2,258 +2,70 @@ import {
   DEFAULT_API_BASE_URL,
   normalizeApiBaseUrl,
 } from "@distilled.cloud/fly-io";
-import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
-import * as Match from "effect/Match";
 import * as Redacted from "effect/Redacted";
+import { getEnv, getEnvRedactedRequired } from "../Auth/Env.ts";
 import {
-  AuthError,
-  AuthProviderLayer,
-  type ConfigureContext,
-} from "../Auth/AuthProvider.ts";
-import { CredentialsStore, displayRedacted } from "../Auth/Credentials.ts";
-import { getEnv, getEnvRedacted, retryOnce } from "../Auth/Env.ts";
-import { AlchemyProfile } from "../Auth/Profile.ts";
-import * as Clank from "../Util/Clank.ts";
+  makeStoredAuthProvider,
+  storedSecret,
+  storedValueText,
+  type StoredAuthConfig,
+} from "../Auth/StoredAuthProvider.ts";
 
 export const FLY_AUTH_PROVIDER_NAME = "Fly";
 export const FLY_API_TOKEN_ENV = "FLY_API_TOKEN";
 export const FLY_API_HOSTNAME_ENV = "FLY_API_HOSTNAME";
 
-const STORAGE_KEY = "fly-stored";
-
-export type FlyAuthConfig = { method: "env" } | { method: "stored" };
-
-export type FlyStoredCredentials = {
-  type: "token";
-  apiKey: string;
-  apiBaseUrl?: string;
-};
+export type FlyAuthConfig = StoredAuthConfig;
 
 export type FlyResolvedCredentials = {
   type: "token";
   apiKey: Redacted.Redacted<string>;
   apiBaseUrl: string;
-  source: { type: FlyAuthConfig["method"]; details?: string };
+  source: { type: FlyAuthConfig["method"] | "env"; details?: string };
 };
 
-const options: Array<{
-  value: FlyAuthConfig["method"];
-  label: string;
-  hint?: string;
-}> = [
-  {
-    value: "env",
-    label: "Environment Variables",
-    hint: `${FLY_API_TOKEN_ENV} + optional ${FLY_API_HOSTNAME_ENV}`,
-  },
-  {
-    value: "stored",
-    label: "API Token",
-    hint: "enter interactively, stored in ~/.alchemy/credentials",
-  },
-];
-
 const resolveApiBaseUrl = (explicit?: string) =>
   getEnv(FLY_API_HOSTNAME_ENV).pipe(
     Effect.map((fromEnv) => normalizeApiBaseUrl(explicit ?? fromEnv)),
   );
 
-/**
- * Layer that registers the Fly {@link AuthProvider} into the
- * {@link AuthProviders} registry. Include this in the Fly `providers()`
- * layer so `alchemy login` can discover it.
- *
- * Auth is a Fly.io API token (`FLY_API_TOKEN`). There is no OAuth flow.
- * An optional `FLY_API_HOSTNAME` overrides the Machines API root
- * (default `https://api.machines.dev/v1`).
- */
-export const FlyAuth = AuthProviderLayer<
-  FlyAuthConfig,
-  FlyResolvedCredentials
->()(
-  FLY_AUTH_PROVIDER_NAME,
-  Effect.gen(function* () {
-    const profiles = yield* AlchemyProfile;
-    const store = yield* CredentialsStore;
-
-    const loginStored = Effect.fn(function* (profileName: string) {
-      const apiKey = yield* Clank.password({
-        message: "Fly.io API Token",
-        validate: (v) => (v.length === 0 ? "Required" : undefined),
-      }).pipe(retryOnce);
-
-      const envHostname = yield* getEnv(FLY_API_HOSTNAME_ENV);
-      const hostnamePrompt = yield* Clank.text({
-        message: "Fly API hostname (Enter for default)",
-        placeholder: DEFAULT_API_BASE_URL,
-        defaultValue: envHostname ?? DEFAULT_API_BASE_URL,
-      }).pipe(retryOnce);
-      const trimmed = (hostnamePrompt ?? "").trim();
-      const apiBaseUrl =
-        trimmed.length > 0 && trimmed !== DEFAULT_API_BASE_URL
-          ? trimmed
-          : undefined;
-
-      yield* store.write<FlyStoredCredentials>(profileName, STORAGE_KEY, {
-        type: "token",
-        apiKey,
-        apiBaseUrl,
-      });
-      yield* Clank.success("Fly: credentials saved.");
-      return { method: "stored" as const };
-    });
-
-    const configureInteractive = (profileName: string) =>
-      Clank.select({
-        message: "Fly authentication method",
-        options,
-      }).pipe(
-        Effect.flatMap((method) =>
-          Match.value(method).pipe(
-            Match.when("env", () => Effect.succeed({ method: "env" as const })),
-            Match.when("stored", () => loginStored(profileName)),
-            Match.exhaustive,
-          ),
-        ),
-      );
-
-    const configureCredentials = (profileName: string, ctx: ConfigureContext) =>
-      Effect.gen(function* () {
-        if (ctx.ci) {
-          return { method: "env" as const };
-        }
-        return yield* configureInteractive(profileName);
-      }).pipe(
-        Effect.mapError(
-          (e) =>
-            new AuthError({
-              message: "failed to configure credentials",
-              cause: e,
-            }),
-        ),
-      );
-
-    const resolveCredentials = (
-      profileName: string,
-      config: FlyAuthConfig,
-    ): Effect.Effect<FlyResolvedCredentials, AuthError> =>
-      Match.value(config).pipe(
-        Match.when(
-          { method: "env" },
-          Effect.fn(function* () {
-            const apiKey = yield* getEnvRedacted(FLY_API_TOKEN_ENV);
-            if (!apiKey) {
-              return yield* new AuthError({
-                message: `Fly env credentials not found. Set ${FLY_API_TOKEN_ENV}.`,
-              });
-            }
-            const apiBaseUrl = yield* resolveApiBaseUrl();
-            return {
-              type: "token" as const,
-              apiKey,
-              apiBaseUrl,
-              source: { type: "env" as const, details: FLY_API_TOKEN_ENV },
-            };
-          }),
-        ),
-        Match.when({ method: "stored" }, () =>
-          store.read<FlyStoredCredentials>(profileName, STORAGE_KEY).pipe(
-            Effect.flatMap((creds) =>
-              creds == null
-                ? Effect.fail(
-                    new AuthError({
-                      message:
-                        "Fly stored credentials not found. Run: alchemy login --configure",
-                    }),
-                  )
-                : resolveApiBaseUrl(creds.apiBaseUrl).pipe(
-                    Effect.map((apiBaseUrl) => ({
-                      type: "token" as const,
-                      apiKey: Redacted.make(creds.apiKey),
-                      apiBaseUrl,
-                      source: { type: "stored" as const },
-                    })),
-                  ),
-            ),
-          ),
-        ),
-        Match.exhaustive,
-      );
-
-    const logout = (profileName: string, config: FlyAuthConfig) =>
-      Match.value(config).pipe(
-        Match.when({ method: "env" }, () => Effect.void),
-        Match.when({ method: "stored" }, () =>
-          store
-            .delete(profileName, STORAGE_KEY)
-            .pipe(
-              Effect.andThen(Clank.success("Fly: stored credentials removed")),
-            ),
-        ),
-        Match.exhaustive,
-      );
-
-    const login = (profileName: string, config: FlyAuthConfig) =>
-      Match.value(config)
-        .pipe(
-          Match.when({ method: "env" }, () =>
-            // If FLY_API_TOKEN isn't set, fall through to the interactive picker
-            // so the user can switch to `stored` (or be told to set the env var)
-            // instead of silently failing later in `read`. The new selection is
-            // persisted to the profile so subsequent logins don't re-prompt.
-            getEnvRedacted(FLY_API_TOKEN_ENV).pipe(
-              Effect.flatMap((apiKey) =>
-                apiKey
-                  ? Effect.void
-                  : Effect.gen(function* () {
-                      const next = yield* configureInteractive(profileName);
-                      const existing = yield* profiles.getProfile(profileName);
-                      yield* profiles.setProfile(profileName, {
-                        ...existing,
-                        [FLY_AUTH_PROVIDER_NAME]: next,
-                      });
-                    }),
-              ),
-            ),
-          ),
-          Match.when({ method: "stored" }, () =>
-            store
-              .read<FlyStoredCredentials>(profileName, STORAGE_KEY)
-              .pipe(
-                Effect.flatMap((creds) =>
-                  creds == null ? loginStored(profileName) : Effect.void,
-                ),
-              ),
-          ),
-          Match.exhaustive,
-        )
-        .pipe(
-          Effect.mapError(
-            (e) => new AuthError({ message: "login failed", cause: e }),
-          ),
-        );
-
-    const prettyPrint = (profileName: string, config: FlyAuthConfig) =>
-      resolveCredentials(profileName, config).pipe(
-        Effect.tap((creds) => {
-          const sourceStr = creds.source.details
-            ? `${creds.source.type} - ${creds.source.details}`
-            : creds.source.type;
-          return Effect.all([
-            Console.log(`  apiKey: ${displayRedacted(creds.apiKey, 6)}`),
-            Console.log(`  apiBaseUrl: ${creds.apiBaseUrl}`),
-            Console.log(`  source: ${sourceStr}`),
-          ]);
-        }),
-      );
-
+const flyAuth = makeStoredAuthProvider<FlyResolvedCredentials>({
+  provider: FLY_AUTH_PROVIDER_NAME,
+  fields: [
+    { name: "apiKey", label: "Fly.io API Token", secret: true },
+    {
+      name: "apiBaseUrl",
+      label: "Fly API hostname",
+      placeholder: DEFAULT_API_BASE_URL,
+      optional: true,
+    },
+  ],
+  toResolved: (values) => ({
+    type: "token",
+    apiKey: storedSecret(values.apiKey) ?? Redacted.make(""),
+    apiBaseUrl: normalizeApiBaseUrl(storedValueText(values.apiBaseUrl)),
+    source: { type: "stored" },
+  }),
+  readEnvironment: Effect.gen(function* () {
+    const apiKey = yield* getEnvRedactedRequired(FLY_API_TOKEN_ENV);
+    const apiBaseUrl = yield* resolveApiBaseUrl();
     return {
-      configure: configureCredentials,
-      logout,
-      login,
-      prettyPrint,
-      read: resolveCredentials,
+      type: "token" as const,
+      apiKey,
+      apiBaseUrl,
+      source: { type: "env" as const, details: FLY_API_TOKEN_ENV },
     };
   }),
-);
+  environment: [
+    { name: FLY_API_TOKEN_ENV, required: true, secret: true },
+    { name: FLY_API_HOSTNAME_ENV, required: false },
+  ],
+});
+
+/**
+ * Layer that registers the Fly {@link AuthProvider} into the
+ * {@link AuthProviders} registry. Fly uses a stored API token locally and
+ * `FLY_API_TOKEN` in CI; `FLY_API_HOSTNAME` optionally overrides the API root.
+ */
+export const FlyAuth = flyAuth.layer;

package/src/Fly/CheckpointHttp.ts

@@ -1,8 +1,8 @@
-import { CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as sprites from "@distilled.cloud/fly-io/sprites";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsFromAmbientOrEnv } from "./Credentials.ts";
 import { Checkpoint, type CheckpointClient } from "./Checkpoint.ts";
 import { makeHttpSpriteBinding } from "./SpriteHttp.ts";
 
@@ -62,4 +62,7 @@ export const CheckpointHttp = Layer.effect(
       }),
     }),
   ),
-).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(CredentialsFromEnv));
+).pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CredentialsFromAmbientOrEnv),
+);

package/src/Fly/Credentials.ts

@@ -1,10 +1,9 @@
 import { ConfigError } from "@distilled.cloud/core/errors";
-import { Credentials } from "@distilled.cloud/fly-io";
-import * as Config from "effect/Config";
+import { Credentials, CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import { getAuthProvider } from "../Auth/AuthProvider.ts";
-import { ALCHEMY_PROFILE, AlchemyProfile } from "../Auth/Profile.ts";
+import * as Option from "effect/Option";
+import { resolveProviderConfig } from "../Auth/Resolve.ts";
 import {
   FLY_AUTH_PROVIDER_NAME,
   type FlyAuthConfig,
@@ -21,9 +20,29 @@ export {
 } from "@distilled.cloud/fly-io";
 
 /**
- * Build a `Credentials` layer that resolves Fly credentials via the
- * Alchemy AuthProvider using the configured profile (defaults to "default",
- * overridable with the `ALCHEMY_PROFILE` env/config value).
+ * `Credentials` for the HTTP binding layers (`GetSecretHttp`, `ExecHttp`, …).
+ *
+ * Those layers are built in two places. Inside a stack (plan/deploy, or an
+ * Action) `providers()` has already resolved the profile-backed
+ * `Credentials`, and the binding must use them — a laptop deploy has no
+ * `FLY_API_TOKEN` in its env once the token lives in the Alchemy profile.
+ * Inside a deployed Machine there is no profile; the host injected
+ * `FLY_API_TOKEN` into the process env (see `SecretHttp.ts`). So: reuse the
+ * ambient `Credentials` when present, otherwise read the env.
+ */
+export const CredentialsFromAmbientOrEnv: Layer.Layer<Credentials> =
+  Layer.effect(
+    Credentials,
+    Effect.gen(function* () {
+      const ambient = yield* Effect.serviceOption(Credentials);
+      if (Option.isSome(ambient)) return ambient.value;
+      return yield* Credentials.pipe(Effect.provide(CredentialsFromEnv));
+    }),
+  );
+
+/**
+ * Build a `Credentials` layer that resolves Fly credentials via the current
+ * Alchemy profile, or directly from environment variables in CI.
  *
  * Maps onto `@distilled.cloud/fly-io`'s `{ apiKey, apiBaseUrl }` shape.
  * Distilled's own `CredentialsFromEnv` also accepts `FLY_IO_API_KEY` as a
@@ -33,18 +52,12 @@ export const fromAuthProvider = () =>
   Layer.effect(
     Credentials,
     Effect.gen(function* () {
-      const profile = yield* AlchemyProfile;
-      const auth = yield* getAuthProvider<
+      const { profileName, resolve } = yield* resolveProviderConfig<
         FlyAuthConfig,
         FlyResolvedCredentials
       >(FLY_AUTH_PROVIDER_NAME);
-      const profileName = yield* ALCHEMY_PROFILE;
-      const ci = yield* Config.boolean("CI").pipe(Config.withDefault(false));
 
-      return yield* profile.loadOrConfigure(auth, profileName, { ci }).pipe(
-        Effect.flatMap((config) =>
-          auth.read(profileName, config as FlyAuthConfig),
-        ),
+      return yield* resolve.pipe(
         Effect.map((creds) => ({
           apiKey: creds.apiKey,
           apiBaseUrl: creds.apiBaseUrl,
@@ -52,7 +65,7 @@ export const fromAuthProvider = () =>
         Effect.mapError(
           (e) =>
             new ConfigError({
-              message: `Failed to resolve Fly credentials for profile '${profileName}': ${(e as { message?: string }).message ?? String(e)}`,
+              message: `Failed to resolve Fly credentials from ${profileName === undefined ? "the CI environment" : `profile '${profileName}'`}: ${(e as { message?: string }).message ?? String(e)}`,
             }),
         ),
         Effect.orDie,

package/src/Fly/DecryptHttp.ts

@@ -1,9 +1,9 @@
-import { CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as machines from "@distilled.cloud/fly-io/machines";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsFromAmbientOrEnv } from "./Credentials.ts";
 import { Decrypt, type DecryptRequest } from "./Decrypt.ts";
 import { unwrapSecretValue } from "./SecretHttp.ts";
 import {
@@ -54,4 +54,7 @@ export const DecryptHttp = Layer.effect(
         }),
     }),
   ),
-).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(CredentialsFromEnv));
+).pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CredentialsFromAmbientOrEnv),
+);

package/src/Fly/EncryptHttp.ts

@@ -1,8 +1,8 @@
-import { CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as machines from "@distilled.cloud/fly-io/machines";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsFromAmbientOrEnv } from "./Credentials.ts";
 import { Encrypt, type EncryptRequest } from "./Encrypt.ts";
 import {
   base64ToBytes,
@@ -48,4 +48,7 @@ export const EncryptHttp = Layer.effect(
         }),
     }),
   ),
-).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(CredentialsFromEnv));
+).pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CredentialsFromAmbientOrEnv),
+);

package/src/Fly/ExecHttp.ts

@@ -1,8 +1,8 @@
-import { CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as sprites from "@distilled.cloud/fly-io/sprites";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsFromAmbientOrEnv } from "./Credentials.ts";
 import { Exec, type ExecRequest } from "./Exec.ts";
 import { makeHttpSpriteBinding } from "./SpriteHttp.ts";
 
@@ -43,4 +43,7 @@ export const ExecHttp = Layer.effect(
         }),
     }),
   ),
-).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(CredentialsFromEnv));
+).pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CredentialsFromAmbientOrEnv),
+);

package/src/Fly/GetSecretHttp.ts

@@ -1,10 +1,10 @@
-import { CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as machines from "@distilled.cloud/fly-io/machines";
 import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as Redacted from "effect/Redacted";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsFromAmbientOrEnv } from "./Credentials.ts";
 import { GetSecret } from "./GetSecret.ts";
 import { makeHttpSecretBinding } from "./SecretHttp.ts";
 
@@ -56,4 +56,7 @@ export const GetSecretHttp = Layer.effect(
         }),
     }),
   ),
-).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(CredentialsFromEnv));
+).pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CredentialsFromAmbientOrEnv),
+);

package/src/Fly/ListSecretsHttp.ts

@@ -1,8 +1,8 @@
-import { CredentialsFromEnv } from "@distilled.cloud/fly-io";
 import * as machines from "@distilled.cloud/fly-io/machines";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import { CredentialsFromAmbientOrEnv } from "./Credentials.ts";
 import { ListSecrets } from "./ListSecrets.ts";
 import { makeHttpAppBinding } from "./SecretHttp.ts";
 
@@ -39,4 +39,7 @@ export const ListSecretsHttp = Layer.effect(
         }),
     }),
   ),
-).pipe(Layer.provide(FetchHttpClient.layer), Layer.provide(CredentialsFromEnv));
+).pipe(
+  Layer.provide(FetchHttpClient.layer),
+  Layer.provide(CredentialsFromAmbientOrEnv),
+);

package/src/Fly/Machine.ts

@@ -27,6 +27,7 @@ import {
   observeReplicaSet,
   reconcileReplicas,
   resolveCount,
+  toFlyService,
   volumeIdsOf,
   type Replica,
   type ReplicaSet,
@@ -105,6 +106,37 @@ export interface MachinePort {
   endPort?: number;
 }
 
+/** A health check attached to a Fly service. */
+export interface MachineServiceCheck {
+  /** Check type. HTTP checks send a request; TCP checks open a connection. */
+  type: "http" | "tcp";
+  /** Port to check. Usually the service's {@link MachineService.internalPort}. */
+  port?: number;
+  /** Time between checks, such as `"15s"`. */
+  interval?: string;
+  /** Maximum time for a check, such as `"2s"`. */
+  timeout?: string;
+  /** Delay after the Machine starts before checks begin, such as `"30s"`. */
+  gracePeriod?: string;
+  /** HTTP method for an `http` check. */
+  method?: string;
+  /** Request path for an `http` check. */
+  path?: string;
+  /** Request protocol for an `http` check. */
+  protocol?: "http" | "https";
+  /** Headers sent by an `http` check. */
+  headers?: Array<{
+    /** Header name. */
+    name: string;
+    /** Header values. */
+    values: string[];
+  }>;
+  /** Hostname used to validate the certificate for an HTTPS check. */
+  tlsServerName?: string;
+  /** Skip certificate verification for an HTTPS check. */
+  tlsSkipVerify?: boolean;
+}
+
 export interface MachineService {
   /**
    * Proxy protocol (`tcp` or `udp`).
@@ -122,6 +154,8 @@ export interface MachineService {
   autostop?: "off" | "stop" | "suspend" | boolean;
   /** Minimum Machines to keep running for this service. */
   minMachinesRunning?: number;
+  /** Health checks for this service. */
+  checks?: MachineServiceCheck[];
 }
 
 export type MachineMount = DiskSpec;
@@ -410,6 +444,39 @@ export type Machine = Resource<
  * });
  * ```
  *
+ * ### Service health checks
+ * Add HTTP or TCP `checks` to a service. Fly uses their results to
+ * determine whether the service is ready to receive traffic.
+ *
+ * **Example:** HTTP readiness check
+ * ```typescript
+ * const web = yield* Fly.Machine("Web", {
+ *   app: Site,
+ *   region: "iad",
+ *   image: "nginx:alpine",
+ *   services: [
+ *     {
+ *       protocol: "tcp",
+ *       internalPort: 80,
+ *       ports: [{ port: 80, handlers: ["http"] }],
+ *       checks: [
+ *         {
+ *           type: "http",
+ *           port: 80,
+ *           method: "GET",
+ *           path: "/health",
+ *           protocol: "http",
+ *           interval: "15s",
+ *           timeout: "2s",
+ *           gracePeriod: "30s",
+ *           headers: [{ name: "X-Health-Check", values: ["alchemy"] }],
+ *         },
+ *       ],
+ *     },
+ *   ],
+ * });
+ * ```
+ *
  * ### Autostart and autostop
  * `autostart` starts the Machine when a request arrives. `autostop` is
  * `"off"`, `"stop"`, `"suspend"`, or a boolean. `minMachinesRunning`
@@ -696,26 +763,6 @@ const toFlyRestart = (restart: MachineRestart): FlyMachineRestart => ({
   max_retries: restart.maxRetries,
 });
 
-const toFlyService = (service: MachineService): FlyMachineService => ({
-  protocol: service.protocol,
-  internal_port: service.internalPort,
-  autostart: service.autostart,
-  autostop:
-    typeof service.autostop === "boolean"
-      ? service.autostop
-        ? "stop"
-        : "off"
-      : service.autostop,
-  min_machines_running: service.minMachinesRunning,
-  ports: service.ports?.map((port) => ({
-    port: port.port,
-    handlers: port.handlers,
-    force_https: port.forceHttps,
-    start_port: port.startPort,
-    end_port: port.endPort,
-  })),
-});
-
 const desiredEnv = (
   props: MachineProps,
   bindingEnv: Record<string, any>,

package/src/Fly/Providers.ts

@@ -1,7 +1,7 @@
 import * as Layer from "effect/Layer";
 import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
 import { CredentialsStoreLive } from "../Auth/Credentials.ts";
-import { ProfileLive } from "../Auth/Profile.ts";
+import { ProfileStoreLive } from "../Auth/Profile.ts";
 import * as Command from "../Command/index.ts";
 import * as Provider from "../Provider.ts";
 import { App, AppProvider } from "./App.ts";
@@ -147,7 +147,7 @@ export const providers = () =>
     Layer.provideMerge(fromCredentials()),
     Layer.provideMerge(Credentials.fromAuthProvider()),
     Layer.provideMerge(FlyAuth),
-    Layer.provideMerge(ProfileLive),
+    Layer.provideMerge(ProfileStoreLive),
     Layer.provideMerge(CredentialsStoreLive),
     Layer.provideMerge(FetchHttpClient.layer),
     Layer.provideMerge(Command.providers()),