alchemy 0.85.1 → 0.86.0

package/src/docker/api.ts

@@ -69,10 +69,44 @@ type VolumeInfo = {
   Scope: string;
 };
 
-type ContainerInfo = {
+export type ContainerInfo = {
   Id: string;
   State: { Status: "created" | "running" | "paused" | "stopped" | "exited" };
   Created: string;
+  Config: {
+    Image: string;
+    Cmd: string[] | null;
+    Env: string[] | null;
+    Healthcheck?: {
+      Test: string[] | null;
+      Interval?: number;
+      Timeout?: number;
+      Retries?: number;
+      StartPeriod?: number;
+      StartInterval?: number;
+    } | null;
+  };
+  HostConfig: {
+    PortBindings: Record<
+      string,
+      Array<{ HostIp: string; HostPort: string }> | null
+    > | null;
+    Binds: string[] | null;
+    RestartPolicy: {
+      Name: string;
+      MaximumRetryCount: number;
+    };
+    AutoRemove: boolean;
+  };
+  NetworkSettings: {
+    Networks: Record<
+      string,
+      {
+        NetworkID: string;
+        Aliases: string[] | null;
+      }
+    > | null;
+  };
 };
 
 /**
@@ -103,6 +137,7 @@ export class DockerApi {
   async exec(
     args: string[],
     remainingAttempts = 3,
+    quiet = false,
   ): Promise<{ stdout: string; stderr: string }> {
     // If a custom config directory is provided, ensure all commands use it by
     // setting the DOCKER_CONFIG env variable for the spawned process.
@@ -124,13 +159,17 @@ export class DockerApi {
 
     // Stream stdout in real-time
     subprocess.stdout?.on("data", (chunk: string) => {
-      process.stdout.write(chunk);
+      if (!quiet) {
+        process.stdout.write(chunk);
+      }
       stdout += chunk;
     });
 
     // Stream stderr in real-time
     subprocess.stderr?.on("data", (chunk: string) => {
-      process.stderr.write(chunk);
+      if (!quiet) {
+        process.stderr.write(chunk);
+      }
       stderr += chunk;
     });
 
@@ -364,7 +403,11 @@ export class DockerApi {
    * @returns Container details in JSON format
    */
   async inspectContainer(containerId: string): Promise<ContainerInfo[]> {
-    const { stdout } = await this.exec(["container", "inspect", containerId]);
+    const { stdout } = await this.exec(
+      ["container", "inspect", containerId],
+      undefined,
+      true,
+    );
     try {
       return JSON.parse(stdout.trim()) as ContainerInfo[];
     } catch (_error) {

package/src/docker/container.ts

@@ -1,6 +1,6 @@
 import type { Context } from "../context.ts";
 import { Resource } from "../resource.ts";
-import { DockerApi } from "./api.ts";
+import { DockerApi, normalizeDuration, type ContainerInfo } from "./api.ts";
 import type { Image } from "./image.ts";
 import type { RemoteImage } from "./remote-image.ts";
 
@@ -201,7 +201,7 @@ export interface Container extends ContainerProps {
   /**
    * Container state
    */
-  state?: "created" | "running" | "paused" | "stopped" | "exited";
+  state: "created" | "running" | "paused" | "stopped" | "exited";
 
   /**
    * Time when the container was created
@@ -277,6 +277,7 @@ export interface Container extends ContainerProps {
  */
 export const Container = Resource(
   "docker::Container",
+  { alwaysUpdate: true },
   async function (
     this: Context<Container>,
     id: string,
@@ -311,39 +312,63 @@ export const Container = Resource(
       return this.destroy();
     }
 
-    let containerState: NonNullable<Container["state"]> = "created";
+    let containerState: Container["state"] = "created";
 
     // 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);
+      // Create phase - check for adoption
+      if (this.phase === "create" && !props.adopt) {
+        throw new Error(
+          `Container "${containerName}" already exists. Use adopt: true to adopt it.`,
+        );
+      }
+
+      const [containerInfo] = await api.inspectContainer(containerName);
+
+      // Compute what changes are needed
+      if (shouldReplace(imageRef, props, containerInfo)) {
+        // Need to recreate - remove existing container
+        if (this.phase === "update") {
+          // In update phase, we can replace the resource
+          // Force because we need to delete the old one first if the name is the same
+          return this.replace(true);
+        } else {
+          // In create phase, we cannot replace the resource, so manually delete instead
+          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.`,
-          );
+        // Apply incremental changes without recreating the container
+
+        const { toConnect, toDisconnect } = getNetworkChanges(
+          props,
+          containerInfo,
+        );
+
+        // Apply network disconnections
+        for (const network of toDisconnect) {
+          await api.disconnectNetwork(containerInfo.Id, network);
         }
 
-        // Adopt existing container
-        const containerInfos = await api.inspectContainer(containerName);
-        const containerInfo = containerInfos[0];
-        let adoptedState = containerInfo.State.Status;
+        // Apply network connections
+        for (const network of toConnect) {
+          await api.connectNetwork(containerInfo.Id, network.name, {
+            aliases: network.aliases,
+          });
+        }
 
         // Optionally start the container if requested
         if (props.start && containerInfo.State.Status !== "running") {
-          await api.startContainer(containerName);
-          adoptedState = "running";
+          await api.startContainer(containerInfo.Id);
+          containerState = "running";
         }
 
         return {
           ...props,
           id: containerInfo.Id,
           name: containerName,
-          state: adoptedState,
+          state: containerState,
           createdAt: new Date(containerInfo.Created).getTime(),
         };
       }
@@ -402,3 +427,278 @@ export const Container = Resource(
     };
   },
 );
+
+function getNetworkChanges(
+  props: ContainerProps,
+  containerInfo: ContainerInfo,
+): { toConnect: NetworkMapping[]; toDisconnect: string[] } {
+  const currentNetworks = new Set(
+    Object.keys(containerInfo.NetworkSettings.Networks || {}),
+  );
+  const desiredNetworks = new Map(
+    (props.networks || []).map((n) => [n.name, n]),
+  );
+  const toConnect: NetworkMapping[] = [];
+  const toDisconnect: string[] = [];
+  for (const network of currentNetworks) {
+    if (!desiredNetworks.has(network) && network !== "bridge") {
+      toDisconnect.push(network);
+    }
+  }
+  for (const [name, config] of desiredNetworks) {
+    if (!currentNetworks.has(name)) {
+      toConnect.push(config);
+    }
+  }
+  return { toConnect, toDisconnect };
+}
+
+function shouldReplace(
+  imageRef: string,
+  props: ContainerProps,
+  containerInfo: ContainerInfo,
+): boolean {
+  // Check immutable properties that require recreation
+
+  // Image change - compare the image ID/digest if available
+  // The container stores the resolved image ID, so we compare against imageRef
+  if (containerInfo.Config.Image !== imageRef) {
+    return true;
+  }
+
+  // Command change
+  const containerCmd = containerInfo.Config.Cmd || [];
+  if (
+    props.command && // only compare if command is set; otherwise we'd be comparing against the image's default command
+    (props.command.length !== containerCmd.length ||
+      !props.command.every((c, i) => c === containerCmd[i]))
+  ) {
+    return true;
+  }
+
+  // Environment variables
+  if (!compareEnv(props.environment, containerInfo.Config.Env)) {
+    return true;
+  }
+
+  // Port bindings
+  if (!comparePorts(props.ports, containerInfo.HostConfig.PortBindings)) {
+    return true;
+  }
+
+  // Volume bindings
+  if (!compareVolumes(props.volumes, containerInfo.HostConfig.Binds)) {
+    return true;
+  }
+
+  // Healthcheck
+  if (
+    !compareHealthcheck(props.healthcheck, containerInfo.Config.Healthcheck)
+  ) {
+    return true;
+  }
+
+  // Restart policy
+  if (
+    !compareRestartPolicy(props.restart, containerInfo.HostConfig.RestartPolicy)
+  ) {
+    return true;
+  }
+
+  // AutoRemove (removeOnExit)
+  if ((props.removeOnExit || false) !== containerInfo.HostConfig.AutoRemove) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Normalize port mappings to a comparable format
+ * @internal
+ */
+function normalizePortMappings(
+  ports: PortMapping[] | undefined,
+): Map<string, string> {
+  const map = new Map<string, string>();
+  if (!ports) return map;
+  for (const port of ports) {
+    const protocol = port.protocol || "tcp";
+    map.set(`${port.external}`, `${port.internal}/${protocol}`);
+  }
+  return map;
+}
+
+/**
+ * Normalize volume mappings to a comparable format
+ * @internal
+ */
+function normalizeVolumeMappings(
+  volumes: VolumeMapping[] | undefined,
+): Set<string> {
+  const set = new Set<string>();
+  if (!volumes) return set;
+  for (const volume of volumes) {
+    const readOnlyFlag = volume.readOnly ? ":ro" : "";
+    set.add(`${volume.hostPath}:${volume.containerPath}${readOnlyFlag}`);
+  }
+  return set;
+}
+
+/**
+ * Compare environment variables
+ * @internal
+ */
+function compareEnv(
+  propsEnv: Record<string, string> | undefined,
+  containerEnv: string[] | null,
+): boolean {
+  const propsEntries = Object.entries(propsEnv || {}).sort(([a], [b]) =>
+    a.localeCompare(b),
+  );
+  const containerEntries = (containerEnv || [])
+    .map((e) => {
+      const idx = e.indexOf("=");
+      return idx >= 0 ? ([e.slice(0, idx), e.slice(idx + 1)] as const) : null;
+    })
+    .filter((e): e is [string, string] => e !== null)
+    // Filter out PATH and other system env vars that Docker adds
+    .filter(([key]) => propsEnv && key in propsEnv)
+    .sort(([a], [b]) => a.localeCompare(b));
+
+  if (propsEntries.length !== containerEntries.length) return false;
+  for (let i = 0; i < propsEntries.length; i++) {
+    if (
+      propsEntries[i][0] !== containerEntries[i][0] ||
+      propsEntries[i][1] !== containerEntries[i][1]
+    ) {
+      return false;
+    }
+  }
+  return true;
+}
+
+/**
+ * Compare port bindings
+ * @internal
+ */
+function comparePorts(
+  propsPorts: PortMapping[] | undefined,
+  containerPorts: Record<
+    string,
+    Array<{ HostIp: string; HostPort: string }> | null
+  > | null,
+): boolean {
+  const propsMap = normalizePortMappings(propsPorts);
+
+  // Extract container port mappings
+  const containerMap = new Map<string, string>();
+  if (containerPorts) {
+    for (const [containerPort, bindings] of Object.entries(containerPorts)) {
+      if (bindings && bindings.length > 0) {
+        containerMap.set(bindings[0].HostPort, containerPort);
+      }
+    }
+  }
+
+  if (propsMap.size !== containerMap.size) return false;
+  for (const [hostPort, containerPort] of propsMap) {
+    if (containerMap.get(hostPort) !== containerPort) return false;
+  }
+  return true;
+}
+
+/**
+ * Compare volume bindings
+ * @internal
+ */
+function compareVolumes(
+  propsVolumes: VolumeMapping[] | undefined,
+  containerBinds: string[] | null,
+): boolean {
+  const propsSet = normalizeVolumeMappings(propsVolumes);
+  const containerSet = new Set(containerBinds || []);
+
+  if (propsSet.size !== containerSet.size) return false;
+  for (const bind of propsSet) {
+    if (!containerSet.has(bind)) return false;
+  }
+  return true;
+}
+
+/**
+ * Compare healthcheck configuration
+ * @internal
+ */
+function compareHealthcheck(
+  propsHc: HealthcheckConfig | undefined,
+  containerHc:
+    | {
+        Test: string[] | null;
+        Interval?: number;
+        Timeout?: number;
+        Retries?: number;
+        StartPeriod?: number;
+        StartInterval?: number;
+      }
+    | null
+    | undefined,
+): boolean {
+  // Both undefined/null
+  if (!propsHc && !containerHc) return true;
+  // One defined, one not
+  if (!propsHc || !containerHc) return false;
+
+  // Compare command
+  const propsCmd = Array.isArray(propsHc.cmd)
+    ? propsHc.cmd.join(" ")
+    : propsHc.cmd;
+  const containerCmd = containerHc.Test
+    ? containerHc.Test.slice(1).join(" ")
+    : "";
+  if (propsCmd !== containerCmd) return false;
+
+  // Helper to convert Duration to nanoseconds for comparison
+  const toNanos = (d: Duration | undefined): number => {
+    if (d === undefined) return 0;
+    const str = normalizeDuration(d);
+    const match = str.match(/^(\d+(?:\.\d+)?)(ms|s|m|h)$/);
+    if (!match) return 0;
+    const value = parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value * 1_000_000;
+      case "s":
+        return value * 1_000_000_000;
+      case "m":
+        return value * 60 * 1_000_000_000;
+      case "h":
+        return value * 3600 * 1_000_000_000;
+      default:
+        return 0;
+    }
+  };
+
+  if (toNanos(propsHc.interval) !== (containerHc.Interval || 0)) return false;
+  if (toNanos(propsHc.timeout) !== (containerHc.Timeout || 0)) return false;
+  if ((propsHc.retries || 0) !== (containerHc.Retries || 0)) return false;
+  if (toNanos(propsHc.startPeriod) !== (containerHc.StartPeriod || 0))
+    return false;
+  if (toNanos(propsHc.startInterval) !== (containerHc.StartInterval || 0))
+    return false;
+
+  return true;
+}
+
+/**
+ * Compare restart policy
+ * @internal
+ */
+function compareRestartPolicy(
+  propsRestart: ContainerProps["restart"] | undefined,
+  containerRestart: { Name: string; MaximumRetryCount: number },
+): boolean {
+  const propsPolicy = propsRestart || "no";
+  return propsPolicy === containerRestart.Name;
+}

package/src/test/bun.ts

@@ -157,7 +157,7 @@ export function test(meta: ImportMeta, defaultOptions?: TestOptions): test {
     const timeout =
       typeof args[args.length - 1] === "number"
         ? (args[args.length - 1] as number)
-        : 120000;
+        : 150000;
     const spread = (obj: any) =>
       obj && typeof obj === "object"
         ? Object.fromEntries(

package/src/test/vitest.ts

@@ -196,7 +196,7 @@ export function test(
     const timeout =
       typeof args[args.length - 1] === "number"
         ? (args[args.length - 1] as number)
-        : 120000;
+        : 150000;
     const spread = (obj: any) =>
       obj && typeof obj === "object"
         ? Object.fromEntries(

package/workers/tunnel-proxy.js

@@ -83,7 +83,7 @@ const renderErrorHtml = (props) => `
             Alchemy</a>.</p>
       </div>
       <div class="bg-slate-200 px-5 py-3 flex flex-col w-full max-w-lg">
-        <p class="text-sm text-slate-500">Alchemy 0.85.1</p>
+        <p class="text-sm text-slate-500">Alchemy 0.86.0</p>
       </div>
     </div>
   </body>