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,
});
},
});