alchemy 2.0.0-beta.74 → 2.0.0-beta.76

package/src/Cloudflare/Workers/LocalWorkerProvider.ts

@@ -15,7 +15,9 @@ import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Equal from "effect/Equal";
 import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import type * as FileSystem from "effect/FileSystem";
+import * as PlatformFileSystem from "effect/FileSystem";
 import * as MutableHashMap from "effect/MutableHashMap";
 import * as Option from "effect/Option";
 import * as Path from "effect/Path";
@@ -29,6 +31,7 @@ import type * as Bundle from "../../Bundle/Bundle.ts";
 import * as LocalProvider from "../../Local/LocalProvider.ts";
 import { Stack } from "../../Stack.ts";
 import { unwrapRedacted } from "../../Util/index.ts";
+import { sha256 } from "../../Util/sha256.ts";
 import { CloudflareEnvironment } from "../CloudflareEnvironment.ts";
 import {
   isLiveId,
@@ -327,6 +330,12 @@ export const LocalWorkerProvider = () =>
         // opt-out restarts the instance.
         const devRemote: Record<string, boolean> = {};
         const containers: Record<string, ContainerImage> = {};
+        // Content hashes of the container images, keyed like `containers`.
+        // `ContainerImage` itself only carries stable paths (context /
+        // dockerfile / imageUri), so without the hash an image CONTENT
+        // change (a Dockerfile edit, a rebuilt bundle) would never change
+        // the config and the running container would serve stale code.
+        const containerHashes: Record<string, string> = {};
         for (const { data } of bindings) {
           for (const binding of data.bindings ?? []) {
             if (
@@ -391,6 +400,9 @@ export const LocalWorkerProvider = () =>
                 ...container.dev,
                 env: unwrapRedacted(container.dev.env),
               };
+              if (container.hash !== undefined) {
+                containerHashes[container.className] = container.hash;
+              }
             }
           }
         }
@@ -446,6 +458,14 @@ export const LocalWorkerProvider = () =>
           durableObjectNamespaces: Object.values(durableObjectNamespaces),
           workflows: Object.values(workflows),
           hyperdrives,
+          /**
+           * Container image CONTENT hashes (className → hash). The DO
+           * namespace records above only carry the image's stable paths, so
+           * this is what makes an image content change — a Dockerfile edit,
+           * a rebuilt effectful bundle — restart the instance (which is
+           * what re-runs the docker build).
+           */
+          containerHashes,
           /**
            * External source-provider descriptor (plain JSON). Part of the
            * hashed config so changing the provider or its options restarts
@@ -577,6 +597,152 @@ export const LocalWorkerProvider = () =>
       // last good instance keeps serving until the replacement's first
       // serve completes. Ownership is tracked in `workerdScopes`, closed by
       // the next successful serve, by `delete`, or by provider shutdown.
+      /**
+       * One container-context watcher per worker id, keyed by the watched
+       * path set. Registry-held (NOT per-serve-scope): a worker restarts
+       * through several code paths that overlap scopes, and a watcher per
+       * serve produced DUPLICATES whose simultaneous restarts storm the
+       * instance until the DO's container link breaks.
+       */
+      const containerWatchers = new Map<
+        string,
+        { key: string; fiber: Fiber.Fiber<void> }
+      >();
+
+      const stopContainerWatcher = (id: string) =>
+        Effect.suspend(() => {
+          const existing = containerWatchers.get(id);
+          if (existing === undefined) return Effect.void;
+          containerWatchers.delete(id);
+          return Fiber.interrupt(existing.fiber).pipe(Effect.asVoid);
+        });
+
+      /**
+       * Watch a worker's Build-variant container contexts and restart the
+       * instance when their CONTENT changes — the docker build happens at
+       * instance start, so a restart IS the image rebuild.
+       *
+       * This is the reload path for USER-supplied Dockerfile/context
+       * containers: those files are not imported by the stack, so
+       * `bun --watch` never re-runs the exec child for them and no replan
+       * (hence no config-hash restart) ever fires. Generated contexts
+       * (under `.alchemy/`) are excluded — the effectful `main` variant
+       * rewrites its bundle there on every plan, which would loop; that
+       * variant reloads through the config's `containerHashes` instead.
+       *
+       * Events are debounced and gated on a content fingerprint
+       * (`node_modules`/`.git` skipped), so editor double-saves and
+       * metadata-only churn don't bounce the instance.
+       */
+      const ensureContainerWatcher = (
+        worker: RunnableWorkerConfig,
+        restart: Effect.Effect<
+          void,
+          never,
+          | ChildProcessSpawner.ChildProcessSpawner
+          | PlatformFileSystem.FileSystem
+          | Path.Path
+        >,
+      ) =>
+        Effect.gen(function* () {
+          const fs = yield* PlatformFileSystem.FileSystem;
+          const watched = new Map<string, { dockerfile: string | undefined }>();
+          for (const namespace of worker.durableObjectNamespaces) {
+            const image = namespace.container;
+            if (image === undefined || !("dockerfile" in image)) continue;
+            const context = path.resolve(image.context ?? ".");
+            if (context.split(path.sep).includes(".alchemy")) continue;
+            watched.set(context, {
+              dockerfile:
+                image.dockerfile !== undefined
+                  ? path.resolve(context, image.dockerfile)
+                  : undefined,
+            });
+          }
+          const key = JSON.stringify([...watched.entries()].sort());
+          const existing = containerWatchers.get(worker.id);
+          if (existing !== undefined) {
+            if (existing.key === key) return; // same watcher keeps running
+            yield* stopContainerWatcher(worker.id);
+          }
+          if (watched.size === 0) return;
+
+          const fingerprint = Effect.gen(function* () {
+            const hashes: string[] = [];
+            const walk = (dir: string): Effect.Effect<void, any> =>
+              Effect.gen(function* () {
+                const entries = yield* fs.readDirectory(dir);
+                for (const entry of entries.sort()) {
+                  if (entry === "node_modules" || entry === ".git") continue;
+                  const file = path.join(dir, entry);
+                  const stat = yield* fs.stat(file);
+                  if (stat.type === "Directory") {
+                    yield* walk(file);
+                  } else {
+                    hashes.push(
+                      `${file}:${yield* fs.readFile(file).pipe(Effect.flatMap(sha256))}`,
+                    );
+                  }
+                }
+              });
+            for (const [context, { dockerfile }] of watched) {
+              yield* walk(context);
+              if (dockerfile !== undefined && !dockerfile.startsWith(context)) {
+                hashes.push(
+                  `${dockerfile}:${yield* fs.readFile(dockerfile).pipe(Effect.flatMap(sha256))}`,
+                );
+              }
+            }
+            return yield* sha256(hashes.join("\n"));
+          }).pipe(Effect.orElseSucceed(() => undefined));
+
+          const streams = [...watched.entries()].flatMap(
+            ([context, { dockerfile }]) => [
+              fs.watch(context, { recursive: true }),
+              ...(dockerfile !== undefined && !dockerfile.startsWith(context)
+                ? [fs.watch(path.dirname(dockerfile))]
+                : []),
+            ],
+          );
+          const watchLoop = Effect.gen(function* () {
+            let last = yield* fingerprint;
+            yield* Stream.mergeAll(streams, {
+              concurrency: streams.length,
+            }).pipe(
+              Stream.debounce("500 millis"),
+              Stream.runForEach(() =>
+                Effect.gen(function* () {
+                  const next = yield* fingerprint;
+                  if (next === undefined || next === last) return;
+                  last = next;
+                  yield* Effect.logInfo(
+                    `[${worker.id}] Container build context changed, restarting instance`,
+                  );
+                  yield* restart;
+                }),
+              ),
+              Effect.catchCause((cause) =>
+                Effect.logWarning(
+                  `[${worker.id}] Container context watch failed`,
+                  Cause.squash(cause),
+                ),
+              ),
+            );
+          });
+          const fiber = yield* watchLoop.pipe(
+            Effect.ensuring(
+              Effect.sync(() => {
+                const current = containerWatchers.get(worker.id);
+                if (current?.fiber === fiber) {
+                  containerWatchers.delete(worker.id);
+                }
+              }),
+            ),
+            Effect.forkIn(rootScope),
+          );
+          containerWatchers.set(worker.id, { key, fiber });
+        });
+
       const serveWith = (
         worker: RunnableWorkerConfig,
         bundle: Bundle.BundleOutput,
@@ -666,6 +832,13 @@ export const LocalWorkerProvider = () =>
                   worker.name,
                   restartWorker(worker.id),
                 );
+                // Idempotent: the registry keeps ONE watcher per worker id
+                // across restarts (a new one only when the watched path set
+                // changed).
+                yield* ensureContainerWatcher(
+                  worker,
+                  Effect.suspend(() => restartWorker(worker.id)),
+                );
                 const currentConsumers = yield* getQueueConsumers(worker.name);
                 if (
                   JSON.stringify(currentConsumers) !==
@@ -716,7 +889,15 @@ export const LocalWorkerProvider = () =>
           ),
         );
 
-      const restartWorker = (id: string) =>
+      const restartWorker = (
+        id: string,
+      ): Effect.Effect<
+        void,
+        never,
+        | ChildProcessSpawner.ChildProcessSpawner
+        | PlatformFileSystem.FileSystem
+        | Path.Path
+      > =>
         Effect.suspend(() => {
           const latest = latestServes.get(id);
           if (latest) {
@@ -744,6 +925,7 @@ export const LocalWorkerProvider = () =>
       // instance replacement does NOT go through this: the previous workerd
       // keeps serving until the replacement's first serve closes it.
       const closeWorkerd = Effect.fn(function* (id: string) {
+        yield* stopContainerWatcher(id);
         const scope = workerdScopes.get(id);
         if (scope) {
           workerdScopes.delete(id);

package/src/Cloudflare/Workers/Worker.ts

@@ -1301,7 +1301,17 @@ export type Worker<Bindings = any> = Resource<
      * `WorkerProps.cache` takes precedence.
      */
     cache?: WorkerCache;
-    containers?: { className: string; dev: DevContainerImage | undefined }[];
+    containers?: {
+      className: string;
+      dev: DevContainerImage | undefined;
+      /**
+       * Content hash of the image (bundle/Dockerfile/context). Part of the
+       * local worker's restart config: `dev` only carries stable PATHS, so
+       * without the hash an image content change would never restart the
+       * instance and the running container would serve stale code.
+       */
+      hash: string | undefined;
+    }[];
     crons?: string[];
     hyperdrives?: Record<string, Required<DevOrigin>>;
     /**

package/src/Cloudflare/Workers/WorkerAsyncBindings.ts

@@ -313,6 +313,13 @@ const bindContainerClass = Effect.fn(function* (
       `Worker binding '${bindingName}' is a Container without a deployable image. Declare the container with props (image, or context/dockerfile) to bind it on an async Worker — effectful (main) containers require an Effect-native Durable Object host.`,
     );
   }
+  // Both halves of the Worker's side describe the same env entry, so they
+  // share one `sid`. Binding rows are collapsed by sid (last write wins), so
+  // splitting them across two `bind` calls silently drops the namespace
+  // binding whenever the two sids coincide — e.g. the env key and the
+  // Container's logical id match (`Sandbox: Container("Sandbox", …)`). The
+  // Worker then uploads the Container declaration itself as a `json` binding
+  // and `env.NAME` is not a DO namespace at runtime.
   yield* resource.bind`${bindingName}`({
     bindings: [
       {
@@ -321,6 +328,13 @@ const bindContainerClass = Effect.fn(function* (
         className,
       },
     ],
+    containers: [
+      {
+        className,
+        dev: application.dev,
+        hash: application.hash.pipe(Output.map((h) => h?.image)),
+      },
+    ],
   });
   yield* application.bind`${bindingName}`({
     durableObjects: {
@@ -329,9 +343,6 @@ const bindContainerClass = Effect.fn(function* (
       ),
     },
   });
-  yield* resource.bind`${application.LogicalId}`({
-    containers: [{ className, dev: application.dev }],
-  });
 });
 
 type BindingSpec = InputProps<WorkerBinding>;

package/src/Cloudflare/Workers/WorkerProvider.ts

@@ -3234,6 +3234,7 @@ export const LiveWorkerProvider = () =>
               name,
               assets,
               session,
+              dispatchNamespace,
             );
             metadataAssets = {
               jwt,

package/src/Cloudflare/Workers/index.ts

@@ -12,6 +12,7 @@ export * from "./DurableObject.ts";
 export * from "./DurableObjectBridge.ts";
 export * from "./DurableObjectState.ts";
 export * from "./DurableObjectStorage.ts";
+export * from "./EmailEventSource.ts";
 export * from "./Fetch.ts";
 export * from "./GitHubRepositoryEventSource.ts";
 export * from "./HttpServer.ts";

package/src/Cloudflare/Zone/lookup.ts

@@ -1,7 +1,4 @@
-import {
-  Credentials,
-  formatHeaders,
-} from "@distilled.cloud/cloudflare/Credentials";
+import { Credentials } from "@distilled.cloud/cloudflare/Credentials";
 import * as zones from "@distilled.cloud/cloudflare/zones";
 import * as Effect from "effect/Effect";
 import * as Stream from "effect/Stream";
@@ -52,50 +49,36 @@ type ZoneListItem = {
   account: { id?: string | null };
 };
 
-type ZoneListResponse = {
-  success: boolean;
-  errors?: { message?: string }[];
-  result?: ZoneListItem[];
-};
-
 export const findZoneByName = ({
   accountId,
   name,
 }: {
   accountId: string;
   name: string;
-}): Effect.Effect<ZoneListItem | undefined, Error, Credentials> =>
+}): Effect.Effect<
+  ZoneListItem | undefined,
+  zones.ListZonesError,
+  Credentials | HttpClient.HttpClient
+> =>
   Effect.gen(function* () {
-    const credentialsEffect = yield* Credentials;
-    const credentials = yield* credentialsEffect;
-    const url = new URL(`${credentials.apiBaseUrl}/zones`);
-    url.searchParams.set("account.id", accountId);
-    url.searchParams.set("name", name);
-    url.searchParams.set("per_page", "1");
-
-    const json = yield* Effect.tryPromise({
-      try: async () => {
-        const response = await fetch(url, {
-          headers: formatHeaders(credentials),
-        });
-        return (await response.json()) as ZoneListResponse;
-      },
-      catch: (cause) => new Error(`Failed to list Cloudflare zones`, { cause }),
+    // Distilled `listZones` rides `Retry.makeDefault` (5xx / throttling).
+    // The previous raw `fetch` failed the first time Cloudflare answered
+    // `{ success: false, errors: [{ message: "unhandled server error" }] }`.
+    const page = yield* zones.listZones({
+      account: { id: accountId },
+      name,
+      perPage: 1,
     });
-
-    if (!json.success) {
-      return yield* Effect.fail(
-        new Error(
-          json.errors?.map((error) => error.message).join(", ") ??
-            `Failed to list Cloudflare zones`,
-        ),
-      );
-    }
-
-    return json.result?.find(
+    const match = (page.result ?? []).find(
       (candidate) =>
         candidate.name === name && candidate.account.id === accountId,
     );
+    if (match === undefined) return undefined;
+    return {
+      id: match.id,
+      name: match.name,
+      account: { id: match.account.id },
+    };
   });
 
 /**

package/src/Command/Build.ts

@@ -118,15 +118,21 @@ export const Build = Resource<Build>("Command.Build");
 /**
  * Resolves `Redacted` env values to their plain string so that a change in a
  * secret's value still busts the memo hash (the hash is one-way, so the secret
- * itself is never recoverable from state).
+ * itself is never recoverable from state). `undefined`-valued entries are
+ * dropped (they mean "unset").
  */
 const resolveEnv = (env: CommandRunProps["env"]) =>
   env
     ? Object.fromEntries(
-        Object.entries(env).map(([key, value]) => [
-          key,
-          Redacted.isRedacted(value) ? Redacted.value(value) : value,
-        ]),
+        Object.entries(env)
+          .filter(
+            (entry): entry is [string, string | Redacted.Redacted<string>] =>
+              entry[1] !== undefined,
+          )
+          .map(([key, value]) => [
+            key,
+            Redacted.isRedacted(value) ? Redacted.value(value) : value,
+          ]),
       )
     : undefined;
 

package/src/Command/Command.ts

@@ -51,8 +51,11 @@ export interface CommandProps {
   shell?: string | boolean;
   /**
    * Extra environment variables passed to the command on top of `process.env`.
+   * Entries whose value is `undefined` are dropped — this lets website
+   * composites forward optional values (e.g. an `Output` service URL that
+   * resolves to `undefined`) without filtering first.
    */
-  env?: Record<string, string | Redacted.Redacted<string>>;
+  env?: Record<string, string | Redacted.Redacted<string> | undefined>;
 }
 
 /**
@@ -315,10 +318,19 @@ export const CommandExecutorLive = () =>
                 cwd: path.resolve(initialCwd, props.cwd ?? "."),
                 shell: props.shell ?? false,
                 env: Object.fromEntries(
-                  Object.entries(props.env ?? {}).map(([k, v]) => [
-                    k,
-                    Redacted.isRedacted(v) ? Redacted.value(v) : v,
-                  ]),
+                  Object.entries(props.env ?? {})
+                    .filter(
+                      (
+                        entry,
+                      ): entry is [
+                        string,
+                        string | Redacted.Redacted<string>,
+                      ] => entry[1] !== undefined,
+                    )
+                    .map(([k, v]) => [
+                      k,
+                      Redacted.isRedacted(v) ? Redacted.value(v) : v,
+                    ]),
                 ),
                 extendEnv: true,
                 stdin: isNonInteractive() ? "ignore" : "inherit",

package/src/Command/Dev.ts

@@ -218,7 +218,15 @@ const ANSI_REGEX = /\x1b\[[0-9;]*m/g;
  */
 export const extractUrl = (text: string) => {
   const clean = text.replaceAll(ANSI_REGEX, "");
-  return clean.match(LOCAL_URL_REGEX)?.[0] ?? clean.match(URL_REGEX)?.[0];
+  const url = clean.match(LOCAL_URL_REGEX)?.[0] ?? clean.match(URL_REGEX)?.[0];
+  // Some dev servers print their *bind* address (Nuxt: `http://0.0.0.0:3000`),
+  // which is not a connectable host. Normalize the unspecified address to
+  // `localhost` so consumers of `url` — browser links, Router dev routing,
+  // the emulated CloudFront edge dialing the origin — can actually reach it.
+  return url?.replace(
+    /^(https?:\/\/)(?:0\.0\.0\.0|\[::\]|\[0+:0+:0+:0+:0+:0+:0+:0+\])(?=[:/]|$)/,
+    "$1localhost",
+  );
 };
 
 const isLocalUrl = (url: string) => LOCAL_URL_REGEX.test(url);