alchemy 2.0.0-beta.59 → 2.0.0-beta.60

package/src/AWS/EC2/Subnet.ts

@@ -9,7 +9,12 @@ import { isResolved, somePropsAreDifferent } from "../../Diff.ts";
 import * as Provider from "../../Provider.ts";
 import { Resource } from "../../Resource.ts";
 import type { Providers } from "../Providers.ts";
-import { createInternalTags, createTagsList, diffTags } from "../../Tags.ts";
+import {
+  createInternalTags,
+  createTagsList,
+  diffTags,
+  hasTags,
+} from "../../Tags.ts";
 import type { AccountID } from "../Environment.ts";
 import type { RegionID } from "../Region.ts";
 import type { VpcId } from "./Vpc.ts";
@@ -388,7 +393,7 @@ export const SubnetProvider = () =>
 
           // Ensure — create the subnet when missing.
           if (subnet === undefined) {
-            const createResult = yield* ec2
+            const newSubnetId = yield* ec2
               .createSubnet({
                 VpcId: news.vpcId,
                 CidrBlock: news.cidrBlock,
@@ -413,9 +418,49 @@ export const SubnetProvider = () =>
                   while: (e) => e._tag === "InvalidVpcID.NotFound",
                   schedule: Schedule.exponential(100),
                 }),
+                Effect.map((createResult) => {
+                  const newSubnetId = createResult.Subnet!
+                    .SubnetId! as SubnetId;
+                  return newSubnetId;
+                }),
+                Effect.tap((newSubnetId) =>
+                  session.note(`Subnet created: ${newSubnetId}`),
+                ),
+                Effect.catchTag("InvalidSubnet.Conflict", (error) =>
+                  Effect.gen(function* () {
+                    // The CIDR is occupied. A prior interrupted run may have
+                    // created this subnet but failed to persist state —
+                    // observe by VPC + CIDR and take it over only when it
+                    // carries our ownership tags; a foreign subnet re-fails
+                    // with the typed conflict.
+                    if (news.cidrBlock === undefined) {
+                      return yield* Effect.fail(error);
+                    }
+                    const lookup = yield* ec2.describeSubnets({
+                      Filters: [
+                        { Name: "vpc-id", Values: [news.vpcId] },
+                        { Name: "cidr-block", Values: [news.cidrBlock] },
+                      ],
+                    });
+                    const existing = lookup.Subnets?.find((s) =>
+                      hasTags(
+                        alchemyTags,
+                        Object.fromEntries(
+                          (s.Tags ?? []).map((t) => [t.Key ?? "", t.Value]),
+                        ),
+                      ),
+                    );
+                    if (existing?.SubnetId === undefined) {
+                      return yield* Effect.fail(error);
+                    }
+                    const existingId = existing.SubnetId as SubnetId;
+                    yield* session.note(
+                      `Recovered subnet ${existingId} at ${news.cidrBlock} owned by this stack (left by an interrupted run)`,
+                    );
+                    return existingId;
+                  }),
+                ),
               );
-            const newSubnetId = createResult.Subnet!.SubnetId! as SubnetId;
-            yield* session.note(`Subnet created: ${newSubnetId}`);
             subnet = yield* waitForSubnetAvailable(newSubnetId, session);
           }
 

package/src/AWS/EC2/hosted.ts

@@ -1,17 +1,19 @@
 import * as iam from "@distilled.cloud/aws/iam";
 import * as s3 from "@distilled.cloud/aws/s3";
-import * as Config from "effect/Config";
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import type * as rolldown from "rolldown";
 import * as Bundle from "../../Bundle/Bundle.ts";
-import { findCwdForBundle } from "../../Bundle/TempRoot.ts";
+import { findCwdForBundle, resolveMainPath } from "../../Bundle/TempRoot.ts";
 import type { ScopedPlanStatusSession } from "../../Cli/Cli.ts";
-import * as Output from "../../Output.ts";
+import type { Input } from "../../Input.ts";
 import { createPhysicalName } from "../../PhysicalName.ts";
 import type { PlatformProps } from "../../Platform.ts";
 import type { ResourceBinding } from "../../Resource.ts";
-import type { ProcessContext } from "../../Server/Process.ts";
+import {
+  createHostRuntimeContext,
+  type HostRuntimeContext,
+} from "../../Server/Process.ts";
 import { createInternalTags, createTagsList, hasTags } from "../../Tags.ts";
 import { sha256 } from "../../Util/sha256.ts";
 import { zipCode } from "../../Util/zip.ts";
@@ -27,7 +29,7 @@ export interface Ec2HostedBinding {
 export interface Ec2HostedProps extends PlatformProps {
   imageId: string;
   instanceType: string;
-  keyName?: string;
+  keyName?: Input<string>;
   instanceProfileName?: string;
   userData?: string;
   subnetId?: any;
@@ -72,60 +74,16 @@ export interface Ec2HostedCleanupState {
 
 /**
  * Deploy-time / plan-time host context for EC2-backed platforms that bundle a
- * long-lived program (`exports.program`) and collect background work via `run`.
+ * long-lived program (`exports.program`) and collect background work via `run`
+ * / HTTP handlers via `serve`. Alias of the shared {@link HostRuntimeContext}.
  */
-export interface Ec2HostRuntimeContext extends ProcessContext {
-  exports: Effect.Effect<{
-    readonly program: Effect.Effect<void, never, any>;
-  }>;
-}
+export type Ec2HostRuntimeContext = HostRuntimeContext;
 
-export const createEc2HostRuntimeContext =
-  (type: string) =>
-  (id: string): Ec2HostRuntimeContext => {
-    const runners: Effect.Effect<void, never, any>[] = [];
-    const env: Record<string, any> = {};
-
-    return {
-      Type: type,
-      id,
-      env,
-      set: (bindingId: string, output: Output.Output) =>
-        Effect.sync(() => {
-          const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
-          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
-          return key;
-        }),
-      get: <T>(key: string) =>
-        Config.string(key).pipe(
-          Effect.flatMap((value) =>
-            Effect.try({
-              try: () => JSON.parse(value) as T,
-              catch: (error) => error as Error,
-            }),
-          ),
-          Effect.catch((cause) =>
-            Effect.die(
-              new Error(`Failed to get environment variable: ${key}`, {
-                cause,
-              }),
-            ),
-          ),
-        ),
-      run: (effect: Effect.Effect<void, never, any>) =>
-        Effect.sync(() => {
-          runners.push(effect);
-        }),
-      exports: Effect.sync(() => ({
-        program: Effect.all(runners, { concurrency: "unbounded" }),
-      })),
-    } satisfies Ec2HostRuntimeContext;
-  };
+export const createEc2HostRuntimeContext = createHostRuntimeContext;
 
 export const createEc2HostedSupport = ({
   stackName,
   stage,
-  fs,
   virtualEntryPlugin,
   resourceType,
 }: {
@@ -184,7 +142,7 @@ export const createEc2HostedSupport = ({
     }
 
     const handler = props.handler ?? "default";
-    const realMain = yield* fs.realPath(props.main);
+    const realMain = yield* resolveMainPath(props.main);
     const cwd = yield* findCwdForBundle(realMain);
 
     const buildBundle = Effect.fn(function* (
@@ -197,14 +155,26 @@ export const createEc2HostedSupport = ({
           input: entry,
           cwd,
           platform: "node",
+          // The hosted process runs under `bun` (installed by the user-data);
+          // keep `bun`/`bun:*` external and resolve the `bun` export condition
+          // so `@effect/platform-bun` picks its Bun implementations.
+          external: [
+            "bun",
+            "bun:*",
+            ...((props.build?.input?.external as string[] | undefined) ?? []),
+          ],
+          resolve: {
+            conditionNames: ["bun", "import", "module", "default"],
+            ...props.build?.input?.resolve,
+          },
           plugins: [props.build?.input?.plugins, plugins],
         },
         {
           ...props.build?.output,
           format: "esm",
           sourcemap: props.build?.output?.sourcemap ?? false,
-          minify: props.build?.output?.minify ?? true,
-          entryFileNames: "index.js",
+          minify: props.build?.output?.minify ?? false,
+          entryFileNames: "index.mjs",
         },
       );
     });
@@ -215,7 +185,8 @@ export const createEc2HostedSupport = ({
           realMain,
           virtualEntryPlugin(
             (importPath) => `
-import { NodeServices } from "@effect/platform-node";
+import { BunServices } from "@effect/platform-bun";
+import { BunHttpServer } from "alchemy/Http";
 import { Stack } from "alchemy/Stack";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -229,13 +200,17 @@ import * as Region from "@distilled.cloud/aws/Region";
 import { ${handler} as handler } from ${JSON.stringify(importPath)};
 
 const platform = Layer.mergeAll(
-  NodeServices.layer,
+  BunServices.layer,
   FetchHttpClient.layer,
   Logger.layer([Logger.consolePretty()]),
 );
 
+// Resolve the bundled program (the runners registered via host.run / serve)
+// and run it with a Bun HTTP server bound to PORT, so a returned { fetch }
+// handler is actually served and host.run loops stay alive.
 const program = handler.pipe(
-  Effect.flatMap((instance) => instance.RuntimeContext.exports.program),
+  Effect.flatMap((instance) => instance.RuntimeContext.exports),
+  Effect.flatMap((exports) => exports.program),
   Effect.provide(
     Layer.effect(
       Stack,
@@ -253,6 +228,7 @@ const program = handler.pipe(
     ).pipe(
       Layer.provideMerge(Credentials.fromEnv()),
       Layer.provideMerge(Region.fromEnv()),
+      Layer.provideMerge(BunHttpServer()),
       Layer.provideMerge(platform),
       Layer.provideMerge(
         Layer.succeed(
@@ -265,18 +241,28 @@ const program = handler.pipe(
   Effect.scoped
 );
 
-await Effect.runPromise(program);
+console.log("Instance bootstrap starting...");
+await Effect.runPromise(program).catch((err) => {
+  console.error("Instance bootstrap failed:", err);
+  process.exit(1);
+});
 `,
           ),
         );
 
-    const mainFile = bundleOutput.files[0];
-    const code =
-      typeof mainFile.content === "string"
-        ? new TextEncoder().encode(mainFile.content)
-        : mainFile.content;
-
-    const archive = yield* zipCode(code);
+    // Zip every emitted file: the entry becomes `index.mjs` (what the systemd
+    // unit runs) and shared chunks keep their `*.js` names so the entry's
+    // relative imports resolve. Dropping a chunk crashes the process at start.
+    const toBytes = (content: string | Uint8Array<ArrayBufferLike>) =>
+      typeof content === "string" ? new TextEncoder().encode(content) : content;
+    const [entryFile, ...chunkFiles] = bundleOutput.files;
+    const archive = yield* zipCode(
+      toBytes(entryFile.content),
+      chunkFiles.map((file) => ({
+        path: file.path,
+        content: toBytes(file.content),
+      })),
+    );
     return { archive, hash: bundleOutput.hash };
   });
 
@@ -304,39 +290,54 @@ await Effect.runPromise(program);
     region: string;
   }) {
     const appDir = `/opt/${unitName}`;
+    const bucket = yield* Assets.BucketName;
+    // User-data runs once via cloud-init's `scripts-user` (once-per-instance),
+    // and is skipped on any subsequent boot — so it must NOT carry the work
+    // that can fail transiently (bun install over the network, S3 sync). It
+    // only writes the setup script + unit and enables the service. The systemd
+    // service (Restart=always) runs the setup on every start, so a flaky bun
+    // install / S3 read self-heals and the service survives reboots.
     return `#!/bin/bash
-set -euo pipefail
-
-PKG_INSTALL=""
-if command -v dnf >/dev/null 2>&1; then
-  PKG_INSTALL="dnf install -y"
-elif command -v yum >/dev/null 2>&1; then
-  PKG_INSTALL="yum install -y"
-fi
-
-if [ -n "$PKG_INSTALL" ]; then
-  $PKG_INSTALL unzip curl awscli
-fi
+set -uo pipefail
 
 mkdir -p "${appDir}"
 
+cat >/usr/local/bin/${unitName}-setup.sh <<'SETUP_EOF'
+#!/bin/bash
+set -uo pipefail
 export HOME=/root
+
+# unzip (needed below) — install if missing.
+command -v unzip >/dev/null 2>&1 || {
+  (command -v dnf >/dev/null 2>&1 && dnf install -y unzip) \
+    || (command -v yum >/dev/null 2>&1 && yum install -y unzip) || true
+}
+
+# AWS CLI — preinstalled on Amazon Linux 2023; install v2 otherwise.
+command -v aws >/dev/null 2>&1 || {
+  curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-$(uname -m).zip" -o /tmp/awscliv2.zip \
+    && (cd /tmp && unzip -q -o awscliv2.zip && ./aws/install) || true
+}
+
+# bun — retry the network install a few times.
 if [ ! -x /root/.bun/bin/bun ]; then
-  curl -fsSL https://bun.sh/install | bash
+  for attempt in 1 2 3 4 5; do
+    curl -fsSL https://bun.sh/install | bash && break
+    sleep 5
+  done
 fi
 
-cat >/usr/local/bin/${unitName}-sync.sh <<'EOF'
-#!/bin/bash
-set -euo pipefail
+# Sync the bundle + env from S3 (must succeed for the service to start).
+set -e
 mkdir -p "${appDir}"
-aws s3 cp "s3://${yield* Assets.BucketName}/${bundleKey}" "${appDir}/bundle.zip" --region "${region}"
-aws s3 cp "s3://${yield* Assets.BucketName}/${envKey}" "${appDir}/env" --region "${region}"
+aws s3 cp "s3://${bucket}/${bundleKey}" "${appDir}/bundle.zip" --region "${region}"
+aws s3 cp "s3://${bucket}/${envKey}" "${appDir}/env" --region "${region}"
 rm -f "${appDir}/index.mjs"
 unzip -o "${appDir}/bundle.zip" -d "${appDir}"
-EOF
-chmod +x /usr/local/bin/${unitName}-sync.sh
+SETUP_EOF
+chmod +x /usr/local/bin/${unitName}-setup.sh
 
-cat >/etc/systemd/system/${unitName}.service <<'EOF'
+cat >/etc/systemd/system/${unitName}.service <<'UNIT_EOF'
 [Unit]
 Description=Alchemy EC2 instance runtime ${unitName}
 After=network-online.target
@@ -345,17 +346,16 @@ Wants=network-online.target
 [Service]
 Type=simple
 WorkingDirectory=${appDir}
-ExecStartPre=/usr/local/bin/${unitName}-sync.sh
-EnvironmentFile=${appDir}/env
+ExecStartPre=/usr/local/bin/${unitName}-setup.sh
+EnvironmentFile=-${appDir}/env
 ExecStart=/root/.bun/bin/bun ${appDir}/index.mjs
 Restart=always
 RestartSec=5
 
 [Install]
 WantedBy=multi-user.target
-EOF
+UNIT_EOF
 
-/usr/local/bin/${unitName}-sync.sh
 systemctl daemon-reload
 systemctl enable --now ${unitName}.service
 `;
@@ -832,7 +832,7 @@ systemctl enable --now ${unitName}.service
     return {
       ImageId: news.imageId,
       InstanceType: news.instanceType,
-      KeyName: news.keyName,
+      KeyName: news.keyName as string | undefined,
       IamInstanceProfile: runtime.instanceProfileName
         ? {
             Name: runtime.instanceProfileName,

package/src/AWS/EC2/index.ts

@@ -3,6 +3,7 @@ export * from "./EIP.ts";
 export * from "./Image.ts";
 export * from "./Instance.ts";
 export * from "./InternetGateway.ts";
+export * from "./KeyPair.ts";
 export * from "./NatGateway.ts";
 export * from "./Network.ts";
 export * from "./NetworkAcl.ts";