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

package/src/Cli/commands/profile.ts

@@ -1,132 +0,0 @@
-import * as Console from "effect/Console";
-import * as Effect from "effect/Effect";
-import * as Option from "effect/Option";
-import { Command } from "effect/unstable/cli";
-import * as Argument from "effect/unstable/cli/Argument";
-
-import { AuthProviders } from "../../Auth/AuthProvider.ts";
-import { CredentialsStore } from "../../Auth/Credentials.ts";
-import { AlchemyProfile } from "../../Auth/Profile.ts";
-
-import {
-  buildBuiltinAuthProviders,
-  buildStackProviders,
-  envFile,
-  instrumentCommand,
-  printProfile,
-  profile,
-} from "./_shared.ts";
-
-/**
- * Entrypoint whose `providers()` layer contributes the user's own auth
- * providers. Optional and best-effort — if it's missing or fails to load,
- * `profile show` still renders the built-in providers.
- */
-const mainFile = Argument.file("main").pipe(
-  Argument.withDescription(
-    "Stack entrypoint whose providers() should be used, defaults to alchemy.run.ts",
-  ),
-  Argument.withDefault("alchemy.run.ts"),
-);
-
-/**
- * Populate an {@link AuthProviders} registry for display: the built-in
- * providers first, then the user's stack `providers()` layer on top so a
- * customized provider (same name) overrides the built-in one. Loading the
- * user's stack is best-effort — a missing or invalid entrypoint leaves the
- * built-ins in place.
- *
- * Registration happens as a side effect of building each layer (see
- * `AuthProviderLayer`), and later builds overwrite earlier entries by name,
- * so build order is what gives the user's providers precedence.
- */
-export const collectAuthProviders = Effect.fn("collectAuthProviders")(
-  function* (options: {
-    main: string;
-    envFile: Option.Option<string>;
-    profile: string;
-  }) {
-    const authProviders: AuthProviders["Service"] = {};
-
-    // 1. Built-in providers first (baseline).
-    yield* buildBuiltinAuthProviders({
-      envFile: options.envFile,
-      profile: options.profile,
-      registry: authProviders,
-    });
-
-    // 2. The user's own providers() layer on top — building into the same
-    //    registry overrides the built-ins by name. Best-effort: swallow
-    //    load/build failures (including a missing entrypoint) so display
-    //    still works with just the built-ins.
-    yield* buildStackProviders({ ...options, registry: authProviders }).pipe(
-      Effect.catchCause((cause) =>
-        Effect.logDebug("profile show: could not load user stack providers", {
-          cause,
-        }),
-      ),
-    );
-
-    return authProviders;
-  },
-);
-
-const showCommand = Command.make(
-  "show",
-  { profile, envFile, main: mainFile },
-  instrumentCommand("profile.show", (a: { profile: string }) => ({
-    "alchemy.profile": a.profile,
-  }))(
-    Effect.fn(function* ({ profile, envFile, main }) {
-      const profiles = yield* AlchemyProfile;
-      const stored = yield* profiles.getProfile(profile);
-      if (stored == null) {
-        const config = yield* profiles.readConfig;
-        const names = Object.keys(config.profiles);
-        yield* Console.log(`Profile '${profile}' not found.`);
-        if (names.length > 0) {
-          yield* Console.log(`Available profiles: ${names.sort().join(", ")}`);
-        } else {
-          yield* Console.log("No profiles configured. Run `alchemy login`.");
-        }
-        return;
-      }
-
-      const authProviders = yield* collectAuthProviders({
-        main,
-        envFile,
-        profile,
-      });
-
-      yield* printProfile(profile, stored, authProviders);
-    }),
-  ),
-);
-
-const clearCommand = Command.make(
-  "clear",
-  { profile },
-  instrumentCommand("profile.clear", (a: { profile: string }) => ({
-    "alchemy.profile": a.profile,
-  }))(
-    Effect.fn(function* ({ profile }) {
-      const profiles = yield* AlchemyProfile;
-      const store = yield* CredentialsStore;
-      const removed = yield* profiles.deleteProfile(profile);
-      yield* store.deleteProfile(profile);
-      if (removed) {
-        yield* Console.log(
-          `Cleared profile '${profile}' and all its credentials.`,
-        );
-      } else {
-        yield* Console.log(
-          `Profile '${profile}' not found in profiles.json; removed any stray credentials directory.`,
-        );
-      }
-    }),
-  ),
-);
-
-export const profileCommand = Command.make("profile", {}).pipe(
-  Command.withSubcommands([showCommand, clearCommand]),
-);

package/src/Cli/commands/sync.ts

@@ -1,123 +0,0 @@
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Option from "effect/Option";
-import * as Command from "effect/unstable/cli/Command";
-import * as Flag from "effect/unstable/cli/Flag";
-
-import { AdoptPolicy } from "../../AdoptPolicy.ts";
-import { ArtifactStore, createArtifactStore } from "../../Artifacts.ts";
-import { AuthProviders } from "../../Auth/AuthProvider.ts";
-import { withProfileOverride } from "../../Auth/Profile.ts";
-import * as CLI from "../../Cli/Cli.ts";
-import { Stage } from "../../Stage.ts";
-import * as Sync from "../../Sync.ts";
-import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
-import { fileLogger } from "../../Util/FileLogger.ts";
-
-import {
-  envFile,
-  importStack,
-  instrumentCommand,
-  profile,
-  script,
-  stage,
-  yes,
-} from "./_shared.ts";
-
-const dryRunFlag = Flag.boolean("dry-run").pipe(
-  Flag.withDescription(
-    "Detect and report drift without repairing it (no reconcile, no state writes)",
-  ),
-  Flag.withDefault(false),
-);
-
-export interface SyncArgs {
-  main: string;
-  stage: string;
-  envFile: Option.Option<string>;
-  profile?: string;
-  dryRun?: boolean;
-  yes?: boolean;
-}
-
-export const execSync = Effect.fn(function* ({
-  main,
-  stage,
-  envFile,
-  profile,
-  dryRun = false,
-  yes = false,
-}: SyncArgs) {
-  const stackEffect = yield* importStack(main);
-
-  const services = Layer.mergeAll(
-    Layer.succeed(AdoptPolicy, false),
-    Layer.succeed(ArtifactStore, createArtifactStore()),
-    Layer.succeed(
-      AuthProviders,
-      yield* Effect.serviceOption(AuthProviders).pipe(
-        Effect.map(Option.getOrElse(() => ({}))),
-      ),
-    ),
-    ConfigProvider.layer(
-      withProfileOverride(yield* loadConfigProvider(envFile), profile),
-    ),
-    Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
-    Layer.succeed(Stage, stage),
-  );
-
-  yield* Effect.gen(function* () {
-    const cli = yield* CLI.Cli;
-    const stack = yield* stackEffect;
-
-    yield* Effect.gen(function* () {
-      // Detection pass: project the drift onto the engine's Plan shape so
-      // the CLI renders a sync exactly like a deploy plan (ink TUI when
-      // interactive, plain logging otherwise).
-      const { result, plan } = yield* Sync.plan({
-        name: stack.name,
-        stage: stack.stage,
-      });
-
-      if (dryRun) {
-        yield* cli.displayPlan(plan);
-        return;
-      }
-
-      const hasChanges = Object.values(result.resources).some(
-        (r) => r.action === "drifted" || r.action === "missing",
-      );
-      if (!yes && hasChanges) {
-        const approved = yield* cli.approvePlan(plan);
-        if (!approved) {
-          return;
-        }
-      }
-
-      // Repair pass: re-observes the cloud (rather than trusting the
-      // detection snapshot) and reports progress through the session.
-      const session = yield* cli.startApplySession(plan);
-      yield* Sync.sync({ name: stack.name, stage: stack.stage }, { session });
-    }).pipe(Effect.provide(stack.services));
-  }).pipe(Effect.provide(services));
-});
-
-export const syncCommand = Command.make(
-  "sync",
-  {
-    dryRun: dryRunFlag,
-    main: script,
-    envFile,
-    stage,
-    yes,
-    profile,
-  },
-  instrumentCommand("sync", (args: SyncArgs) => ({
-    "alchemy.stage": args.stage,
-    "alchemy.profile": args.profile,
-    "alchemy.main": args.main,
-    "alchemy.dry_run": !!args.dryRun,
-  }))(execSync),
-);

package/src/Cli/commands/tail.ts

@@ -1,155 +0,0 @@
-import * as ConfigProvider from "effect/ConfigProvider";
-import * as Console from "effect/Console";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Logger from "effect/Logger";
-import * as Stream from "effect/Stream";
-import * as Command from "effect/unstable/cli/Command";
-
-import { findProviderByType, type LogLine } from "../../Provider.ts";
-import { stampedMode } from "../../ProviderMode.ts";
-import { Stage } from "../../Stage.ts";
-import * as State from "../../State/index.ts";
-import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
-import { fileLogger } from "../../Util/FileLogger.ts";
-
-import { AuthProviders } from "../../Auth/AuthProvider.ts";
-import { withProfileOverride } from "../../Auth/Profile.ts";
-import {
-  envFile,
-  formatLocalTimestamp,
-  importStack,
-  instrumentCommand,
-  parseResourceFilter,
-  profile,
-  resourceFilter,
-  script,
-  stage,
-  TAIL_COLORS,
-  TAIL_RESET,
-} from "./_shared.ts";
-
-export const tailCommand = Command.make(
-  "tail",
-  {
-    main: script,
-    envFile,
-    stage,
-    profile,
-    filter: resourceFilter,
-  },
-  instrumentCommand(
-    "tail",
-    (a: { main: string; stage: string; profile: string }) => ({
-      "alchemy.stage": a.stage,
-      "alchemy.profile": a.profile,
-      "alchemy.main": a.main,
-    }),
-  )(
-    Effect.fn(function* ({ main, stage, envFile, profile, filter }) {
-      const stackEffect = yield* importStack(main);
-
-      const services = Layer.mergeAll(
-        ConfigProvider.layer(
-          withProfileOverride(yield* loadConfigProvider(envFile), profile),
-        ),
-        Layer.succeed(AuthProviders, {}),
-        Layer.succeed(Stage, stage),
-        Logger.layer([fileLogger("out")], { mergeWithExisting: true }),
-        State.localState(),
-      );
-
-      yield* Effect.gen(function* () {
-        const stack = yield* stackEffect;
-
-        yield* Effect.gen(function* () {
-          const state = yield* yield* State.State;
-          const filterSet = parseResourceFilter(filter);
-          const availableIds = [
-            ...new Set(Object.values(stack.resources).map((r) => r.LogicalId)),
-          ].sort();
-
-          if (filterSet) {
-            for (const id of filterSet) {
-              if (!availableIds.includes(id)) {
-                return yield* Effect.die(
-                  new Error(
-                    `Unknown resource '${id}' in --filter. Available: ${availableIds.join(", ") || "(none)"}`,
-                  ),
-                );
-              }
-            }
-          }
-
-          const fqns = Object.keys(stack.resources);
-          const tailable: {
-            logicalId: string;
-            stream: Stream.Stream<LogLine, any, any>;
-          }[] = [];
-
-          for (const fqn of fqns) {
-            const resource = stack.resources[fqn]!;
-            if (filterSet && !filterSet.has(resource.LogicalId)) continue;
-
-            const resourceState = yield* state.get({
-              stack: stack.name,
-              stage: stack.stage,
-              fqn,
-            });
-            if (!(resourceState as any)?.attr) continue;
-
-            // Tail with the provider variant of the mode that deployed the
-            // row (a local dev worker's logs come from the local provider).
-            const provider = yield* findProviderByType(
-              resource.Type,
-              stampedMode(resourceState as any),
-            );
-            if (!provider.tail) continue;
-
-            tailable.push({
-              logicalId: resource.LogicalId,
-              stream: provider.tail({
-                id: resource.LogicalId,
-                fqn,
-                instanceId: (resourceState as any).instanceId,
-                props: (resourceState as any).props,
-                output: (resourceState as any).attr,
-              }),
-            });
-          }
-
-          if (tailable.length === 0) {
-            if (filterSet) {
-              yield* Console.log(
-                "No tailable resources match --filter (deploy first, or selected resources may not support tail).",
-              );
-            } else {
-              yield* Console.log(
-                "No tailable resources found. Deploy first, then run tail.",
-              );
-            }
-            return;
-          }
-
-          yield* Console.log(
-            `Tailing: ${tailable.map((t) => t.logicalId).join(", ")}`,
-          );
-
-          const taggedStreams = tailable.map(({ logicalId, stream }, i) => {
-            const color = TAIL_COLORS[i % TAIL_COLORS.length]!;
-            return stream.pipe(
-              Stream.map(({ timestamp, message }) => {
-                const ts = formatLocalTimestamp(timestamp);
-                return `${color}${ts} [${logicalId}]${TAIL_RESET} ${message}`;
-              }),
-            );
-          });
-
-          yield* Stream.mergeAll(taggedStreams, {
-            concurrency: "unbounded",
-          }).pipe(Stream.runForEach((line) => Console.log(line)));
-        }).pipe(Effect.provide(stack.services));
-      }).pipe(Effect.provide(services));
-    }),
-  ),
-);

package/src/Cli/tui/InkCLI.tsx

@@ -1,69 +0,0 @@
-/** @jsxImportSource react */
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { render } from "ink";
-import type { Plan } from "../../Plan.ts";
-import { type PlanStatusSession, Cli } from "../Cli.ts";
-import type { ApplyEvent } from "../Event.ts";
-import { ApprovePlan } from "./components/ApprovePlan.tsx";
-import { Plan as PlanComponent } from "./components/Plan.tsx";
-import { PlanProgress } from "./components/PlanProgress.tsx";
-
-export const inkCLI = () =>
-  Layer.succeed(
-    Cli,
-    Cli.of({
-      approvePlan,
-      displayPlan,
-      startApplySession,
-    }),
-  );
-
-const approvePlan = Effect.fn(function* <P extends Plan>(plan: P) {
-  let approved = false;
-  const { waitUntilExit } = render(
-    <ApprovePlan plan={plan} approve={(a) => (approved = a)} />,
-  );
-  yield* Effect.promise(waitUntilExit);
-  return approved;
-});
-
-const displayPlan = <P extends Plan>(plan: P): Effect.Effect<void> =>
-  Effect.sync(() => {
-    const { unmount } = render(<PlanComponent plan={plan} />);
-    unmount();
-  });
-
-const startApplySession = Effect.fn(function* <P extends Plan>(plan: P) {
-  // Print the plan preview once into scrollback before mounting the
-  // animated progress region (mirrors LoggingCli, which prints the plan
-  // lines at session start — `alchemy dev`/`--yes` runs never call
-  // displayPlan/approvePlan, so without this the TTY path shows no plan at
-  // all). Rendering + immediately unmounting leaves the frame behind and
-  // releases the Ink instance for PlanProgress; forwarded runtime logs then
-  // insert BETWEEN the preview and the live region instead of piling above
-  // the entire transcript.
-  yield* displayPlan(plan);
-  const listeners = new Set<(event: ApplyEvent) => void>();
-  const { unmount } = render(
-    <PlanProgress
-      plan={plan}
-      source={{
-        subscribe(listener) {
-          listeners.add(listener);
-          return () => listeners.delete(listener);
-        },
-      }}
-    />,
-  );
-  return {
-    done: Effect.fn(function* () {
-      yield* Effect.sleep(10); // give the react event loop time to re-render
-      yield* Effect.sync(() => unmount());
-    }),
-    emit: (event) =>
-      Effect.sync(() => {
-        for (const listener of listeners) listener(event);
-      }),
-  } satisfies PlanStatusSession;
-});

package/src/Cli/tui/components/ApprovePlan.tsx

@@ -1,44 +0,0 @@
-/** @jsxImportSource react */
-import { useState, type JSX } from "react";
-
-import { Box, Text, useApp, useInput } from "ink";
-import type { Plan as AlchemyPlan } from "../../../Plan.ts";
-
-import { Plan } from "./Plan.tsx";
-
-export interface ApprovePlanProps {
-  plan: AlchemyPlan;
-  approve: (result: boolean) => void;
-}
-
-export function ApprovePlan(props: ApprovePlanProps): JSX.Element {
-  const { plan, approve } = props;
-  const [selected, setSelected] = useState(0);
-  const { exit } = useApp();
-
-  useInput((_input, key) => {
-    if (key.leftArrow || key.rightArrow) {
-      setSelected((prev) => (prev === 0 ? 1 : 0));
-    } else if (key.return) {
-      approve(selected === 0);
-      exit();
-    }
-  });
-
-  return (
-    <Box flexDirection="column">
-      <Plan plan={plan} />
-      <Box marginTop={1}>
-        <Text>Proceed?</Text>
-      </Box>
-      <Box gap={1}>
-        <Text color={selected === 0 ? "green" : "gray"}>
-          {selected === 0 ? "◉" : "○"} Yes
-        </Text>
-        <Text color={selected === 1 ? "red" : "gray"}>
-          {selected === 1 ? "◉" : "○"} No
-        </Text>
-      </Box>
-    </Box>
-  );
-}