alchemy 2.0.0-beta.34 → 2.0.0-beta.36

package/bin/cli.js

@@ -21,9 +21,9 @@
 //
 // foreground-child forwards stdio + signals and exits with the child's code,
 // so the launcher is transparent to the invoking shell / npm script.
+import { foregroundChild } from "foreground-child";
 import { fileURLToPath } from "node:url";
 import path from "pathe";
-import { foregroundChild } from "foreground-child";
 
 const execpath = (process.env.npm_execpath ?? "").toLowerCase();
 const userAgent = (process.env.npm_config_user_agent ?? "").toLowerCase();
@@ -38,17 +38,17 @@ const binDir = path.dirname(fileURLToPath(import.meta.url));
 const jsEntry = path.join(binDir, "alchemy.js");
 const tsEntry = path.join(binDir, "alchemy.ts");
 
-// Treat any install-tree path as published; only a raw checkout uses .ts.
-const useTs = !(
+// Treat any install-tree path as published.
+const isDev = !(
   binDir.includes("/node_modules/") || binDir.includes("\\node_modules\\")
 );
 
-// .ts only runs under bun. Force bun in dev even if node was the invoker.
-const runtime = useTs || invokedByBun ? "bun" : "node";
+// We no longer force bun in dev when node is the invoker because this prevents us from testing in node.
+const runtime = invokedByBun ? "bun" : "node";
 
 const args = [];
 
-if (runtime === "bun" && useTs) {
+if (runtime === "bun" && isDev) {
   // Pin bun's tsconfig to alchemy's, not whatever happens to be in the
   // invoking workspace's cwd. Bun's default is `$cwd/tsconfig.json`, which
   // means invoking `alchemy` from e.g. `examples/cloudflare-solidstart`
@@ -58,7 +58,8 @@ if (runtime === "bun" && useTs) {
   args.push(`--tsconfig-override=${path.join(binDir, "..", "tsconfig.json")}`);
 }
 
-args.push(useTs ? tsEntry : jsEntry, ...process.argv.slice(2));
+// .ts only runs under bun.
+args.push(runtime === "bun" ? tsEntry : jsEntry, ...process.argv.slice(2));
 
 process.on("uncaughtException", (error) => {
   if (

package/bin/exec.js

@@ -1,3 +1,4 @@
+import { createRequire } from "node:module";
 import * as ConfigProvider from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -7,6 +8,10 @@ import * as EffectContext from "effect/Context";
 import * as FileSystem from "effect/FileSystem";
 import * as Path$1 from "effect/Path";
 import { Path } from "effect/Path";
+import * as Redacted from "effect/Redacted";
+import path from "pathe";
+import * as Config from "effect/Config";
+import os from "node:os";
 import * as Console from "effect/Console";
 import * as Logger from "effect/Logger";
 import * as Option from "effect/Option";
@@ -16,12 +21,8 @@ import * as Data from "effect/Data";
 import * as Cause from "effect/Cause";
 import * as Deferred from "effect/Deferred";
 import { pipe } from "effect/Function";
-import * as Redacted from "effect/Redacted";
 import { SingleShotGen } from "effect/Utils";
 import { pipeArguments } from "effect/Pipeable";
-import path from "pathe";
-import * as Config from "effect/Config";
-import os from "node:os";
 import * as Duration from "effect/Duration";
 import * as Exit from "effect/Exit";
 import * as Metric from "effect/Metric";
@@ -45,6 +46,130 @@ const AlchemyContextLive = Layer.effect(AlchemyContext, Effect.gen(function* ()
 	};
 }));
 
+//#endregion
+//#region lib/Auth/Profile.js
+const rootDir = path.join(os.homedir(), ".alchemy");
+const configFilePath = path.join(rootDir, "profiles.json");
+/**
+* Config key consulted by the various `fromAuthProvider` /
+* `fromEnvironment` layers to pick which named profile in
+* `~/.alchemy/profiles.json` to use. Defaults to `"default"`.
+*/
+const ALCHEMY_PROFILE = Config.string("ALCHEMY_PROFILE").pipe(Config.withDefault("default"));
+const CONFIG_VERSION = 0;
+const emptyConfig = () => ({
+	version: CONFIG_VERSION,
+	profiles: {}
+});
+var Profile = class extends EffectContext.Service()("Alchemy::Profile") {};
+/**
+* Layer that builds the {@link Profile} service. Captures the
+* {@link FileSystem.FileSystem} dependency at layer-build time, so any
+* Effect that yields {@link Profile} ends up with `R = Profile` (no
+* `FileSystem` leak). Provide this once at the top of your runtime
+* (alongside `PlatformServices` / `NodeContext`).
+*/
+const ProfileLive = Layer.effect(Profile, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const readConfig = fs.readFileString(configFilePath).pipe(Effect.flatMap((data) => Effect.try({
+		try: () => {
+			const parsed = JSON.parse(data);
+			if (parsed?.version !== CONFIG_VERSION) return emptyConfig();
+			return parsed;
+		},
+		catch: emptyConfig
+	})), Effect.orElseSucceed(emptyConfig));
+	const writeConfig = (config) => fs.makeDirectory(path.dirname(configFilePath), { recursive: true }).pipe(Effect.flatMap(() => fs.writeFileString(configFilePath, JSON.stringify(config, null, 2))));
+	const getProfile = (name) => readConfig.pipe(Effect.map((config) => config.profiles[name]));
+	const setProfile = (name, profile$1) => readConfig.pipe(Effect.tap((config) => Effect.sync(() => config.profiles[name] = profile$1)), Effect.flatMap(writeConfig));
+	const deleteProfile = (name) => readConfig.pipe(Effect.flatMap((config) => {
+		if (!(name in config.profiles)) return Effect.succeed(false);
+		delete config.profiles[name];
+		return writeConfig(config).pipe(Effect.as(true));
+	}));
+	const loadOrConfigure = (auth, profileName, ctx) => Effect.flatMap(getProfile(profileName), (existing) => existing?.[auth.name] ? Effect.succeed(existing[auth.name]) : Effect.tap(auth.configure(profileName, ctx), (config) => setProfile(profileName, {
+		...existing,
+		[auth.name]: config
+	})));
+	return {
+		readConfig,
+		writeConfig,
+		getProfile,
+		setProfile,
+		deleteProfile,
+		loadOrConfigure
+	};
+}));
+/**
+* Returns a `ConfigProvider` that overrides `ALCHEMY_PROFILE` with the
+* given `profile` (when explicitly passed via the CLI `--profile` flag),
+* falling through to `base` for everything else.
+*
+* Use this to let the CLI's `--profile <name>` win over `$ALCHEMY_PROFILE`
+* without disturbing other config lookups.
+*/
+const withProfileOverride = (base, profile$1) => {
+	if (profile$1 === void 0) return base;
+	const overrides = { ALCHEMY_PROFILE: profile$1 };
+	const overrideProvider = ConfigProvider.make((path$1) => Effect.succeed(path$1.length === 1 && typeof path$1[0] === "string" && path$1[0] in overrides ? ConfigProvider.makeValue(overrides[path$1[0]]) : void 0));
+	return ConfigProvider.orElse(base)(overrideProvider);
+};
+
+//#endregion
+//#region lib/Auth/Credentials.js
+const credentialsDirPath = path.join(rootDir, "credentials");
+const profileCredentialsDirPath = (profile$1) => path.join(credentialsDirPath, profile$1);
+const credentialsFilePath = (profile$1, provider) => path.join(profileCredentialsDirPath(profile$1), `${provider}.json`);
+var CredentialsStore = class extends EffectContext.Service()("Alchemy::CredentialsStore") {};
+const CredentialsStoreLive = Layer.effect(CredentialsStore, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const read = (profile$1, provider) => fs.readFileString(credentialsFilePath(profile$1, provider)).pipe(Effect.catch(() => Effect.succeed(void 0)), Effect.map((data) => {
+		if (data === void 0) return void 0;
+		try {
+			return JSON.parse(data);
+		} catch {
+			return;
+		}
+	}));
+	const write = (profile$1, provider, credentials) => {
+		const filePath = credentialsFilePath(profile$1, provider);
+		return fs.makeDirectory(path.dirname(filePath), { recursive: true }).pipe(Effect.flatMap(() => fs.writeFileString(filePath, JSON.stringify(credentials, null, 2))));
+	};
+	const remove_ = (profile$1, provider) => fs.remove(credentialsFilePath(profile$1, provider)).pipe(Effect.catch(() => Effect.void));
+	const deleteProfile = (profile$1) => fs.remove(profileCredentialsDirPath(profile$1), { recursive: true }).pipe(Effect.catch(() => Effect.void));
+	return {
+		read,
+		write,
+		delete: remove_,
+		deleteProfile
+	};
+}));
+
+//#endregion
+//#region lib/Util/LocalhostDns.js
+let installed = false;
+const isLocalhost = (hostname) => hostname === "localhost" || hostname === "[::1]" || hostname.endsWith(".localhost");
+const installLocalhostDns = () => {
+	if (installed) return;
+	installed = true;
+	if (typeof globalThis.Bun !== "undefined") return;
+	try {
+		const require = createRequire(import.meta.url);
+		const undici = require("undici");
+		const dns = require("node:dns");
+		undici.setGlobalDispatcher(new undici.Agent({ connect: { lookup: (hostname, options, cb) => {
+			if (isLocalhost(hostname)) {
+				if (options && options.all) return cb(null, [{
+					address: "127.0.0.1",
+					family: 4
+				}]);
+				return cb(null, "127.0.0.1", 4);
+			}
+			return dns.lookup(hostname, options, cb);
+		} } }));
+	} catch {}
+};
+
 //#endregion
 //#region lib/Util/PlatformServices.js
 const isBun = typeof Bun !== "undefined";
@@ -58,6 +183,7 @@ const PlatformServices = Effect.promise(async () => {
 	}
 }).pipe(Layer.unwrap);
 const runMain = (effect, options) => {
+	installLocalhostDns();
 	if (isBun) import("@effect/platform-bun/BunRuntime").then((BunRuntime) => BunRuntime.runMain(effect, options));
 	else import("@effect/platform-node/NodeRuntime").then((NodeRuntime) => NodeRuntime.runMain(effect, options));
 };
@@ -333,44 +459,6 @@ const GenericService = () => (Kind) => {
 	return Object.assign(Object.setPrototypeOf(make$2, service), service);
 };
 
-//#endregion
-//#region lib/Auth/Profile.js
-const rootDir = path.join(os.homedir(), ".alchemy");
-const configFilePath = path.join(rootDir, "profiles.json");
-/**
-* Config key consulted by the various `fromAuthProvider` /
-* `fromEnvironment` layers to pick which named profile in
-* `~/.alchemy/profiles.json` to use. Defaults to `"default"`.
-*/
-const ALCHEMY_PROFILE = Config.string("ALCHEMY_PROFILE").pipe(Config.withDefault("default"));
-const CONFIG_VERSION = 0;
-const emptyConfig = () => ({
-	version: CONFIG_VERSION,
-	profiles: {}
-});
-const readConfig = FileSystem.FileSystem.asEffect().pipe(Effect.flatMap((fs) => fs.readFileString(configFilePath)), Effect.flatMap((data) => Effect.try({
-	try: () => {
-		const parsed = JSON.parse(data);
-		if (parsed?.version !== CONFIG_VERSION) return emptyConfig();
-		return parsed;
-	},
-	catch: emptyConfig
-})), Effect.orElseSucceed(emptyConfig));
-/**
-* Returns a `ConfigProvider` that overrides `ALCHEMY_PROFILE` with the
-* given `profile` (when explicitly passed via the CLI `--profile` flag),
-* falling through to `base` for everything else.
-*
-* Use this to let the CLI's `--profile <name>` win over `$ALCHEMY_PROFILE`
-* without disturbing other config lookups.
-*/
-const withProfileOverride = (base, profile$1) => {
-	if (profile$1 === void 0) return base;
-	const overrides = { ALCHEMY_PROFILE: profile$1 };
-	const overrideProvider = ConfigProvider.make((path$1) => Effect.succeed(path$1.length === 1 && typeof path$1[0] === "string" && path$1[0] in overrides ? ConfigProvider.makeValue(overrides[path$1[0]]) : void 0));
-	return ConfigProvider.orElse(base)(overrideProvider);
-};
-
 //#endregion
 //#region lib/Auth/AuthProvider.js
 var AuthProviders = class extends EffectContext.Service()("AuthProviders") {};
@@ -391,16 +479,16 @@ const loadConfigProvider = (envFile$1) => {
 
 //#endregion
 //#region lib/Util/effect.js
-const taggedFunction = (tag, fn) => {
+const taggedFunction = (tag$1, fn) => {
 	const overrides = {
-		asEffect: () => tag.asEffect(),
-		[Symbol.iterator]: () => tag[Symbol.iterator](),
-		pipe: (...fns) => pipeArguments(tag.asEffect(), fns),
-		toString: () => `${tag.toString()}.${fn.name}`
+		asEffect: () => tag$1.asEffect(),
+		[Symbol.iterator]: () => tag$1[Symbol.iterator](),
+		pipe: (...fns) => pipeArguments(tag$1.asEffect(), fns),
+		toString: () => `${tag$1.toString()}.${fn.name}`
 	};
 	return new Proxy(fn, {
-		get: (target, prop, receiver) => Reflect.has(overrides, prop) ? Reflect.get(overrides, prop, receiver) : Reflect.has(target, prop) ? Reflect.get(target, prop, receiver) : Reflect.get(tag, prop, tag),
-		has: (target, prop) => Reflect.has(overrides, prop) || Reflect.has(target, prop) || Reflect.has(tag, prop)
+		get: (target, prop, receiver) => Reflect.has(overrides, prop) ? Reflect.get(overrides, prop, receiver) : Reflect.has(target, prop) ? Reflect.get(target, prop, receiver) : Reflect.get(tag$1, prop, tag$1),
+		has: (target, prop) => Reflect.has(overrides, prop) || Reflect.has(target, prop) || Reflect.has(tag$1, prop)
 	});
 };
 
@@ -445,7 +533,7 @@ const make$1 = (options) => (effect) => Effect.scope.pipe(Effect.flatMap((scope)
 	services: EffectContext.merge(services$1, context)
 })), Effect.provideContext(context))));
 const CurrentStack = Effect.serviceOption(Stack).asEffect().pipe(Effect.map(Option.getOrUndefined));
-const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.layer([fileLogger("out")], { mergeWithExisting: true }));
+const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer, Logger.layer([fileLogger("out")], { mergeWithExisting: true }), Layer.provide(ProfileLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices));
 
 //#endregion
 //#region lib/Resource.js
@@ -920,7 +1008,7 @@ const make = (stack, options = {}) => Effect.gen(function* () {
 		const ctx = yield* Effect.serviceOption(AlchemyContext);
 		return Option.match(ctx, {
 			onNone: () => false,
-			onSome: (c) => c.adopt
+			onSome: (c$1) => c$1.adopt
 		});
 	});
 	const resourceFqns = yield* state.list({
@@ -2067,6 +2155,99 @@ const planCommand = Command.make("plan", {
 	dryRun: true
 })));
 
+//#endregion
+//#region lib/Cli/LoggingCli.js
+const ESC = "\x1B[";
+const RESET = `${ESC}0m`;
+const useColor = process.stdout.hasColors?.() ?? !!process.stdout.isTTY;
+const c = (code, s) => useColor ? `${ESC}${code}m${s}${RESET}` : s;
+const dim = (s) => c("2", s);
+const bold = (s) => c("1", s);
+const red = (s) => c("31", s);
+const green = (s) => c("32", s);
+const yellow = (s) => c("33", s);
+const blue = (s) => c("34", s);
+const magenta = (s) => c("35", s);
+const cyan = (s) => c("36", s);
+const actionColor$1 = {
+	create: green,
+	update: yellow,
+	replace: magenta,
+	delete: red,
+	noop: dim
+};
+const statusColor$1 = (status) => {
+	switch (status) {
+		case "created":
+		case "updated":
+		case "replaced": return green;
+		case "deleted": return dim;
+		case "fail": return red;
+		case "attaching":
+		case "post-attach": return cyan;
+		default: return yellow;
+	}
+};
+const tag = (id) => bold(`[${id}]`);
+const isTerminal = (status) => status === "created" || status === "updated" || status === "deleted" || status === "replaced" || status === "fail";
+const formatPlanLines = (plan) => {
+	const items = [...Object.values(plan.resources), ...Object.values(plan.deletions)];
+	if (items.length === 0) return [bold("Plan:") + " no changes"];
+	const counts = items.reduce((acc, item) => (acc[item.action] = (acc[item.action] ?? 0) + 1, acc), {});
+	const summary = [
+		"create",
+		"update",
+		"replace",
+		"delete",
+		"noop"
+	].filter((a) => counts[a]).map((a) => actionColor$1[a](`${counts[a]} to ${a}`)).join(dim(", "));
+	const sorted = [...items].sort((a, b) => a.resource.LogicalId.localeCompare(b.resource.LogicalId));
+	const lines = [`${bold("Plan:")} ${summary}`];
+	for (const item of sorted) {
+		const action = actionColor$1[item.action](item.action);
+		lines.push(`${tag(item.resource.LogicalId)} ${action}`);
+		for (const binding of item.bindings) {
+			if (binding.action === "noop") continue;
+			const bindingAction = actionColor$1[binding.action](binding.action);
+			lines.push(`${tag(`${item.resource.LogicalId}/${binding.sid}`)} ${bindingAction}`);
+		}
+	}
+	return lines;
+};
+const LoggingCli = Layer.succeed(Cli, Cli.of({
+	approvePlan: (plan) => Effect.gen(function* () {
+		for (const line of formatPlanLines(plan)) yield* Console.log(line);
+		yield* Console.log(`\n${yellow("Non-interactive terminal detected.")} Pass ${bold("--yes")} to approve, or set ${bold("ALCHEMY_TUI=1")} for the interactive UI.`);
+		return false;
+	}),
+	displayPlan: (plan) => Effect.gen(function* () {
+		for (const line of formatPlanLines(plan)) yield* Console.log(line);
+	}),
+	startApplySession: (plan) => Effect.gen(function* () {
+		for (const line of formatPlanLines(plan)) yield* Console.log(line);
+		yield* Console.log("");
+		const counts = {
+			ok: 0,
+			fail: 0
+		};
+		return {
+			emit: (event) => Effect.sync(() => {
+				if (event.kind === "annotate") {
+					console.log(`${tag(event.id)} ${blue(event.message)}`);
+					return;
+				}
+				const id = event.bindingId ? `${event.id}/${event.bindingId}` : event.id;
+				const status = statusColor$1(event.status)(event.status);
+				const msg = event.message ? ` ${dim("—")} ${event.message}` : "";
+				console.log(`${tag(id)} ${status}${msg}`);
+				if (isTerminal(event.status)) if (event.status === "fail") counts.fail++;
+				else counts.ok++;
+			}),
+			done: () => Console.log(`\n${bold("Done:")} ${green(`${counts.ok} succeeded`)}${counts.fail ? dim(", ") + red(`${counts.fail} failed`) : ""}`)
+		};
+	})
+}));
+
 //#endregion
 //#region lib/Cli/NamespaceTree.js
 function buildNamespaceTree(items) {
@@ -2611,9 +2792,29 @@ const startApplySession = Effect.fn(function* (plan) {
 	};
 });
 
+//#endregion
+//#region lib/Cli/selectCli.js
+/**
+* Returns true when the current process looks like it's being driven by a
+* coding agent, CI runner, or anything else that won't render an interactive
+* TUI well. The Ink renderer repaints the screen on every event, which floods
+* agent transcripts with redundant frames; LoggingCli emits one line per
+* status change instead.
+*/
+const isNonInteractive = () => {
+	const env = process.env;
+	if (env.ALCHEMY_PLAIN === "1" || env.ALCHEMY_NO_TUI === "1") return true;
+	if (env.ALCHEMY_TUI === "1") return false;
+	if (!process.stdout.isTTY) return true;
+	if (env.CI) return true;
+	if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT || env.CURSOR_AGENT || env.AIDER_MODEL || env.CODEX_CLI) return true;
+	return false;
+};
+const selectCli = () => isNonInteractive() ? LoggingCli : inkCLI();
+
 //#endregion
 //#region lib/Cli/exec.js
-const services = Layer.mergeAll(Layer.provideMerge(AlchemyContextLive, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()), inkCLI());
+const services = Layer.mergeAll(Layer.provideMerge(AlchemyContextLive, PlatformServices), Layer.provide(ProfileLive, PlatformServices), Layer.provide(CredentialsStoreLive, PlatformServices), FetchHttpClient.layer, ConfigProvider.layer(ConfigProvider.fromEnv()), selectCli());
 const exec = () => execStack(S.decodeSync(ExecStackOptions)(JSON.parse(process.env.ALCHEMY_EXEC_OPTIONS))).pipe(Effect.provide(services), Effect.scoped);
 
 //#endregion