alchemy 0.61.0 → 0.62.0

package/src/util/idempotent-spawn.ts

@@ -1,8 +1,25 @@
-import find from "find-process";
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import fsp from "node:fs/promises";
 import path from "node:path";
+import { AsyncMutex } from "./mutex.ts";
+
+export interface IdempotentSpawnOptions {
+  cmd: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  log: string;
+  stateFile?: string;
+  overlapBytes?: number;
+  resume?: boolean;
+  isSameProcess?: (pid: number) => Promise<boolean>;
+  processName?: string;
+  extract?: (line: string) => string | undefined;
+  /**
+   * If true, the child's stdout and stderr will not be mirrored to this process's console.
+   */
+  quiet?: boolean;
+}
 
 /**
  * Idempotently ensure a long-lived child is running with stdout/stderr -> files,
@@ -13,6 +30,7 @@ import path from "node:path";
 export async function idempotentSpawn({
   cmd,
   cwd,
+  env,
   stateFile = "state.json",
   overlapBytes = 0,
   resume = false,
@@ -21,25 +39,9 @@ export async function idempotentSpawn({
   extract,
   isSameProcess,
   quiet = false,
-}: {
-  cmd: string;
-  cwd?: string;
-  log: string;
-  stateFile?: string;
-  overlapBytes?: number;
-  resume?: boolean;
-  isSameProcess?: (pid: number) => Promise<boolean>;
-  processName?: string;
-  extract?: (line: string) => string | undefined;
-  /**
-   * If true, the child's stdout and stderr will not be mirrored to this process's console.
-   */
-  quiet?: boolean;
-}): Promise<string | undefined> {
+}: IdempotentSpawnOptions): Promise<string | undefined> {
   if (!processName && !isSameProcess) {
-    throw new Error(
-      "Either processName or isSameProcess must be provided to resume a process",
-    );
+    processName = cmd.split(" ")[0];
   }
 
   const outPath = log;
@@ -52,13 +54,22 @@ export async function idempotentSpawn({
     Promise.withResolvers<string | undefined>();
 
   if (!extract) {
-    console.warn(
-      "No extract function provided, will not return a value. This is probably a bug.",
-    );
     resolveExtracted(undefined);
   }
 
-  // ------------------------ helpers ------------------------
+  await ensureChildRunning();
+
+  const write = quiet
+    ? () => false
+    : (buf: Buffer) => process.stdout.write(buf);
+
+  // Start followers (stdout/stderr) and mirror to this process
+  await followFilePersisted(outPath, {
+    stateKey: `${path.resolve(outPath)}::stdout`,
+    write,
+  });
+
+  return extracted;
 
   function isPidAlive(pid: number) {
     if (!pid || Number.isNaN(pid)) return false;
@@ -96,7 +107,7 @@ export async function idempotentSpawn({
       shell: true,
       cwd,
       stdio: ["ignore", out.fd, out.fd], // stdout/stderr -> files (OS-level)
-      env: process.env,
+      env,
       detached: false,
     });
 
@@ -117,6 +128,7 @@ export async function idempotentSpawn({
       if (isPidAlive(pid)) return pid;
       if (await isSameProcess?.(pid)) return pid;
       if (processName) {
+        const { default: find } = await import("find-process");
         const processes = await find("pid", pid);
         if (processes.length > 1) {
           console.warn(
@@ -124,7 +136,9 @@ export async function idempotentSpawn({
           );
         }
         if (processes.length > 0) {
-          return processes[0].name.startsWith(processName);
+          if (processes[0].name.startsWith(processName)) {
+            return pid;
+          }
         }
       }
     }
@@ -140,9 +154,9 @@ export async function idempotentSpawn({
   async function followFilePersisted(
     logPath: string,
     {
-      write = (buf: Buffer) => process.stdout.write(buf),
+      write,
       chunkSize = 64 * 1024,
-      tickMs = 100,
+      // tickMs = 100,
     }: {
       stateKey: string;
       write: (buf: Buffer) => boolean;
@@ -168,64 +182,23 @@ export async function idempotentSpawn({
         : st.size;
 
     let closed = false;
-
-    async function persist() {
-      try {
-        const cur = await fh.stat();
-        state = {
-          ...state,
-          offset,
-          ino: Number(cur.ino ?? ino),
-          dev: Number(cur.dev ?? dev),
-          size: cur.size,
-          mtimeMs: cur.mtimeMs,
-        };
-        await writeJsonAtomic(stateFile, state);
-      } catch {
-        // If the file vanished mid-rotation, we'll catch up on the next event.
-      }
-    }
-
-    async function drain() {
-      while (true) {
-        const cur = await fh.stat().catch(() => null);
-        if (!cur) break;
-
-        if (cur.size < offset) offset = 0; // truncated
-
-        if (offset > 0 && extract) {
-          // read from start to offset
-          const fullBuffer = Buffer.allocUnsafe(offset);
-          await fh.read({
-            position: 0,
-            buffer: fullBuffer,
-            length: offset,
-          });
-          const content = fullBuffer.toString("utf8");
-          const lines = content.split("\n");
-          for (const line of lines) {
-            const extracted = extract(line);
-            if (extracted) {
-              resolveExtracted(extracted);
-              break;
-            }
-          }
-        }
-
-        const toRead = Math.min(chunkSize, cur.size - offset);
-        if (toRead <= 0) break;
-
-        const { bytesRead, buffer } = await fh.read({
-          position: offset,
-          buffer: Buffer.allocUnsafe(toRead),
-          length: toRead,
-        });
-        if (!bytesRead) break;
-
-        offset += bytesRead;
-        write(buffer.subarray(0, bytesRead));
-      }
-      await persist();
+    const drainMutex = new AsyncMutex();
+
+    // we read the log file and stream in chunks, not lines
+    // so we need to keep track of the remainder of the last line
+    let remainder: string | undefined;
+
+    // if we are resuming, then re-parse the log lines to extract the value
+    if (offset > 0) {
+      // read from start to offset
+      const fullBuffer = Buffer.allocUnsafe(offset);
+      await fh.read({
+        position: 0,
+        buffer: fullBuffer,
+        length: offset,
+      });
+      const content = fullBuffer.toString("utf8");
+      parse(content);
     }
 
     await drain();
@@ -263,24 +236,68 @@ export async function idempotentSpawn({
       await fh.close().catch(() => {});
       await persist();
     };
-  }
 
-  // ------------------------ main flow ------------------------
+    async function persist() {
+      try {
+        const cur = await fh.stat();
+        state = {
+          ...state,
+          offset,
+          ino: Number(cur.ino ?? ino),
+          dev: Number(cur.dev ?? dev),
+          size: cur.size,
+          mtimeMs: cur.mtimeMs,
+        };
+        await writeJsonAtomic(stateFile, state);
+      } catch {
+        // If the file vanished mid-rotation, we'll catch up on the next event.
+      }
+    }
 
-  await ensureChildRunning();
+    function parse(content: string) {
+      const lines = content.split("\n");
+      if (extract) {
+        if (lines.length > 0) {
+          remainder = lines[lines.length - 1];
+        }
+        // parse all lines except the last one (which may be a partial line)
+        for (const line of lines.slice(0, -1)) {
+          const extracted = extract(line);
+          if (extracted) {
+            resolveExtracted(extracted);
+            break;
+          }
+        }
+      }
+    }
 
-  if (!quiet) {
-    const write = quiet
-      ? () => false
-      : (buf: Buffer) => process.stdout.write(buf);
+    function drain() {
+      return drainMutex.lock(async () => {
+        while (true) {
+          const cur = await fh.stat().catch(() => null);
+          if (!cur) break;
 
-    // Start followers (stdout/stderr) and mirror to this process
-    await followFilePersisted(outPath, {
-      stateKey: `${path.resolve(outPath)}::stdout`,
-      write,
-    });
-  }
+          if (cur.size < offset) offset = 0; // truncated
+          const toRead = Math.min(chunkSize, cur.size - offset);
+          if (toRead <= 0) break;
 
-  // Return a stopper for this instance's mirroring (child keeps running)
-  return extracted;
+          const { bytesRead, buffer } = await fh.read({
+            position: offset,
+            buffer: Buffer.allocUnsafe(toRead),
+            length: toRead,
+          });
+          if (!bytesRead) break;
+
+          const chunk = buffer.subarray(0, bytesRead);
+
+          // write the newly read content to the stream
+          write(chunk);
+          // parse the previous remainder and the new chunk
+          parse(`${remainder || ""}${chunk.toString("utf8")}`);
+          offset += bytesRead;
+        }
+        await persist();
+      });
+    }
+  }
 }

package/src/util/index.ts

@@ -0,0 +1 @@
+export * from "./safe-fetch.ts";

package/src/util/safe-fetch.ts

@@ -69,3 +69,117 @@ async function dispatcher() {
   }
   return agent.value;
 }
+
+/**
+ * Fetch with exponential backoff retry logic for 404 responses, expecting 200 OK.
+ * This is a convenience wrapper around fetchAndExpectStatus with expectedStatus=200.
+ *
+ * @param input URL or Request object
+ * @param init RequestInit options
+ * @param maxAttempts Maximum number of retry attempts (default: 10)
+ * @param maxWaitTime Maximum total wait time in milliseconds (default: 30000)
+ * @returns The successful Response
+ */
+export async function fetchAndExpectOK(
+  input: string | URL | Request,
+  init?: RequestInit,
+  maxAttempts = 10,
+  maxWaitTime = 30000,
+): Promise<Response> {
+  return fetchAndExpectStatus(input, init, 200, maxAttempts, maxWaitTime);
+}
+
+/**
+ * Fetch and expect a specific status code with retry logic.
+ * Cloudflare's control plane is eventually consistent, so resources may
+ * return 404 immediately after creation before becoming available.
+ *
+ * @param input URL or Request object
+ * @param init RequestInit options
+ * @param expectedStatus Expected HTTP status code (default: 200)
+ * @param maxAttempts Maximum number of retry attempts (default: 10)
+ * @param maxWaitTime Maximum total wait time in milliseconds (default: 30000)
+ * @returns The successful Response
+ */
+export async function fetchAndExpectStatus(
+  input: string | URL | Request,
+  init?: RequestInit,
+  expectedStatus = 200,
+  maxAttempts = 20,
+  maxWaitTime = 30000,
+): Promise<Response> {
+  let attempt = 0;
+  let lastError: Error | undefined;
+
+  while (attempt < maxAttempts) {
+    try {
+      const response = await safeFetch(input, init);
+
+      // If we get the expected status, return it
+      if (response.status === expectedStatus) {
+        return response;
+      }
+
+      // If we get a 500, 404 when expecting something else, retry with backoff
+      if (
+        response.status >= 500 ||
+        (response.status === 404 && expectedStatus !== 404)
+      ) {
+        attempt++;
+
+        if (attempt >= maxAttempts) {
+          throw new Error(
+            `Expected status ${expectedStatus} but got 404 after ${maxAttempts} attempts. This may indicate eventual consistency issues.`,
+          );
+        }
+
+        const backoffTime = Math.min(attempt * 1500, maxWaitTime / maxAttempts);
+
+        console.log(
+          `Expected status ${expectedStatus} but got 404, retrying in ${backoffTime}ms (attempt ${attempt}/${maxAttempts})...`,
+        );
+
+        await new Promise((resolve) => setTimeout(resolve, backoffTime));
+        continue;
+      }
+
+      // For other status codes, throw immediately
+      throw new Error(
+        `Expected status ${expectedStatus} but got ${response.status}: ${response.statusText}`,
+      );
+    } catch (error) {
+      if (error instanceof Error) {
+        lastError = error;
+
+        // If it's not an HTTP error, retry with backoff
+        if (
+          !error.message.startsWith("Expected status") &&
+          !error.message.startsWith("HTTP ")
+        ) {
+          attempt++;
+
+          if (attempt >= maxAttempts) {
+            break;
+          }
+
+          const backoffTime = Math.min(
+            attempt * 1500,
+            maxWaitTime / maxAttempts,
+          );
+
+          console.log(
+            `Network error, retrying in ${backoffTime}ms (attempt ${attempt}/${maxAttempts}): ${error.message}`,
+          );
+
+          await new Promise((resolve) => setTimeout(resolve, backoffTime));
+          continue;
+        }
+      }
+
+      // For status code mismatches, throw immediately
+      throw error;
+    }
+  }
+
+  throw lastError || new Error(`Failed after ${maxAttempts} attempts`);
+}