alchemy 2.0.0-cli-shim.1 → 2.0.0-cli-bundle-fix.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alchemy",
-  "version": "2.0.0-cli-shim.1",
+  "version": "2.0.0-cli-bundle-fix.1",
   "homepage": "https://alchemy.run",
   "license": "Apache-2.0",
   "author": "Sam Goodwin <sam@alchemy.run>",
@@ -255,7 +255,6 @@
     "jszip": "^3.10.1",
     "libsodium-wrappers": "^0.8.3",
     "rolldown": "1.0.0-rc.13",
-    "solid-js": "latest",
     "sonda": "^0.11.1",
     "web-tree-sitter": "0.25.10",
     "workerd": "1.20260417.1",
@@ -277,6 +276,7 @@
     "pathe": "^2.0.3",
     "react": "^19.2.0",
     "react-devtools-core": "^7.0.1",
+    "solid-js": "latest",
     "tsconfig-paths": "^4.2.0",
     "tsdown": "^0.15.4",
     "tsx": "^4.20.6",

package/src/Cli/InkCLI.tsx

@@ -19,16 +19,6 @@ export const inkCLI = () =>
     }),
   );
 
-export const inkCLIAutoApprove = () =>
-  Layer.succeed(
-    Cli,
-    Cli.of({
-      approvePlan: () => Effect.succeed(true),
-      displayPlan,
-      startApplySession,
-    }),
-  );
-
 const approvePlan = Effect.fn(function* <P extends Plan>(plan: P) {
   let approved = false;
   const { waitUntilExit } = render(

package/src/Cli/index.ts

@@ -1,2 +1,5 @@
 export * from "./Cli.ts";
-export * from "./InkCLI.tsx";
+// Note: do NOT re-export InkCLI here. The Ink-based renderer pulls in
+// `react`/`ink`, which we do not want consumers of `alchemy/Cli` to
+// transitively depend on. Import `alchemy/Cli/InkCLI` directly when needed
+// (currently only from `bin/alchemy.ts`, which is bundled).

package/src/Stack.ts

@@ -13,7 +13,7 @@ import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSp
 import { AlchemyContext, AlchemyContextLive } from "./AlchemyContext.ts";
 import { provideFreshArtifactStore } from "./Artifacts.ts";
 import { AuthProviders } from "./Auth/AuthProvider.ts";
-import { inkCLIAutoApprove } from "./Cli/InkCLI.tsx";
+import { Cli } from "./Cli/Cli.ts";
 import type { Input, InputProps } from "./Input.ts";
 import * as Output from "./Output.ts";
 import { ref } from "./Ref.ts";
@@ -34,7 +34,8 @@ export type StackServices =
   | AlchemyContext
   | HttpClient
   | ChildProcessSpawner
-  | AuthProviders;
+  | AuthProviders
+  | Cli;
 
 export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
   A,
@@ -44,6 +45,7 @@ export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
   | Scope
   | AuthProviders
   | AlchemyContext
+  | Cli
   | State
   | Req
 >;
@@ -172,8 +174,33 @@ export const make =
     effect: Effect.Effect<A, Err, Req>,
   ) =>
     Effect.scope.pipe(
-      Effect.flatMap((scope) =>
-        options.providers.pipe(
+      Effect.flatMap((scope) => {
+        if (options.state == null) {
+          return Effect.die(
+            new Error(
+              `Stack "${options.name}" is missing a state store. ` +
+                `Add a \`state\` layer to the stack options, e.g.:\n` +
+                `  Alchemy.Stack("${options.name}", {\n` +
+                `    providers: Cloudflare.providers(),\n` +
+                `    state: Cloudflare.state(), // <-- required\n` +
+                `  }, ...)\n` +
+                `See https://alchemy.run/concepts/state-store for available state stores.`,
+            ),
+          );
+        }
+        if (options.providers == null) {
+          return Effect.die(
+            new Error(
+              `Stack "${options.name}" is missing a providers layer. ` +
+                `Add a \`providers\` layer to the stack options, e.g.:\n` +
+                `  Alchemy.Stack("${options.name}", {\n` +
+                `    providers: Cloudflare.providers(), // <-- required\n` +
+                `    state: Cloudflare.state(),\n` +
+                `  }, ...)`,
+            ),
+          );
+        }
+        return options.providers.pipe(
           Layer.provideMerge(options.state),
           Layer.provideMerge(
             Layer.effect(
@@ -192,8 +219,8 @@ export const make =
             ),
           ),
           Layer.buildWithScope(scope),
-        ),
-      ),
+        );
+      }),
       Effect.flatMap((context) =>
         Effect.all([
           effect,
@@ -257,7 +284,6 @@ export const evalStack = <A, B, Err, Req>(
       ),
     ),
     Effect.provide(Layer.succeed(Stage, options.stage)),
-    Effect.provide(inkCLIAutoApprove()),
     Effect.provide(Layer.provideMerge(alchemy, platform)),
     Effect.scoped,
   );

package/src/State/HttpStateStore.ts

@@ -104,16 +104,39 @@ export const makeHttpStateStore = ({ url, authToken }: HttpStateStoreProps) =>
     return service;
   });
 
+/**
+ * Predicate over an `HttpClientError`-shaped failure that returns `true`
+ * for failures we expect to clear up on their own.
+ *
+ * We retry:
+ * - all transport-level errors (no `response` — DNS, TCP reset, TLS,
+ *   abort, etc.)
+ * - 408 (request timeout) and 429 (rate limit)
+ * - 404, which is normal in the seconds after a worker is first
+ *   deployed and the route hasn't propagated yet
+ * - every 5xx
+ *
+ * Anything else (400/401/403/etc.) is a real client-side problem and
+ * shouldn't be hidden behind retries.
+ */
+const isTransient = (e: any): boolean => {
+  if (e?._tag !== "HttpClientError") return false;
+  const status: number | undefined = e.response?.status;
+  if (status == null) return true;
+  if (status === 404 || status === 408 || status === 429) return true;
+  return status >= 500 && status < 600;
+};
+
 const retryTransient = <A, Err, Req>(eff: Effect.Effect<A, Err, Req>) =>
   Effect.retry(eff, {
-    while: (e: any) =>
-      e._tag === "HttpClientError" &&
-      (e.response?.status === 500 ||
-        e.response?.status === 502 ||
-        // not founds are usually after the worker has just been created
-        e.response?.status === 404),
+    while: isTransient,
+    // Exponential backoff capped at 2s, no attempt limit. The state
+    // store is on the deploy critical path; we'd rather block than
+    // surface a transient blip as a hard failure (which historically
+    // stranded `syncState` mid-flight, leaving the remote store
+    // partially populated).
     schedule: Schedule.exponential(100).pipe(
-      Schedule.both(Schedule.recurs(10)),
+      Schedule.either(Schedule.spaced("2 seconds")),
     ),
   });
 

package/src/State/Sync.ts

@@ -17,6 +17,7 @@ export const syncState = Effect.fnUntraced(function* (
   source: StateService,
   destination: StateService,
   options?: {
+    stacks?: string[];
     /**
      * Maximum number of resources to copy in parallel within a single stage.
      * @default "unbounded".
@@ -29,7 +30,9 @@ export const syncState = Effect.fnUntraced(function* (
     source.listStacks(),
     destination.listStacks(),
   ]);
-  const sourceStackSet = new Set(sourceStacks);
+  const sourceStackSet = new Set(
+    sourceStacks.filter((stack) => options?.stacks?.includes(stack) ?? true),
+  );
 
   yield* Effect.forEach(
     sourceStacks,

package/src/Test/Bun.ts

@@ -9,6 +9,7 @@ import type { HookOptions } from "node:test";
 import { AlchemyContext, AlchemyContextLive } from "../AlchemyContext.ts";
 import { provideFreshArtifactStore } from "../Artifacts.ts";
 import { AuthProviders } from "../Auth/AuthProvider.ts";
+import { inkCLI } from "../Cli/InkCLI.tsx";
 import { deploy as _deploy } from "../Deploy.ts";
 import { destroy as _destroy } from "../Destroy.ts";
 import {
@@ -28,8 +29,7 @@ const platform = Layer.mergeAll(PlatformServices, FetchHttpClient.layer);
 
 // override alchemy state store, CLI/reporting, state, and dotAlchemy
 const alchemy = Layer.mergeAll(
-  // CLI.inkCLI(),
-  // optional
+  inkCLI(),
   Logger.layer([Logger.consolePretty()]),
   AlchemyContextLive,
 );