import * as Cause from "effect/Cause"; import * as Digest from "effect/crypto/Digest"; import * as SecureRandom from "effect/crypto/SecureRandom"; import type { Input as DurationInput } from "effect/Duration"; import * as Effect from "effect/Effect"; import type { FileSystem } from "effect/FileSystem"; import type { HttpServer } from "effect/http/HttpServer"; import type { ServeError } from "effect/http/HttpServerError"; import * as Layer from "effect/Layer"; import * as Logger from "effect/Logger"; import type { Path } from "effect/Path"; import type { ChildProcessSpawner } from "effect/process/ChildProcessSpawner"; import { defaultTeardown, getErrorReported, type Teardown } from "effect/Runtime"; import type { WebSocketConstructor } from "effect/socket/Socket"; import type { Stdio } from "effect/Stdio"; import type { Terminal } from "effect/Terminal"; import { disableCrossSpawnChdir } from "./Node.ts"; const isBun = typeof Bun !== "undefined"; const importPlatformPeer = ( peerDependency: "@effect/platform-bun" | "@effect/platform-node", load: () => Promise, ): Promise => load().catch(() => { console.error( [ `Alchemy could not load the required peer dependency "${peerDependency}".`, `Install a compatible version of "${peerDependency}" in the same project as "alchemy".`, "If it is already installed, you may be running a globally installed Alchemy CLI; run the project-local CLI instead.", ].join("\n"), ); process.exit(1); }); /** * Constructs a layer with different implementations for Bun and Node. */ export const platformLayer = (constructors: { bun: () => Promise>; node: () => Promise>; }) => Layer.unwrap( Effect.promise(async () => { if (isBun) { return await constructors.bun(); } else { return await constructors.node(); } }), ); // effect 4.1 dropped crypto from the platform `*Services` bundles. const WebCryptoServices = Layer.mergeAll(SecureRandom.layerWebCrypto, Digest.layerWebCrypto); export type PlatformServices = | ChildProcessSpawner | Digest.Digest | SecureRandom.SecureRandom | FileSystem | Path | Stdio | Terminal // WebSocketConstructor is not included in NodeServices/BunServices, but required for Workers tail | WebSocketConstructor; export const PlatformServices: Layer.Layer = platformLayer({ bun: async () => { const [BunServices, BunSocket] = await Promise.all([ importPlatformPeer("@effect/platform-bun", () => import("@effect/platform-bun/BunServices")), importPlatformPeer("@effect/platform-bun", () => import("@effect/platform-bun/BunSocket")), ]); return Layer.mergeAll( BunServices.layer, BunSocket.layerWebSocketConstructor, WebCryptoServices, ); }, node: async () => { const [NodeServices, NodeSocket] = await Promise.all([ importPlatformPeer( "@effect/platform-node", () => import("@effect/platform-node/NodeServices"), ), importPlatformPeer("@effect/platform-node", () => import("@effect/platform-node/NodeSocket")), ]); return Layer.mergeAll( NodeServices.layer, NodeSocket.layerWebSocketConstructor, WebCryptoServices, ); }, }); /** * ALWAYS exit once the main effect completes. The platform `runMain` default * only force-exits on failure or signal interruption — a *successful* * `alchemy deploy`/`destroy` otherwise lingers for ~100 seconds after "Done" * while keep-alive sockets (Cloudflare API agents, provider sidecar handles) * pin the event loop until the remote side closes them. All Effect finalizers * have already run by the time teardown is invoked; the macrotask hop lets * any buffered stdout drain before the process exits. */ const exitingTeardown: Teardown = (exit, onExit) => { defaultTeardown(exit, (code) => { const finalCode = code !== 0 ? code : Number(process.exitCode ?? 0) || 0; setTimeout(() => process.exit(finalCode), 0); onExit(finalCode); }); }; export const runMain = ( effect: Effect.Effect, options?: { readonly disableErrorReporting?: boolean | undefined; readonly teardown?: Teardown | undefined; }, ): void => { // Every alchemy process (CLI, exec child, sidecar, build/dev runners) // runs concurrent effects that depend on a stable working directory — // forbid cross-spawn's transient process-wide chdir (see Util/Node.ts). disableCrossSpawnChdir(); const opts = { ...options, teardown: options?.teardown ?? exitingTeardown, // Reported below instead. disableErrorReporting: true, }; // The runtime's report of an unhandled failure, on stderr: stdout carries // only a command's output (`--log-format json` records, for one). if (options?.disableErrorReporting !== true) { effect = Effect.tapCause(effect, (cause) => Cause.hasInterruptsOnly(cause) || !cause.pipe(Cause.squash, getErrorReported) ? Effect.void : Effect.logError(cause).pipe(Effect.provideService(Logger.LogToStderr, true)), ); } if (isBun) { void importPlatformPeer( "@effect/platform-bun", () => import("@effect/platform-bun/BunRuntime"), ).then((BunRuntime) => BunRuntime.runMain(effect, opts)); } else { void importPlatformPeer( "@effect/platform-node", () => import("@effect/platform-node/NodeRuntime"), ).then((NodeRuntime) => NodeRuntime.runMain(effect, opts)); } }; export const httpServer = ( port: number = 0, host: string = "127.0.0.1", options?: { readonly gracefulShutdownTimeout?: DurationInput | undefined; }, ): Layer.Layer => platformLayer({ bun: async () => { const BunHttpServer = await importPlatformPeer( "@effect/platform-bun", () => import("@effect/platform-bun/BunHttpServer"), ); // `idleTimeout: 0` disables Bun's default 10s request idle timeout. // The RPC spawner serves a long-lived `/logs` stream (sidecar output // forwarded to the exec child's renderer) that can legitimately sit // idle between lines; Bun would otherwise sever it mid-session. return BunHttpServer.layer({ hostname: host, port, idleTimeout: 0 }); }, node: async () => { const [NodeHttpServer, Http] = await Promise.all([ importPlatformPeer( "@effect/platform-node", () => import("@effect/platform-node/NodeHttpServer"), ), import("node:http"), ]); return NodeHttpServer.layerServer(Http.createServer, { host, port, gracefulShutdownTimeout: options?.gracefulShutdownTimeout, }); }, });