alchemy 0.47.0 → 0.48.0

package/src/alchemy.ts

@@ -20,50 +20,6 @@ import type { LoggerApi } from "./util/cli.ts";
 import { logger } from "./util/logger.ts";
 import { TelemetryClient } from "./util/telemetry/client.ts";
 
-/**
- * Parses CLI arguments to extract alchemy options
- */
-function parseCliArgs(): Partial<AlchemyOptions> {
-  const args = process.argv.slice(2);
-  const options: Partial<AlchemyOptions> = {};
-
-  // Parse phase from CLI arguments
-  if (args.includes("--destroy")) {
-    options.phase = "destroy";
-  } else if (args.includes("--read")) {
-    options.phase = "read";
-  }
-
-  if (args.includes("--local") || args.includes("--dev")) {
-    options.dev = "prefer-local";
-  } else if (
-    args.includes("--remote") ||
-    args.includes("--watch") ||
-    process.execArgv.includes("--watch")
-  ) {
-    options.dev = "prefer-remote";
-  }
-
-  // Parse quiet flag
-  if (args.includes("--quiet")) {
-    options.quiet = true;
-  }
-
-  // Parse stage argument (--stage my-stage)
-  const stageIndex = args.indexOf("--stage");
-  if (stageIndex !== -1 && stageIndex + 1 < args.length) {
-    options.stage = args[stageIndex + 1];
-  }
-  options.stage ??= process.env.STAGE;
-
-  // Get password from environment variables
-  if (process.env.ALCHEMY_PASSWORD) {
-    options.password = process.env.ALCHEMY_PASSWORD;
-  }
-
-  return options;
-}
-
 /**
  * Type alias for semantic highlighting of `alchemy` as a type keyword
  */
@@ -175,8 +131,25 @@ async function _alchemy(
   if (typeof args[0] === "string") {
     const [appName, options] = args as [string, AlchemyOptions?];
 
-    // Parse CLI arguments and merge with provided options (explicit options take precedence)
-    const cliOptions = parseCliArgs();
+    const cliArgs = process.argv.slice(2);
+    const cliOptions = {
+      phase: cliArgs.includes("--destroy")
+        ? "destroy"
+        : cliArgs.includes("--read")
+          ? "read"
+          : "up",
+      local: cliArgs.includes("--local") || cliArgs.includes("--dev"),
+      watch: cliArgs.includes("--watch"),
+      quiet: cliArgs.includes("--quiet"),
+      // Parse stage argument (--stage my-stage) functionally and inline as a property declaration
+      stage: (function parseStage() {
+        const i = cliArgs.indexOf("--stage");
+        return i !== -1 && i + 1 < cliArgs.length
+          ? cliArgs[i + 1]
+          : process.env.STAGE;
+      })(),
+      password: process.env.ALCHEMY_PASSWORD,
+    } satisfies Partial<AlchemyOptions>;
     const mergedOptions = {
       ...cliOptions,
       ...options,
@@ -348,11 +321,17 @@ export interface AlchemyOptions {
    */
   phase?: Phase;
   /**
-   * Determines how Alchemy will run in development mode.
+   * Determines if resources should be simulated locally (where possible)
+   *
+   * @default - `true` if ran with `alchemy dev` or `bun ./alchemy.run.ts --dev`
+   */
+  local?: boolean;
+  /**
+   * Determines if local changes to resources should be reactively pushed to the local or remote environment.
    *
-   * @default - `"prefer-local"` if `--dev` or `--local` is passed as a CLI argument, `"prefer-remote"` if `--remote` or `--watch` is passed as a CLI argument, `undefined` otherwise
+   * @default - `true` if ran with `alchemy dev`, `alchemy watch`, `bun --watch ./alchemy.run.ts`
    */
-  dev?: "prefer-local" | "prefer-remote";
+  watch?: boolean;
   /**
    * Name to scope the resource state under (e.g. `.alchemy/{stage}/..`).
    *

package/src/cloudflare/astro.ts

@@ -85,5 +85,8 @@ export async function Astro<B extends Bindings>(
       run_worker_first: false,
     },
     wrangler,
+    dev: props.dev ?? {
+      command: "astro dev",
+    },
   });
 }

package/src/cloudflare/container.ts

@@ -191,7 +191,7 @@ export async function Container<T>(
     adopt: props.adopt,
   };
 
-  const isDev = Scope.current.dev && !props.dev?.remote;
+  const isDev = Scope.current.local && !props.dev?.remote;
   if (isDev) {
     const image = await Image(id, {
       name: `cloudflare-dev/${name}`, // prefix used by Miniflare

package/src/cloudflare/nuxt.ts

@@ -64,5 +64,8 @@ export async function Nuxt<B extends Bindings>(
     compatibilityFlags: ["nodejs_compat", ...(props?.compatibilityFlags ?? [])],
     // Enable wrangler by default, common for Nuxt/Cloudflare deployments
     wrangler: props?.wrangler ?? true,
+    dev: props?.dev ?? {
+      command: "nuxt dev",
+    },
   });
 }

package/src/cloudflare/pipeline.ts

@@ -368,11 +368,9 @@ const PipelineResource = Resource("cloudflare::Pipeline", async function <
   let pipelineData: CloudflarePipelineResponse;
 
   if (this.phase === "create") {
-    console.log(props);
     // Check if we should adopt an existing pipeline
     try {
       // Try to create pipeline first
-      console.log("Creating new Cloudflare Pipeline:", pipelineName);
       pipelineData = await createPipeline(api, pipelineName, props);
     } catch (error) {
       // If creation fails with 409 (conflict), adopt existing pipeline
@@ -383,7 +381,7 @@ const PipelineResource = Resource("cloudflare::Pipeline", async function <
             error.message.includes("Pipeline with this name already exists")))
       ) {
         if (props.adopt) {
-          console.log(
+          console.warn(
             "Pipeline already exists, adopting existing Cloudflare Pipeline:",
             pipelineName,
           );

package/src/cloudflare/react-router.ts

@@ -41,5 +41,8 @@ export async function ReactRouter<B extends Bindings>(
             dist: props.assets.dist ?? defaultAssets,
           }
         : (props.assets ?? defaultAssets),
+    dev: props.dev ?? {
+      command: "react-router dev",
+    },
   });
 }

package/src/cloudflare/vite.ts

@@ -38,7 +38,6 @@ export async function Vite<B extends Bindings>(
         : (props.assets ?? defaultAssets),
     dev: props.dev ?? {
       command: devCommand,
-      url: "http://localhost:5173",
     },
   });
 }

package/src/cloudflare/website.ts

@@ -2,6 +2,7 @@ import path from "node:path";
 import { alchemy } from "../alchemy.ts";
 import { Exec } from "../os/exec.ts";
 import { Scope } from "../scope.ts";
+import { detectPackageManager } from "../util/detect-package-manager.ts";
 import { Assets } from "./assets.ts";
 import type { Bindings } from "./bindings.ts";
 import {
@@ -100,7 +101,6 @@ export interface WebsiteProps<B extends Bindings>
    */
   dev?: {
     command: string;
-    url: string;
   };
 
   /**
@@ -123,6 +123,15 @@ export interface WebsiteProps<B extends Bindings>
   };
 }
 
+const packageManager = await detectPackageManager();
+const devCommand = {
+  npm: "npx vite dev",
+  bun: "bun vite dev",
+  pnpm: "pnpm vite dev",
+  yarn: "yarn vite dev",
+  deno: "deno task dev",
+}[packageManager];
+
 export type Website<B extends Bindings> = B extends { ASSETS: any }
   ? never
   : Worker<B & { ASSETS: Assets }>;
@@ -189,12 +198,9 @@ export default {
 };`,
         url: props.url ?? true,
         adopt: props.adopt ?? true,
-        dev: props.dev
-          ? {
-              command: props.dev.command,
-              url: props.dev.url,
-            }
-          : undefined,
+        dev: {
+          command: props.dev?.command ?? devCommand,
+        },
       } as WorkerProps<any> & { name: string };
 
       if (wrangler) {
@@ -216,7 +222,7 @@ export default {
         });
       }
 
-      const isDev = scope.dev && !!props.dev;
+      const isDev = scope.local;
 
       if (props.command && !isDev) {
         await Exec("build", {

package/src/cloudflare/worker.ts

@@ -1,13 +1,7 @@
 import type esbuild from "esbuild";
 import kleur from "kleur";
 import { spawn } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
+import fs from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import path from "pathe";
 import { BUILD_DATE } from "../build-date.ts";
@@ -18,7 +12,7 @@ import { getBindKey, tryGetBinding } from "../runtime/bind.ts";
 import { isRuntime } from "../runtime/global.ts";
 import { bootstrapPlugin } from "../runtime/plugin.ts";
 import { Scope } from "../scope.ts";
-import { Secret, secret } from "../secret.ts";
+import { Secret, isSecret, secret } from "../secret.ts";
 import { serializeScope } from "../serde.ts";
 import type { type } from "../type.ts";
 import { DeferredPromise } from "../util/deferred-promise.ts";
@@ -92,6 +86,7 @@ import { Workflow, isWorkflow, upsertWorkflow } from "./workflow.ts";
 // Previous versions of `Worker` used the `Bundle` resource.
 // This import is here to avoid errors when destroying the `Bundle` resource.
 import "../esbuild/bundle.ts";
+import { exists } from "../util/exists.ts";
 
 /**
  * Configuration options for static assets
@@ -353,7 +348,6 @@ export interface BaseWorkerProps<
    * the worker will be emulated locally and available at a randomly selected port.
    */
   dev?:
-    | boolean
     | {
         /**
          * Port to use for local development
@@ -365,11 +359,16 @@ export interface BaseWorkerProps<
          * @default false
          */
         remote?: boolean;
+        /** @internal */
+        command?: undefined;
       }
     | {
         command: string;
-        url: string;
         cwd?: string;
+        /** @internal */
+        port?: undefined;
+        /** @internal */
+        remote?: undefined;
       };
 
   /**
@@ -1047,8 +1046,6 @@ export const _Worker = Resource(
         ? props.namespace
         : props.namespace?.namespaceName;
 
-    const dev = normalizeDev(this, props.dev);
-
     const [bundle, error] = wrap(() =>
       normalizeWorkerBundle({
         entrypoint: props.entrypoint,
@@ -1067,34 +1064,45 @@ export const _Worker = Resource(
       }),
     );
 
-    if (dev.local) {
+    // run locally if
+    const local = this.scope.local && !props.dev?.remote;
+    const watch = this.scope.watch;
+
+    if (local) {
       let url: string | undefined;
       if (error) {
         throw error;
       }
 
-      switch (dev.type) {
-        case "command":
-          createDevCommand({
-            id,
-            command: dev.command,
-            cwd: dev.cwd ?? props.cwd ?? process.cwd(),
-            env: props.env ?? {},
-          });
-          url = dev.url;
-          break;
-        case "miniflare": {
-          url = await createMiniflare({
-            id,
-            workerName,
-            compatibilityDate,
-            compatibilityFlags,
-            bindings: props.bindings,
-            bundle,
-            port: dev.port,
-          });
-          break;
-        }
+      if (props.dev?.command) {
+        const { url: commandUrl } = await createDevCommand({
+          id,
+          command: props.dev.command,
+          cwd: props.dev.cwd || props.cwd || process.cwd(),
+          env: {
+            ...props.env,
+            ...Object.fromEntries(
+              Object.entries(props.bindings ?? {}).flatMap(([key, value]) =>
+                typeof value === "string"
+                  ? [[key, value]]
+                  : isSecret(value)
+                    ? [[key, value.unencrypted]]
+                    : [],
+              ),
+            ),
+          },
+        });
+        url = commandUrl;
+      } else {
+        url = await createMiniflare({
+          id,
+          workerName,
+          compatibilityDate,
+          compatibilityFlags,
+          bindings: props.bindings,
+          bundle,
+          port: props.dev?.port,
+        });
       }
 
       return this({
@@ -1218,7 +1226,7 @@ export const _Worker = Resource(
     }
 
     let putWorkerResult: PutWorkerResult;
-    if (dev.type === "remote") {
+    if (watch) {
       // todo(john): clean this up and add log tail
       const controller = new AbortController();
       cleanups.push(() => controller.abort());
@@ -1436,57 +1444,6 @@ process.on("SIGINT", async () => {
   process.exit(0);
 });
 
-type Dev =
-  | {
-      type: "none";
-      local: false;
-    }
-  | {
-      type: "miniflare";
-      port?: number;
-      local: true;
-    }
-  | {
-      type: "command";
-      command: string;
-      url: string;
-      cwd?: string;
-      local: true;
-    }
-  | {
-      type: "remote";
-      local: false;
-    };
-
-const normalizeDev = (ctx: Context<any>, dev: WorkerProps["dev"]): Dev => {
-  if (!ctx.scope.dev || ctx.phase === "delete" || dev === false) {
-    return {
-      type: "none",
-      local: false,
-    };
-  }
-  const devObj = dev === true ? {} : (dev ?? {});
-  if ("command" in devObj) {
-    // Commands are always local
-    return {
-      type: "command",
-      ...devObj,
-      local: true,
-    };
-  }
-  if (devObj.remote === false || ctx.scope.dev === "prefer-local") {
-    return {
-      type: "miniflare",
-      port: devObj.port,
-      local: true,
-    };
-  }
-  return {
-    type: "remote",
-    local: false,
-  };
-};
-
 const assertUnique = <T, Key extends keyof T>(
   inputs: T[],
   key: Key,
@@ -1858,15 +1815,15 @@ async function createMiniflare(props: {
   return await startPromise.value;
 }
 
-function createDevCommand(props: {
+async function createDevCommand(props: {
   id: string;
   command: string;
   cwd: string;
   env: Record<string, string>;
-}) {
+}): Promise<{ url: string }> {
   const persistFile = path.join(process.cwd(), ".alchemy", `${props.id}.pid`);
-  if (existsSync(persistFile)) {
-    const pid = Number.parseInt(readFileSync(persistFile, "utf8"));
+  if (await exists(persistFile)) {
+    const pid = Number.parseInt(await fs.readFile(persistFile, "utf8"));
     try {
       // Actually kill the process if it's alive
       process.kill(pid, "SIGTERM");
@@ -1874,12 +1831,20 @@ function createDevCommand(props: {
       // ignore
     }
     try {
-      unlinkSync(persistFile);
+      await fs.unlink(persistFile);
     } catch {
       // ignore
     }
   }
   const command = props.command.split(" ");
+  console.log({
+    command,
+    args: command.slice(1),
+    cwd: props.cwd,
+    env: {
+      ...props.env,
+    },
+  });
   const proc = spawn(command[0], command.slice(1), {
     cwd: props.cwd,
     env: {
@@ -1890,21 +1855,61 @@ function createDevCommand(props: {
         ".alchemy",
         "miniflare",
       ),
+      // Force colors in the child process since we're piping output
+      // FORCE_COLOR: "1",
     },
-    stdio: ["inherit", "inherit", "inherit"],
+    stdio: ["inherit", "pipe", "pipe"],
   });
-  cleanups.push(() => {
-    try {
-      unlinkSync(persistFile);
-    } catch {
-      // ignore
-    }
-    proc.kill();
+  const { url } = await new Promise<{ url: string }>((resolve, reject) => {
+    let urlFound = false;
+    let stdout = "";
+    let stderr = "";
+    const urlRegex =
+      /http:\/\/(?:(?:localhost|0\.0\.0\.0|127\.0\.0\.1)|(?:\d{1,3}\.){3}\d{1,3}):\d+(?:\/)?/;
+
+    const parseOutput = (data: string) => {
+      if (!urlFound) {
+        const match = data.match(urlRegex);
+        if (match) {
+          urlFound = true;
+          resolve({ url: match[0] });
+        }
+      }
+    };
+
+    // Handle stdout - parse for URL and write through with colors preserved
+    proc.stdout?.on("data", (data) => {
+      parseOutput(
+        (stdout += data.toString().replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")),
+      );
+      process.stdout.write(data);
+    });
+
+    proc.stderr?.on("data", (data) => {
+      parseOutput(
+        (stderr += data.toString().replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "")),
+      );
+      process.stderr.write(data);
+    });
+
+    proc.on("error", (error) => {
+      reject(error);
+    });
+
+    cleanups.push(async () => {
+      try {
+        await fs.unlink(persistFile);
+      } catch {
+        // ignore
+      }
+      proc.kill();
+    });
   });
   if (proc.pid) {
-    mkdirSync(path.dirname(persistFile), { recursive: true });
-    writeFileSync(persistFile, proc.pid.toString());
+    await fs.mkdir(path.dirname(persistFile), { recursive: true });
+    await fs.writeFile(persistFile, proc.pid.toString());
   }
+  return { url };
 }
 
 type PutWorkerOptions = Omit<WorkerProps, "entrypoint"> & {

package/src/scope.ts

@@ -38,7 +38,18 @@ export interface ScopeOptions {
   stateStore?: StateStoreType;
   quiet?: boolean;
   phase?: Phase;
-  dev?: "prefer-local" | "prefer-remote";
+  /**
+   * Determines if resources should be simulated locally (where possible)
+   *
+   * @default - `true` if ran with `alchemy dev` or `bun ./alchemy.run.ts --dev`
+   */
+  local?: boolean;
+  /**
+   * Determines if local changes to resources should be reactively pushed to the local or remote environment.
+   *
+   * @default - `true` if ran with `alchemy dev`, `alchemy watch`, `bun --watch ./alchemy.run.ts`
+   */
+  watch?: boolean;
   telemetryClient?: ITelemetryClient;
   logger?: LoggerApi;
 }
@@ -107,7 +118,8 @@ export class Scope {
   public readonly stateStore: StateStoreType;
   public readonly quiet: boolean;
   public readonly phase: Phase;
-  public readonly dev?: "prefer-local" | "prefer-remote";
+  public readonly local: boolean;
+  public readonly watch: boolean;
   public readonly logger: LoggerApi;
   public readonly telemetryClient: ITelemetryClient;
   public readonly dataMutex: AsyncMutex;
@@ -162,9 +174,10 @@ export class Scope {
           options.logger,
         );
 
-    this.dev = options.dev ?? this.parent?.dev;
+    this.local = options.local ?? this.parent?.local ?? false;
+    this.watch = options.watch ?? this.parent?.watch ?? false;
 
-    if (this.dev) {
+    if (this.local) {
       this.logger.warnOnce(
         "Development mode is in beta. Please report any issues to https://github.com/sam-goodwin/alchemy/issues.",
       );
@@ -415,6 +428,10 @@ export class Scope {
     await this.rootTelemetryClient?.finalize()?.catch((error) => {
       this.logger.warn("Telemetry finalization failed:", error);
     });
+
+    if (!this.parent && process.env.ALCHEMY_TEST_KILL_ON_FINALIZE) {
+      process.exit(0);
+    }
   }
 
   public async destroyPendingDeletions() {

package/src/util/safe-fetch.ts

@@ -20,6 +20,7 @@ export async function safeFetch(
         err?.code === "UND_ERR_SOCKET" ||
         err?.code === "ECONNRESET" ||
         err?.code === "UND_ERR_CONNECT_TIMEOUT" ||
+        err?.code === "EPIPE" ||
         err?.name === "FetchError";
 
       if (!shouldRetry || attempt === retries) {

package/templates/react-router/package.json

@@ -3,7 +3,7 @@
   "name": "@alchemy.run/react-router-template",
   "private": true,
   "scripts": {
-    "build": "vite build",
+    "build": "react-router build",
     "deploy": "alchemy deploy",
     "destroy": "alchemy destroy",
     "dev": "alchemy dev",

package/templates/react-router/tsconfig.cloudflare.json

@@ -11,7 +11,11 @@
     "composite": true,
     "strict": true,
     "lib": ["DOM", "DOM.Iterable", "ES2022"],
-    "types": ["vite/client"],
+    "types": [
+      "vite/client",
+      "@cloudflare/workers-types",
+      "./types/env.d.ts"
+    ],
     "target": "ES2022",
     "module": "ES2022",
     "moduleResolution": "bundler",

package/templates/react-router/tsconfig.json

@@ -10,8 +10,5 @@
     "skipLibCheck": true,
     "strict": true,
     "noEmit": true,
-    "types": [
-        "./worker-configuration.d.ts"
-    ]
   }
 }

package/templates/react-router/tsconfig.node.json

@@ -8,10 +8,6 @@
   "compilerOptions": {
     "composite": true,
     "strict": true,
-    "types": [
-      "@cloudflare/workers-types",
-      "./types/env.d.ts"
-    ],
     "lib": ["ES2022"],
     "target": "ES2022",
     "module": "ES2022",