alchemy 0.12.9 → 0.12.11

package/src/cloudflare/wrangler.json.ts

@@ -23,6 +23,13 @@ export interface WranglerJsonProps {
    * @default cwd/wrangler.json
    */
   path?: string;
+
+  /**
+   * The main entry point for the worker
+   *
+   * @default worker.entrypoint
+   */
+  main?: string;
 }
 
 /**
@@ -75,7 +82,7 @@ export const WranglerJson = Resource(
     const spec: WranglerJsonSpec = {
       name: worker.name,
       // Use entrypoint as main if it exists
-      main: worker.entrypoint,
+      main: props.main ?? worker.entrypoint,
       // see: https://developers.cloudflare.com/workers/configuration/compatibility-dates/
       compatibility_date: worker.compatibilityDate,
       compatibility_flags: props.worker.compatibilityFlags,

package/src/esbuild/bundle.ts

@@ -8,7 +8,7 @@ import { Resource } from "../resource.js";
 /**
  * Properties for creating or updating an esbuild bundle
  */
-export interface BundleProps {
+export interface BundleProps extends Partial<esbuild.BuildOptions> {
   /**
    * Entry point for the bundle
    * Path to the source file to bundle (e.g., "src/handler.ts")
@@ -143,7 +143,7 @@ export const Bundle = Resource(
 
     const result = await bundle(props);
 
-    const bundlePath = Object.entries(result.metafile.outputs).find(
+    const bundlePath = Object.entries(result.metafile!.outputs).find(
       ([_, output]) => {
         if (output.entryPoint === undefined) {
           return false;
@@ -186,7 +186,9 @@ export const Bundle = Resource(
 );
 
 export async function bundle(props: BundleProps) {
-  return await esbuild.build({
+  const { entryPoint, options: _, ...rest } = props;
+  const options = {
+    ...rest,
     ...props.options,
     write: !(props.outdir === undefined && props.outfile === undefined),
     // write:
@@ -200,12 +202,12 @@ export async function bundle(props: BundleProps) {
     target: props.target,
     minify: props.minify,
     sourcemap: props.sourcemap,
-    external: [
-      "node:*",
-      ...(props.external ?? []),
-      ...(props.options?.external ?? []),
-    ],
+    external: [...(props.external ?? []), ...(props.options?.external ?? [])],
     platform: props.platform,
     metafile: true,
-  });
+  };
+  if (process.env.DEBUG) {
+    console.log(options);
+  }
+  return await esbuild.build(options);
 }

package/src/os/exec.ts

@@ -1,10 +1,7 @@
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
+import { spawn } from "node:child_process";
 import type { Context } from "../context.js";
 import { Resource } from "../resource.js";
 
-const execAsync = promisify(exec);
-
 /**
  * Properties for executing a shell command
  */
@@ -32,15 +29,15 @@ export interface ExecProps {
   env?: Record<string, string>;
 
   /**
-   * Maximum buffer size for stdout and stderr (in bytes)
-   * @default 1024 * 1024 (1MB)
+   * Whether to throw an error if the command exits with a non-zero status
    */
-  maxBuffer?: number;
+  throwOnError?: boolean;
 
   /**
-   * Whether to throw an error if the command exits with a non-zero status
+   * Whether to inherit stdio from parent process
+   * @default true
    */
-  throwOnError?: boolean;
+  inheritStdio?: boolean;
 }
 
 /**
@@ -58,12 +55,12 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
   exitCode: number;
 
   /**
-   * Standard output from the command
+   * Standard output from the command (only available when inheritStdio is false)
    */
   stdout: string;
 
   /**
-   * Standard error from the command
+   * Standard error from the command (only available when inheritStdio is false)
    */
   stderr: string;
 
@@ -82,11 +79,18 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
  * Execute a shell command
  *
  * @example
- * // Run a simple command
+ * // Run a simple command with inherited stdio (default)
  * const result = await Exec("list-files", {
  *   command: "ls -la"
  * });
  *
+ * @example
+ * // Run a command and capture output instead of inheriting stdio
+ * const result = await Exec("list-files", {
+ *   command: "ls -la",
+ *   inheritStdio: false
+ * });
+ *
  * console.log(result.stdout);
  *
  * @example
@@ -98,13 +102,6 @@ export interface Exec extends Resource<"os::Exec">, ExecProps {
  * });
  *
  * @example
- * // Run a command with a larger buffer for output
- * const logs = await Exec("get-logs", {
- *   command: "cat large-log-file.log",
- *   maxBuffer: 10 * 1024 * 1024 // 10MB
- * });
- *
- * @example
  * // Run a memoized command that only re-executes when the command changes
  * const memoizedCmd = await Exec("status-check", {
  *   command: "git status",
@@ -143,31 +140,61 @@ export const Exec = Resource(
       let stderr = "";
       let exitCode = 0;
 
+      // Default to inheriting stdio unless explicitly set to false
+      const inheritStdio = props.inheritStdio !== false;
+
       try {
-        console.log(props.command);
-        // Execute the command
-        const result = await execAsync(props.command, {
+        // Parse the command into command and args
+        const [cmd, ...args] = props.command.split(/\s+/);
+
+        // Use spawn for better stdio control
+        const childProcess = spawn(cmd, args, {
           cwd: props.cwd || process.cwd(),
           env: { ...process.env, ...props.env },
-          maxBuffer: props.maxBuffer || 1024 * 1024, // Default 1MB
+          shell: true, // Use shell to handle complex commands
+          stdio: inheritStdio ? "inherit" : "pipe", // Inherit stdio when requested
+        });
+
+        if (!inheritStdio) {
+          // If not inheriting stdio, collect output manually
+          childProcess.stdout?.on("data", (data) => {
+            stdout += data.toString();
+          });
+
+          childProcess.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+        }
+
+        // Wait for the process to complete
+        exitCode = await new Promise<number>((resolve, reject) => {
+          childProcess.on("close", (code) => {
+            resolve(code || 0);
+          });
+
+          childProcess.on("error", (err) => {
+            if (props.throwOnError) {
+              reject(err);
+            } else {
+              stderr += err.toString();
+              resolve(1);
+            }
+          });
         });
 
-        stdout = result.stdout;
-        console.log(stdout);
-        stderr = result.stderr;
-        exitCode = 0; // Success
+        if (exitCode !== 0 && props.throwOnError) {
+          throw new Error(
+            `Command failed with exit code ${exitCode}: ${props.command}`
+          );
+        }
       } catch (error: any) {
-        console.log("error", error);
         if (props.throwOnError) {
           throw error;
         }
 
         // If not throwing, capture the error information
-        exitCode = error.code || 1;
-        stdout = error.stdout || "";
-        stderr = error.stderr || String(error);
-        console.log(stdout);
-        console.error(stderr);
+        exitCode = 1;
+        stderr += String(error);
       }
 
       // Return the execution result
@@ -176,9 +203,9 @@ export const Exec = Resource(
         command: props.command,
         cwd: props.cwd,
         env: props.env,
-        maxBuffer: props.maxBuffer,
         throwOnError: props.throwOnError,
         memoize: props.memoize,
+        inheritStdio,
         exitCode,
         stdout,
         stderr,