alchemy 0.78.0 → 0.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "0.78.0",
+  "version": "0.80.0",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
   "homepage": "https://alchemy.run",

package/src/cloudflare/bindings.ts

@@ -26,10 +26,10 @@ import type { SecretRef as CloudflareSecretRef } from "./secret-ref.ts";
 import type { Secret as CloudflareSecret } from "./secret.ts";
 import type { VectorizeIndex } from "./vectorize-index.ts";
 import type { VersionMetadata } from "./version-metadata.ts";
+import type { WorkerLoader } from "./worker-loader.ts";
 import type { WorkerRef } from "./worker-ref.ts";
 import type { WorkerStub } from "./worker-stub.ts";
 import type { Worker } from "./worker.ts";
-import type { WorkerLoader } from "./worker-loader.ts";
 import type { Workflow } from "./workflow.ts";
 
 export type Bindings = {
@@ -72,6 +72,8 @@ export type Binding =
   | string
   | VectorizeIndex
   | Worker
+  | Worker.DevDomain
+  | Worker.DevUrl
   | WorkerStub
   | WorkerRef
   | WorkerEntrypoint

package/src/cloudflare/bound.ts

@@ -88,17 +88,23 @@ export type Bound<T extends Binding> =
                                                   ? ImagesBinding
                                                   : T extends _VersionMetadata
                                                     ? WorkerVersionMetadata
-                                                    : T extends Self
-                                                      ? Service
-                                                      : T extends Json<infer T>
-                                                        ? T
-                                                        : T extends _Container<
-                                                              infer Obj
+                                                    : T extends
+                                                          | _Worker.DevDomain
+                                                          | _Worker.DevUrl
+                                                      ? string
+                                                      : T extends Self
+                                                        ? Service
+                                                        : T extends Json<
+                                                              infer T
                                                             >
-                                                          ? DurableObjectNamespace<
-                                                              Obj &
-                                                                Rpc.DurableObjectBranded
-                                                            >
-                                                          : T extends undefined
-                                                            ? undefined
-                                                            : Service;
+                                                          ? T
+                                                          : T extends _Container<
+                                                                infer Obj
+                                                              >
+                                                            ? DurableObjectNamespace<
+                                                                Obj &
+                                                                  Rpc.DurableObjectBranded
+                                                              >
+                                                            : T extends undefined
+                                                              ? undefined
+                                                              : Service;

package/src/cloudflare/compatibility-date.gen.ts

@@ -4,4 +4,4 @@
 /**
  * The default Cloudflare Workers compatibility date, set based on the latest workerd release at the time of build.
  */
-export const DEFAULT_COMPATIBILITY_DATE = "2025-11-19";
+export const DEFAULT_COMPATIBILITY_DATE = "2025-12-02";

package/src/cloudflare/miniflare/build-worker-options.ts

@@ -1,6 +1,7 @@
 import * as miniflare from "miniflare";
 import path from "pathe";
 import { assertNever } from "../../util/assert-never.ts";
+import { reservePort } from "../../util/find-open-port.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import { logger } from "../../util/logger.ts";
 import type { CloudflareApi } from "../api.ts";
@@ -83,6 +84,7 @@ export const buildWorkerOptions = async (
     // This exposes the worker as a route that can be accessed by setting the MF-Route-Override header.
     routes: [input.name],
   };
+  const port = input.port ?? (await reservePort(input.name));
   for (const [key, binding] of Object.entries(input.bindings ?? {})) {
     if (typeof binding === "string") {
       (options.bindings ??= {})[key] = binding;
@@ -92,6 +94,14 @@ export const buildWorkerOptions = async (
       (options.serviceBindings ??= {})[key] = miniflare.kCurrentWorker;
       continue;
     }
+    if (binding.type === "cloudflare::Worker::DevDomain") {
+      (options.bindings ??= {})[key] = `localhost:${port}`;
+      continue;
+    }
+    if (binding.type === "cloudflare::Worker::DevUrl") {
+      (options.bindings ??= {})[key] = `http://localhost:${port}`;
+      continue;
+    }
     switch (binding.type) {
       case "ai": {
         const existing = remoteBindings.find((b) => b.type === "ai");

package/src/cloudflare/miniflare/miniflare-controller.ts

@@ -2,7 +2,7 @@ import * as miniflare from "miniflare";
 import assert from "node:assert";
 import path from "pathe";
 import { Scope } from "../../scope.ts";
-import { findOpenPort } from "../../util/find-open-port.ts";
+import { reservePort } from "../../util/find-open-port.ts";
 import type { HTTPServer } from "../../util/http.ts";
 import { logger } from "../../util/logger.ts";
 import { AsyncMutex } from "../../util/mutex.ts";
@@ -37,6 +37,7 @@ export class MiniflareController {
 
   async add(input: MiniflareWorkerInput) {
     const { watch, remoteProxy } = await buildWorkerOptions(input);
+
     if (remoteProxy) {
       this.remoteProxies.set(input.name, remoteProxy);
     }
@@ -54,7 +55,7 @@ export class MiniflareController {
       });
     } else {
       const proxy = await createMiniflareWorkerProxy({
-        port: input.port ?? (await findOpenPort()),
+        port: input.port ?? (await reservePort(input.name)),
         getWorkerName: () => input.name,
         miniflare,
         mode: "local",

package/src/cloudflare/website.ts

@@ -5,6 +5,7 @@ import { Exec } from "../os/index.ts";
 import { Scope } from "../scope.ts";
 import { dedent } from "../util/dedent.ts";
 import { logger } from "../util/logger.ts";
+import { createCloudflareApi } from "./api.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
 import { DEFAULT_COMPATIBILITY_DATE } from "./compatibility-date.gen.ts";
@@ -13,6 +14,7 @@ import {
   extractStringAndSecretBindings,
   unencryptSecrets,
 } from "./util/filter-env-bindings.ts";
+import { computeWorkerDevDomain } from "./worker-subdomain.ts";
 import { type AssetsConfig, Worker, type WorkerProps } from "./worker.ts";
 import { WranglerJson, type WranglerJsonSpec } from "./wrangler.json.ts";
 
@@ -70,6 +72,10 @@ export interface WebsiteProps<B extends Bindings>
          * The command to run to start the dev server
          */
         command?: string;
+        /**
+         * The local domain to use for the dev server
+         */
+        domain?: string;
         /**
          * Additional environment variables to set when running the dev command
          */
@@ -225,11 +231,46 @@ export async function Website<B extends Bindings>(
     };
   })();
   const secrets = props.wrangler?.secrets ?? !props.wrangler?.path;
+
   const env = {
-    ...(process.env ?? {}),
-    ...(props.env ?? {}),
+    ...process.env,
+    ...props.env,
     ...extractStringAndSecretBindings(props.bindings ?? {}, secrets),
   };
+  if (props.bindings) {
+    for (const [key, value] of Object.entries(props.bindings)) {
+      if (typeof value !== "object") continue;
+      if (
+        value.type === "cloudflare::Worker::DevDomain" ||
+        value.type === "cloudflare::Worker::DevUrl"
+      ) {
+        if (Scope.current.local) {
+          const domain = typeof dev === "object" ? dev.domain : undefined;
+          if (!domain) {
+            // we can't know which port the local web server (e.g. vite dev) will use
+            // vite dev # default to 5173 or configured in vite.config.ts
+            // vite dev --port XYZ
+            // next dev # who fucking knows
+            // for now: we require the user tell us the local domain
+            throw new Error(
+              "You must set `dev.domain` when running in local development mode and a Worker.DevDomain binding",
+            );
+          }
+          env[key] =
+            value.type === "cloudflare::Worker::DevDomain"
+              ? domain
+              : `http://${domain}`;
+        } else {
+          const api = await createCloudflareApi(props);
+          const domain = await computeWorkerDevDomain(api, name);
+          env[key] =
+            value.type === "cloudflare::Worker::DevDomain"
+              ? domain
+              : `https://${domain}`;
+        }
+      }
+    }
+  }
   const worker = {
     ...workerProps,
     name,

package/src/cloudflare/worker-metadata.ts

@@ -19,7 +19,13 @@ import type {
   MultiStepMigration,
   SingleStepMigration,
 } from "./worker-migration.ts";
-import { isWorker, type AssetsConfig, type WorkerProps } from "./worker.ts";
+import { computeWorkerDevDomain } from "./worker-subdomain.ts";
+import {
+  isWorker,
+  Worker,
+  type AssetsConfig,
+  type WorkerProps,
+} from "./worker.ts";
 
 /**
  * Metadata returned by Cloudflare API for a worker script
@@ -427,6 +433,18 @@ export async function prepareWorkerMetadata(
         service: props.workerName,
         entrypoint: binding.__entrypoint__,
       });
+    } else if (binding.type === "cloudflare::Worker::DevDomain") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: await computeWorkerDevDomain(api, props.workerName),
+      });
+    } else if (binding.type === "cloudflare::Worker::DevUrl") {
+      meta.bindings.push({
+        type: "plain_text",
+        name: bindingName,
+        text: `https://${await computeWorkerDevDomain(api, props.workerName)}`,
+      });
     } else if (binding.type === "d1") {
       meta.bindings.push({
         type: "d1",

package/src/cloudflare/worker-subdomain.ts

@@ -87,7 +87,9 @@ export async function disableWorkerSubdomain(
     `disable subdomain for "${scriptName}"`,
     api.post(
       `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
-      { enabled: false },
+      {
+        enabled: false,
+      },
     ),
   ).catch((error) => {
     if (error.status === 404) {
@@ -107,7 +109,10 @@ export async function enableWorkerSubdomain(
         `enable subdomain for "${scriptName}"`,
         api.post(
           `/accounts/${api.accountId}/workers/scripts/${scriptName}/subdomain`,
-          { enabled: true, previews_enabled: true },
+          {
+            enabled: true,
+            previews_enabled: true,
+          },
         ),
       ),
     (error) => error instanceof CloudflareApiError && error.status === 404,
@@ -116,6 +121,13 @@ export async function enableWorkerSubdomain(
   );
 }
 
+export async function computeWorkerDevDomain(
+  api: CloudflareApi,
+  scriptName: string,
+) {
+  return `${scriptName}.${await getAccountSubdomain(api)}.workers.dev`;
+}
+
 export async function getWorkerSubdomain(
   api: CloudflareApi,
   scriptName: string,

package/src/cloudflare/worker.ts

@@ -51,11 +51,17 @@ import {
 import {
   type WorkerScriptMetadata,
   bumpMigrationTagVersion,
+  getWorkerSettings,
   prepareWorkerMetadata,
 } from "./worker-metadata.ts";
 import { WorkerSubdomain, disableWorkerSubdomain } from "./worker-subdomain.ts";
 import { createTail } from "./worker-tail.ts";
-import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
+import {
+  Workflow,
+  deleteWorkflow,
+  isWorkflow,
+  upsertWorkflow,
+} from "./workflow.ts";
 
 // Previous versions of `Worker` used the `Bundle` resource.
 // This import is here to avoid errors when destroying the `Bundle` resource.
@@ -803,6 +809,17 @@ export function Worker<const B extends Bindings>(
   return _Worker(id, props as WorkerProps<B>);
 }
 
+export namespace Worker {
+  export type DevDomain = typeof DevDomain;
+  export const DevDomain = {
+    type: "cloudflare::Worker::DevDomain" as const,
+  };
+  export type DevUrl = typeof DevUrl;
+  export const DevUrl = {
+    type: "cloudflare::Worker::DevUrl" as const,
+  };
+}
+
 Worker.experimentalEntrypoint = <RPC extends Rpc.WorkerEntrypointBranded>(
   worker: Worker | WorkerRef | Self,
   entrypoint: string,
@@ -951,7 +968,10 @@ const _Worker = Resource(
             await createEmptyWorker(api, options.name, props.version);
           }
         } else {
-          await deleteQueueConsumers(api, options.name);
+          await Promise.all([
+            deleteQueueConsumers(api, options.name),
+            deleteWorkflows(api, options.name),
+          ]);
           await deleteWorker(api, {
             scriptName: options.name,
             dispatchNamespace: options.dispatchNamespace,
@@ -1708,6 +1728,20 @@ async function deleteQueueConsumers(api: CloudflareApi, scriptName: string) {
   );
 }
 
+async function deleteWorkflows(api: CloudflareApi, scriptName: string) {
+  const settings = await getWorkerSettings(api, scriptName);
+  await Promise.all(
+    (settings?.bindings ?? []).map(async (binding) => {
+      if (
+        binding.type === "workflow" &&
+        (binding.script_name === scriptName || !binding.script_name)
+      ) {
+        await deleteWorkflow(api, binding.workflow_name);
+      }
+    }),
+  );
+}
+
 export async function deleteWorker(
   api: CloudflareApi,
   props: {

package/src/cloudflare/workflow.ts

@@ -116,3 +116,12 @@ export async function upsertWorkflow(
 
   return body.result;
 }
+
+export async function deleteWorkflow(api: CloudflareApi, name: string) {
+  const response = await api.delete(
+    `/accounts/${api.accountId}/workflows/${name}`,
+  );
+  if (!response.ok && response.status !== 404) {
+    await handleApiError(response, "delete", "workflow", name);
+  }
+}

package/src/cloudflare/wrangler.json.ts

@@ -14,7 +14,8 @@ import type { EventSource } from "./event-source.ts";
 import { isQueueEventSource } from "./event-source.ts";
 import { isQueue } from "./queue.ts";
 import { unencryptSecrets } from "./util/filter-env-bindings.ts";
-import { isWorker, type Worker, type WorkerProps } from "./worker.ts";
+import { getAccountSubdomain } from "./worker-subdomain.ts";
+import { isWorker, Worker, type WorkerProps } from "./worker.ts";
 
 /**
  * Properties for wrangler.json configuration file
@@ -180,6 +181,7 @@ export async function WranglerJson(
       Scope.current.local && !props.worker.dev?.remote,
       async () =>
         worker.accountId ?? (await createCloudflareApi(worker)).accountId,
+      async () => await getAccountSubdomain(await createCloudflareApi(worker)),
     );
   }
 
@@ -253,6 +255,7 @@ async function processBindings(
   writeSecrets: boolean,
   local: boolean,
   getAccountId: () => Promise<string>,
+  getAccountSubdomain: () => Promise<string>,
 ): Promise<void> {
   // Arrays to collect different binding types
   const kvNamespaces: WranglerJsonConfig["kv_namespaces"] = [];
@@ -322,6 +325,16 @@ async function processBindings(
         service: workerName,
         entrypoint: binding.__entrypoint__,
       });
+    } else if (binding.type === "cloudflare::Worker::DevDomain") {
+      const subdomain = await getAccountSubdomain();
+      // Subdomain binding
+      (spec.vars ??= {})[bindingName] =
+        `${workerName}.${subdomain}.workers.dev`;
+    } else if (binding.type === "cloudflare::Worker::DevUrl") {
+      const subdomain = await getAccountSubdomain();
+      // Subdomain binding
+      (spec.vars ??= {})[bindingName] =
+        `https://${workerName}.${subdomain}.workers.dev`;
     } else if (binding.type === "service") {
       // Service binding
       services.push({

package/src/docker/api.ts

@@ -69,6 +69,12 @@ type VolumeInfo = {
   Scope: string;
 };
 
+type ContainerInfo = {
+  Id: string;
+  State: { Status: "created" | "running" | "paused" | "stopped" | "exited" };
+  Created: string;
+};
+
 /**
  * Docker API client that wraps Docker CLI commands
  */
@@ -134,7 +140,8 @@ export class DockerApi {
     } catch (error: any) {
       const message = stderr || error.message || "Command failed";
       if (
-        message.includes("unexpected status from HEAD request") &&
+        (message.includes("unexpected status from HEAD request") ||
+          message.includes("502 Bad Gateway")) &&
         remainingAttempts > 0
       ) {
         await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -350,6 +357,21 @@ export class DockerApi {
     return stdout;
   }
 
+  /**
+   * Get Docker container information
+   *
+   * @param containerId Container ID or name
+   * @returns Container details in JSON format
+   */
+  async inspectContainer(containerId: string): Promise<ContainerInfo[]> {
+    const { stdout } = await this.exec(["container", "inspect", containerId]);
+    try {
+      return JSON.parse(stdout.trim()) as ContainerInfo[];
+    } catch (_error) {
+      return [];
+    }
+  }
+
   /**
    * Check if a container exists
    *
@@ -358,7 +380,7 @@ export class DockerApi {
    */
   async containerExists(containerId: string): Promise<boolean> {
     try {
-      await this.exec(["inspect", containerId]);
+      await this.inspectContainer(containerId);
       return true;
     } catch (_error) {
       return false;

package/src/docker/container.ts

@@ -176,6 +176,12 @@ export interface ContainerProps {
    * Healthcheck configuration
    */
   healthcheck?: HealthcheckConfig;
+
+  /**
+   * Whether to adopt the container if it already exists
+   * @default false
+   */
+  adopt?: boolean;
 }
 
 /**
@@ -303,71 +309,96 @@ export const Container = Resource(
 
       // Return destroyed state
       return this.destroy();
-    } else {
-      let containerState: NonNullable<Container["state"]> = "created";
+    }
 
-      if (this.phase === "update") {
-        // Check if container already exists (for update)
-        const containerExists = await api.containerExists(containerName);
+    let containerState: NonNullable<Container["state"]> = "created";
 
-        if (containerExists) {
-          // Remove existing container for update
-          await api.removeContainer(containerName, true);
+    // Check if container already exists
+    const containerExists = await api.containerExists(containerName);
+
+    if (containerExists) {
+      if (this.phase === "update") {
+        // Remove existing container for update
+        await api.removeContainer(containerName, true);
+      } else {
+        // Create phase - check for adoption
+        if (!props.adopt) {
+          throw new Error(
+            `Container "${containerName}" already exists. Use adopt: true to adopt it.`,
+          );
         }
-      }
 
-      // Prepare port mappings
-      const portMappings: Record<string, string> = {};
-      if (props.ports) {
-        for (const port of props.ports) {
-          const protocol = port.protocol || "tcp";
-          portMappings[`${port.external}`] = `${port.internal}/${protocol}`;
+        // Adopt existing container
+        const containerInfos = await api.inspectContainer(containerName);
+        const containerInfo = containerInfos[0];
+        let adoptedState = containerInfo.State.Status;
+
+        // Optionally start the container if requested
+        if (props.start && containerInfo.State.Status !== "running") {
+          await api.startContainer(containerName);
+          adoptedState = "running";
         }
+
+        return {
+          ...props,
+          id: containerInfo.Id,
+          name: containerName,
+          state: adoptedState,
+          createdAt: new Date(containerInfo.Created).getTime(),
+        };
       }
+    }
 
-      // Prepare volume mappings
-      const volumeMappings: Record<string, string> = {};
-      if (props.volumes) {
-        for (const volume of props.volumes) {
-          const readOnlyFlag = volume.readOnly ? ":ro" : "";
-          volumeMappings[volume.hostPath] =
-            `${volume.containerPath}${readOnlyFlag}`;
-        }
+    // Prepare port mappings
+    const portMappings: Record<string, string> = {};
+    if (props.ports) {
+      for (const port of props.ports) {
+        const protocol = port.protocol || "tcp";
+        portMappings[`${port.external}`] = `${port.internal}/${protocol}`;
       }
+    }
 
-      // Create new container
-      const containerId = await api.createContainer(imageRef, containerName, {
-        ports: portMappings,
-        env: props.environment,
-        volumes: volumeMappings,
-        cmd: props.command,
-        healthcheck: props.healthcheck,
-      });
-
-      // Connect to networks if specified
-      if (props.networks) {
-        for (const network of props.networks) {
-          const networkId =
-            typeof network === "string" ? network : network.name;
-          await api.connectNetwork(containerId, networkId, {
-            aliases: network.aliases,
-          });
-        }
+    // Prepare volume mappings
+    const volumeMappings: Record<string, string> = {};
+    if (props.volumes) {
+      for (const volume of props.volumes) {
+        const readOnlyFlag = volume.readOnly ? ":ro" : "";
+        volumeMappings[volume.hostPath] =
+          `${volume.containerPath}${readOnlyFlag}`;
       }
+    }
 
-      // Start container if requested
-      if (props.start) {
-        await api.startContainer(containerId);
-        containerState = "running";
+    // Create new container
+    const containerId = await api.createContainer(imageRef, containerName, {
+      ports: portMappings,
+      env: props.environment,
+      volumes: volumeMappings,
+      cmd: props.command,
+      healthcheck: props.healthcheck,
+    });
+
+    // Connect to networks if specified
+    if (props.networks) {
+      for (const network of props.networks) {
+        const networkId = typeof network === "string" ? network : network.name;
+        await api.connectNetwork(containerId, networkId, {
+          aliases: network.aliases,
+        });
       }
+    }
 
-      return {
-        ...props,
-        id: containerId,
-        name: containerName,
-        state: containerState,
-        createdAt: Date.now(),
-      };
+    // Start container if requested
+    if (props.start) {
+      await api.startContainer(containerId);
+      containerState = "running";
     }
+
+    return {
+      ...props,
+      id: containerId,
+      name: containerName,
+      state: containerState,
+      createdAt: Date.now(),
+    };
   },
 );