alchemy 2.0.0-beta.34 → 2.0.0-beta.35

package/src/Cli/LoggingCli.ts

@@ -1,21 +1,137 @@
+import * as Console from "effect/Console";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import type { CRUD, Plan } from "../Plan.ts";
 import { Cli } from "./Cli.ts";
+import type { ApplyEvent, ApplyStatus } from "./Event.ts";
+
+const ESC = "\x1b[";
+const RESET = `${ESC}0m`;
+const useColor = process.stdout.hasColors?.() ?? !!process.stdout.isTTY;
+const c = (code: string, s: string) =>
+  useColor ? `${ESC}${code}m${s}${RESET}` : s;
+const dim = (s: string) => c("2", s);
+const bold = (s: string) => c("1", s);
+const red = (s: string) => c("31", s);
+const green = (s: string) => c("32", s);
+const yellow = (s: string) => c("33", s);
+const blue = (s: string) => c("34", s);
+const magenta = (s: string) => c("35", s);
+const cyan = (s: string) => c("36", s);
+
+const actionColor: Record<CRUD["action"], (s: string) => string> = {
+  create: green,
+  update: yellow,
+  replace: magenta,
+  delete: red,
+  noop: dim,
+};
+
+const statusColor = (status: ApplyStatus): ((s: string) => string) => {
+  switch (status) {
+    case "created":
+    case "updated":
+    case "replaced":
+      return green;
+    case "deleted":
+      return dim;
+    case "fail":
+      return red;
+    case "attaching":
+    case "post-attach":
+      return cyan;
+    default:
+      return yellow;
+  }
+};
+
+const tag = (id: string) => bold(`[${id}]`);
+
+const isTerminal = (status: ApplyStatus): boolean =>
+  status === "created" ||
+  status === "updated" ||
+  status === "deleted" ||
+  status === "replaced" ||
+  status === "fail";
+
+const formatPlanLines = (plan: Plan): string[] => {
+  const items = [
+    ...Object.values(plan.resources),
+    ...Object.values(plan.deletions),
+  ] as CRUD[];
+  if (items.length === 0) return [bold("Plan:") + " no changes"];
+
+  const counts = items.reduce(
+    (acc, item) => ((acc[item.action] = (acc[item.action] ?? 0) + 1), acc),
+    {} as Record<CRUD["action"], number>,
+  );
+  const summary = (["create", "update", "replace", "delete", "noop"] as const)
+    .filter((a) => counts[a])
+    .map((a) => actionColor[a](`${counts[a]} to ${a}`))
+    .join(dim(", "));
+
+  const sorted = [...items].sort((a, b) =>
+    a.resource.LogicalId.localeCompare(b.resource.LogicalId),
+  );
+  const lines = [`${bold("Plan:")} ${summary}`];
+  for (const item of sorted) {
+    const action = actionColor[item.action](item.action);
+    lines.push(`${tag(item.resource.LogicalId)} ${action}`);
+    for (const binding of item.bindings) {
+      if (binding.action === "noop") continue;
+      const bindingAction = actionColor[binding.action](binding.action);
+      lines.push(
+        `${tag(`${item.resource.LogicalId}/${binding.sid}`)} ${bindingAction}`,
+      );
+    }
+  }
+  return lines;
+};
 
 export const LoggingCli = Layer.succeed(
   Cli,
   Cli.of({
-    approvePlan: () => Effect.succeed(true),
-    displayPlan: () => Effect.void,
-    startApplySession: () =>
-      Effect.succeed({
-        done: () => Effect.void,
-        emit: (event) =>
-          Effect.log(
-            event.kind === "status-change"
-              ? `${event.status} ${event.id}(${event.type})`
-              : `${event.id}: ${event.message}`,
-          ),
+    approvePlan: (plan) =>
+      Effect.gen(function* () {
+        for (const line of formatPlanLines(plan)) yield* Console.log(line);
+        yield* Console.log(
+          `\n${yellow("Non-interactive terminal detected.")} Pass ${bold("--yes")} to approve, or set ${bold("ALCHEMY_TUI=1")} for the interactive UI.`,
+        );
+        return false;
+      }),
+    displayPlan: (plan) =>
+      Effect.gen(function* () {
+        for (const line of formatPlanLines(plan)) yield* Console.log(line);
+      }),
+    startApplySession: (plan) =>
+      Effect.gen(function* () {
+        for (const line of formatPlanLines(plan)) yield* Console.log(line);
+        yield* Console.log("");
+
+        const counts = { ok: 0, fail: 0 };
+        return {
+          emit: (event: ApplyEvent) =>
+            Effect.sync(() => {
+              if (event.kind === "annotate") {
+                console.log(`${tag(event.id)} ${blue(event.message)}`);
+                return;
+              }
+              const id = event.bindingId
+                ? `${event.id}/${event.bindingId}`
+                : event.id;
+              const status = statusColor(event.status)(event.status);
+              const msg = event.message ? ` ${dim("—")} ${event.message}` : "";
+              console.log(`${tag(id)} ${status}${msg}`);
+              if (isTerminal(event.status)) {
+                if (event.status === "fail") counts.fail++;
+                else counts.ok++;
+              }
+            }),
+          done: () =>
+            Console.log(
+              `\n${bold("Done:")} ${green(`${counts.ok} succeeded`)}${counts.fail ? dim(", ") + red(`${counts.fail} failed`) : ""}`,
+            ),
+        };
       }),
   }),
 );

package/src/Cli/checkVersion.ts

@@ -0,0 +1,57 @@
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as HttpClient from "effect/unstable/http/HttpClient";
+
+import packageJson from "../../package.json" with { type: "json" };
+
+const NPM_DIST_TAGS_URL =
+  "https://registry.npmjs.org/-/package/alchemy/dist-tags";
+
+/**
+ * Pick the dist-tag matching the current channel. For pre-release versions
+ * like `2.0.0-beta.33`, npm's `latest` tag points at the most recent stable
+ * release — not the newest beta — so we match the prerelease identifier
+ * (`beta`, `next`, etc.), falling back through `next` → `latest`.
+ */
+const pickDistTag = (
+  current: string,
+  distTags: Record<string, string>,
+): string | undefined => {
+  const pre = current.split("-", 2)[1];
+  if (pre) {
+    const id = pre.split(".")[0];
+    if (id && distTags[id]) return distTags[id];
+    if (distTags.next) return distTags.next;
+  }
+  return distTags.latest;
+};
+
+/**
+ * Fetch the published `alchemy` version on the dist-tag matching the
+ * current channel and log a warning if it's different from the bundled
+ * version. Best-effort: any failure (offline, registry hiccup, slow
+ * response) is swallowed silently.
+ */
+export const checkLatestVersion = Effect.gen(function* () {
+  const http = yield* HttpClient.HttpClient;
+  const response = yield* http.get(NPM_DIST_TAGS_URL);
+  const distTags = (yield* response.json) as Record<string, string>;
+  if (typeof distTags !== "object" || distTags === null) return;
+  const current = packageJson.version;
+  const latest = pickDistTag(current, distTags);
+  if (typeof latest !== "string" || latest === current) return;
+  const installCmd =
+    typeof process !== "undefined" && (process as any).versions?.bun
+      ? `bun add alchemy@${latest}`
+      : `pnpm add alchemy@${latest}`;
+  yield* Effect.logWarning(
+    `alchemy ${latest} is available (you're on ${current}). ` +
+      `Run \`${installCmd}\` to upgrade.`,
+  );
+}).pipe(
+  Effect.timeout(Duration.seconds(5)),
+  Effect.catch(() => Effect.void),
+);
+
+// Exported for tests.
+export const _internal = { pickDistTag };

package/src/Cli/commands/_shared.ts

@@ -9,10 +9,10 @@ import * as Argument from "effect/unstable/cli/Argument";
 import * as CliError from "effect/unstable/cli/CliError";
 import * as Flag from "effect/unstable/cli/Flag";
 
-import { AuthError } from "../../Auth/AuthProvider";
-import type * as Stack from "../../Stack";
-import { recordCli } from "../../Telemetry/Metrics";
-import { PromptCancelled } from "../../Util/Clank";
+import { AuthError } from "../../Auth/AuthProvider.ts";
+import type * as Stack from "../../Stack.ts";
+import { recordCli } from "../../Telemetry/Metrics.ts";
+import { PromptCancelled } from "../../Util/Clank.ts";
 
 export const USER = Config.string("USER").pipe(
   Config.orElse(() => Config.string("USERNAME")),

package/src/Cli/commands/aws.ts

@@ -0,0 +1,127 @@
+import * as Auth from "@distilled.cloud/aws/Auth";
+import * as ConfigProvider from "effect/ConfigProvider";
+import * as Console from "effect/Console";
+import * as Effect from "effect/Effect";
+import type { FileSystem } from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Logger from "effect/Logger";
+import * as Option from "effect/Option";
+import { Path } from "effect/Path";
+import * as Command from "effect/unstable/cli/Command";
+import * as Flag from "effect/unstable/cli/Flag";
+import type { HttpClient } from "effect/unstable/http/HttpClient";
+
+import {
+  bootstrap as bootstrapAws,
+  destroyBootstrap as destroyBootstrapAws,
+} from "../../AWS/Bootstrap.ts";
+import * as AWSCredentials from "../../AWS/Credentials.ts";
+import * as AWSEnvironment from "../../AWS/Environment.ts";
+import * as AWSRegion from "../../AWS/Region.ts";
+import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
+import { fileLogger } from "../../Util/FileLogger.ts";
+
+import { envFile, instrumentCommand } from "./_shared.ts";
+
+const awsProfile = Flag.string("profile").pipe(
+  Flag.withDescription("AWS profile to use for credentials"),
+  Flag.optional,
+  Flag.map(Option.getOrElse(() => "default")),
+);
+
+const awsRegion = Flag.string("region").pipe(
+  Flag.withDescription(
+    "AWS region to bootstrap (defaults to AWS_REGION env var)",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+const bootstrapDestroy = Flag.boolean("destroy").pipe(
+  Flag.withDescription("Destroy all bootstrap buckets in the selected region"),
+  Flag.withDefault(false),
+);
+
+const bootstrapCommand = Command.make(
+  "bootstrap",
+  {
+    envFile,
+    profile: awsProfile,
+    region: awsRegion,
+    destroy: bootstrapDestroy,
+  },
+  instrumentCommand(
+    "aws.bootstrap",
+    (a: { profile: string; region: string | undefined; destroy: boolean }) => ({
+      "alchemy.profile": a.profile,
+      "alchemy.region": a.region ?? "",
+      "alchemy.destroy": a.destroy,
+    }),
+  )(
+    Effect.fnUntraced(function* ({ envFile, profile, region, destroy }) {
+      const logger = Logger.layer([fileLogger("bootstrap.txt")], {
+        mergeWithExisting: true,
+      });
+
+      return yield* Effect.gen(function* () {
+        const ssoProfile = yield* Auth.loadProfile(profile);
+        if (!ssoProfile.sso_account_id) {
+          return yield* Effect.die(
+            `AWS SSO profile '${profile}' is missing sso_account_id`,
+          );
+        }
+
+        const ambient = yield* Effect.context<FileSystem | Path | HttpClient>();
+        const environment = AWSEnvironment.makeEnvironment({
+          accountId: ssoProfile.sso_account_id,
+          region: region ?? ssoProfile.region ?? "us-east-1",
+          credentials: Auth.loadProfileCredentials(profile).pipe(
+            Effect.provide(ambient),
+          ),
+          profile,
+        });
+
+        const awsLayers = Layer.provideMerge(
+          Layer.mergeAll(
+            AWSRegion.fromEnvironment,
+            AWSCredentials.fromEnvironment,
+          ),
+          environment,
+        );
+
+        return yield* Effect.gen(function* () {
+          const provider = yield* loadConfigProvider(envFile);
+          const bootstrapLayer = Layer.provide(
+            awsLayers,
+            Layer.succeed(ConfigProvider.ConfigProvider, provider),
+          );
+          if (destroy) {
+            yield* destroyBootstrapAws().pipe(
+              Effect.tap((result) =>
+                result.destroyed === 0
+                  ? Console.log("✓ No bootstrap buckets found to destroy")
+                  : Console.log(
+                      `✓ Destroyed ${result.destroyed} bootstrap bucket(s): ${result.bucketNames.join(", ")}`,
+                    ),
+              ),
+              Effect.provide(bootstrapLayer),
+            );
+            return;
+          }
+          yield* bootstrapAws().pipe(
+            Effect.tap(({ bucketName, created }) =>
+              created
+                ? Console.log(`✓ Created assets bucket: ${bucketName}`)
+                : Console.log(`✓ Assets bucket already exists: ${bucketName}`),
+            ),
+            Effect.provide(bootstrapLayer),
+          );
+        });
+      }).pipe(Effect.provide(logger));
+    }),
+  ),
+);
+
+export const awsCommand = Command.make("aws", {}).pipe(
+  Command.withSubcommands([bootstrapCommand]),
+);

package/src/Cli/commands/cloudflare.ts

@@ -0,0 +1,222 @@
+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 Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import { Command, Flag } from "effect/unstable/cli";
+
+import { AuthProviders } from "../../Auth/AuthProvider.ts";
+import { withProfileOverride } from "../../Auth/Profile.ts";
+import * as CloudflareAccess from "../../Cloudflare/Access.ts";
+import { CloudflareAuth } from "../../Cloudflare/Auth/AuthProvider.ts";
+import * as CloudflareEnvironment from "../../Cloudflare/CloudflareEnvironment.ts";
+import * as CloudflareCredentials from "../../Cloudflare/Credentials.ts";
+import { CloudflareLogs } from "../../Cloudflare/Logs.ts";
+import { STATE_STORE_SCRIPT_NAME } from "../../Cloudflare/StateStore/Api.ts";
+import { bootstrap as bootstrapCloudflare } from "../../Cloudflare/StateStore/State.ts";
+import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
+import { fileLogger } from "../../Util/FileLogger.ts";
+
+import {
+  envFile,
+  formatLocalTimestamp,
+  instrumentCommand,
+  parseSince,
+  profile,
+} from "./_shared.ts";
+
+/**
+ * Build the Cloudflare auth + environment layer stack used by every
+ * `alchemy cloudflare ...` subcommand. Mirrors the wiring inside
+ * `Cloudflare.state(...)` so the command can talk to the user's
+ * account out-of-band.
+ */
+const cloudflareLayers = (
+  envFileOpt: Option.Option<string>,
+  profileName: string,
+) =>
+  Effect.gen(function* () {
+    const authProviders: AuthProviders["Service"] = {};
+    const authRegistry = Layer.succeed(AuthProviders, authProviders);
+    const authLayer = Layer.provideMerge(CloudflareAuth, authRegistry);
+    const cf = Layer.provideMerge(
+      Layer.mergeAll(
+        CloudflareCredentials.fromAuthProvider(),
+        CloudflareEnvironment.fromProfile(),
+        CloudflareAccess.AccessLive,
+      ),
+      authLayer,
+    );
+
+    const logger = Logger.layer([fileLogger("cloudflare.txt")], {
+      mergeWithExisting: true,
+    });
+
+    return Layer.mergeAll(
+      cf,
+      ConfigProvider.layer(
+        withProfileOverride(yield* loadConfigProvider(envFileOpt), profileName),
+      ),
+      logger,
+    );
+  });
+
+const cloudflareForce = Flag.boolean("force").pipe(
+  Flag.withDescription(
+    "Force a full redeploy even if the state-store worker already exists. " +
+      "Without this flag, an existing worker is adopted and only its credentials are refreshed.",
+  ),
+  Flag.withDefault(false),
+);
+
+const cloudflareWorkerName = Flag.string("worker-name").pipe(
+  Flag.withDescription(
+    "Override the default state-store worker name (advanced; only needed for multiple state stores per account).",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+const bootstrapCommand = Command.make(
+  "bootstrap",
+  {
+    envFile,
+    profile,
+    force: cloudflareForce,
+    workerName: cloudflareWorkerName,
+  },
+  instrumentCommand(
+    "cloudflare.bootstrap",
+    (a: {
+      profile: string;
+      force: boolean;
+      workerName: string | undefined;
+    }) => ({
+      "alchemy.profile": a.profile,
+      "alchemy.force": a.force,
+      "alchemy.worker_name": a.workerName ?? "",
+    }),
+  )(
+    Effect.fnUntraced(function* ({ envFile, profile, force, workerName }) {
+      const services = yield* cloudflareLayers(envFile, profile);
+      yield* bootstrapCloudflare({ workerName, force }).pipe(
+        Effect.provide(services),
+      );
+    }),
+  ),
+);
+
+const tailFlag = Flag.boolean("tail").pipe(
+  Flag.withDescription(
+    "Stream logs in real time via the Cloudflare tail websocket instead of fetching past entries.",
+  ),
+  Flag.withDefault(false),
+);
+
+const limitFlag = Flag.integer("limit").pipe(
+  Flag.withDescription("Number of log entries to fetch (ignored with --tail)"),
+  Flag.withDefault(100),
+);
+
+const sinceFlag = Flag.string("since").pipe(
+  Flag.withDescription(
+    "Fetch logs since this time (e.g. '1h', '30m', '2024-01-01T00:00:00Z')",
+  ),
+  Flag.optional,
+  Flag.map(Option.getOrUndefined),
+);
+
+/**
+ * `alchemy cloudflare state logs` — get or tail logs from the
+ * `alchemy-state-store` Worker on the user's account. Lets us debug
+ * the state-store worker without standing up a stack file.
+ */
+const stateLogsCommand = Command.make(
+  "logs",
+  {
+    envFile,
+    profile,
+    workerName: cloudflareWorkerName,
+    tail: tailFlag,
+    limit: limitFlag,
+    since: sinceFlag,
+  },
+  instrumentCommand(
+    "cloudflare.state.logs",
+    (a: {
+      profile: string;
+      workerName: string | undefined;
+      tail: boolean;
+      limit: number;
+    }) => ({
+      "alchemy.profile": a.profile,
+      "alchemy.worker_name": a.workerName ?? STATE_STORE_SCRIPT_NAME,
+      "alchemy.tail": a.tail,
+      "alchemy.limit": a.limit,
+    }),
+  )(
+    Effect.fnUntraced(function* ({
+      envFile,
+      profile,
+      workerName,
+      tail,
+      limit,
+      since,
+    }) {
+      const services = yield* cloudflareLayers(envFile, profile);
+      const scriptName = workerName ?? STATE_STORE_SCRIPT_NAME;
+
+      yield* Effect.gen(function* () {
+        const { accountId } =
+          yield* CloudflareEnvironment.CloudflareEnvironment;
+        const telemetry = yield* CloudflareLogs;
+
+        const formatLine = (line: { timestamp: Date; message: string }) =>
+          `${formatLocalTimestamp(line.timestamp)} [${scriptName}] ${line.message}`;
+
+        if (tail) {
+          yield* Console.log(`Tailing ${scriptName}...`);
+          yield* telemetry
+            .tailScript({ accountId, scriptName })
+            .pipe(Stream.runForEach((line) => Console.log(formatLine(line))));
+          return;
+        }
+
+        const sinceDate = since ? parseSince(since) : undefined;
+        const lines = yield* telemetry.queryLogs({
+          accountId,
+          filters: [
+            {
+              key: "$workers.scriptName",
+              operation: "eq",
+              type: "string",
+              value: scriptName,
+            },
+          ],
+          options: { limit, since: sinceDate },
+        });
+
+        if (lines.length === 0) {
+          yield* Console.log(`(no log entries for ${scriptName})`);
+          return;
+        }
+
+        for (const line of lines.sort(
+          (a, b) => a.timestamp.getTime() - b.timestamp.getTime(),
+        )) {
+          yield* Console.log(formatLine(line));
+        }
+      }).pipe(Effect.provide(services));
+    }),
+  ),
+);
+
+const stateCommand = Command.make("state", {}).pipe(
+  Command.withSubcommands([stateLogsCommand]),
+);
+
+export const cloudflareCommand = Command.make("cloudflare", {}).pipe(
+  Command.withSubcommands([bootstrapCommand, stateCommand]),
+);

package/src/Cli/commands/deploy.ts

@@ -8,17 +8,17 @@ import * as Schema from "effect/Schema";
 import * as Command from "effect/unstable/cli/Command";
 import * as Flag from "effect/unstable/cli/Flag";
 
-import { AdoptPolicy } from "../../AdoptPolicy";
-import { AlchemyContext } from "../../AlchemyContext";
-import { apply } from "../../Apply";
-import { ArtifactStore, createArtifactStore } from "../../Artifacts";
-import { AuthProviders } from "../../Auth/AuthProvider";
-import { withProfileOverride } from "../../Auth/Profile";
+import { AdoptPolicy } from "../../AdoptPolicy.ts";
+import { AlchemyContext } from "../../AlchemyContext.ts";
+import { apply } from "../../Apply.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 * as Plan from "../../Plan";
-import { Stage } from "../../Stage";
-import { loadConfigProvider } from "../../Util/ConfigProvider";
-import { fileLogger } from "../../Util/FileLogger";
+import * as Plan from "../../Plan.ts";
+import { Stage } from "../../Stage.ts";
+import { loadConfigProvider } from "../../Util/ConfigProvider.ts";
+import { fileLogger } from "../../Util/FileLogger.ts";
 
 import {
   dryRun as dryRunFlag,
@@ -45,6 +45,7 @@ export const ExecStackOptions = Schema.Struct({
   adopt: Schema.optional(Schema.Boolean),
 });
 export type ExecStackOptions = typeof ExecStackOptions.Type;
+export type ExecStackOptionsEncoded = typeof ExecStackOptions.Encoded;
 
 const stackSpanAttrs = (args: ExecStackOptions) => ({
   "alchemy.stage": args.stage,

package/src/Cli/commands/dev.ts

@@ -6,16 +6,6 @@ import { fileURLToPath } from "node:url";
 import { envFile, force, profile, script, stage } from "./_shared.ts";
 import { ExecStackOptions } from "./deploy.ts";
 
-// Source iteration uses unbundled exec.ts so --watch sees source-file changes;
-// published installs use the bundled exec.js so react/ink/pathe stay
-// devDependencies (matching the CLI bundle's intent). Detect which world we're
-// in by whether dev.ts (or the alchemy.js bundle that contains it) lives
-// inside a node_modules tree — same heuristic as bin/cli.js.
-const selfPath = fileURLToPath(import.meta.url);
-const isInstalled =
-  selfPath.includes("/node_modules/") || selfPath.includes("\\node_modules\\");
-const execEntry = isInstalled ? "alchemy/bin/exec.js" : "alchemy/bin/exec.ts";
-
 export const devCommand = Command.make(
   "dev",
   {
@@ -31,30 +21,35 @@ export const devCommand = Command.make(
       yes: true,
       dev: true,
     });
-    const bin = typeof globalThis.Bun !== "undefined" ? "bun" : "node";
-    const main = fileURLToPath(import.meta.resolve(execEntry));
-    const child = yield* ChildProcess.make(
-      bin,
-      {
-        bun: ["run", ...process.execArgv, "--watch", "--no-clear-screen", main],
-        node: [
-          ...process.execArgv,
-          "--experimental-transform-types",
-          "--watch",
-          "--watch-preserve-output",
-          main,
-        ],
-      }[bin],
-      {
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-        env: {
-          ALCHEMY_EXEC_OPTIONS: JSON.stringify(options),
-        },
-        extendEnv: true,
+    // We no longer force Bun in development because this prevents us from testing in Node.
+    const command =
+      typeof globalThis.Bun !== "undefined"
+        ? [
+            "bun",
+            "run",
+            ...process.execArgv,
+            "--watch",
+            "--no-clear-screen",
+            fileURLToPath(import.meta.resolve("alchemy/bin/exec.ts")),
+          ]
+        : [
+            "node",
+            ...process.execArgv,
+            "--experimental-transform-types",
+            "--watch",
+            "--watch-preserve-output",
+            fileURLToPath(import.meta.resolve("alchemy/bin/exec.js")),
+          ];
+    const child = yield* ChildProcess.make(command[0], command.slice(1), {
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+      env: {
+        ALCHEMY_EXEC_OPTIONS: JSON.stringify(options),
       },
-    );
+      extendEnv: true,
+      detached: false,
+    });
     yield* child.exitCode;
   }),
 );