@livestore/utils-dev 0.0.0-snapshot-92c31f56117b4fd377b66f55163ed565795c5e4c → 0.0.0-snapshot-6d1da0d93ffe8144f36fc2ec57c22db22a1d18d8

package/src/node/WranglerDevServer/WranglerDevServer.ts

@@ -1,6 +1,18 @@
+import { error } from 'node:console'
 import * as path from 'node:path'
-
-import { Command, Effect, Exit, type PlatformError, Schema, Stream } from '@livestore/utils/effect'
+import { IS_CI, shouldNeverHappen } from '@livestore/utils'
+import {
+  Command,
+  Duration,
+  Effect,
+  Exit,
+  HttpClient,
+  Option,
+  type PlatformError,
+  Schedule,
+  Schema,
+  Stream,
+} from '@livestore/utils/effect'
 import { getFreePort } from '@livestore/utils/node'
 import { cleanupOrphanedProcesses, killProcessTree } from './process-tree-manager.ts'
 
@@ -28,9 +40,12 @@ export interface WranglerDevServer {
 export interface StartWranglerDevServerArgs {
   wranglerConfigPath?: string
   cwd: string
-  port?: number
+  /** The port to try first. The dev server may bind a different port if unavailable. */
+  preferredPort?: number
   /** @default false */
   showLogs?: boolean
+  inspectorPort?: number
+  connectTimeout?: Duration.DurationInput
 }
 
 /**
@@ -57,27 +72,31 @@ export class WranglerDevServerService extends Effect.Service<WranglerDevServerSe
         Effect.ignore, // Don't fail startup if cleanup fails
       )
 
-      // Allocate port
-      const port =
-        args.port ??
+      // Allocate preferred port (Wrangler may bind a different one if unavailable)
+      const preferredPort =
+        args.preferredPort ??
         (yield* getFreePort.pipe(
           Effect.mapError(
             (cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 }),
           ),
         ))
 
-      yield* Effect.annotateCurrentSpan({ port })
+      yield* Effect.annotateCurrentSpan({ preferredPort })
 
       // Resolve config path
       const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
 
+      const inspectorPort = args.inspectorPort ?? (yield* getFreePort)
+
       // Start wrangler process using Effect Command
       const process = yield* Command.make(
         'bunx',
         'wrangler',
         'dev',
         '--port',
-        port.toString(),
+        preferredPort.toString(),
+        '--inspector-port',
+        inspectorPort.toString(),
         '--config',
         configPath,
       ).pipe(
@@ -90,7 +109,7 @@ export class WranglerDevServerService extends Effect.Service<WranglerDevServerSe
             new WranglerDevServerError({
               cause: error,
               message: `Failed to start wrangler process in directory: ${args.cwd}`,
-              port,
+              port: preferredPort,
             }),
         ),
         Effect.withSpan('WranglerDevServerService:startProcess'),
@@ -154,26 +173,38 @@ export class WranglerDevServerService extends Effect.Service<WranglerDevServerSe
             yield* Effect.logDebug(`Process ${processId} already terminated`)
           }
         }).pipe(
+          Effect.withSpan('WranglerDevServerService:cleanupProcess'),
           Effect.timeout('5 seconds'), // Don't let cleanup hang forever
           Effect.ignoreLogged,
         ),
       )
 
-      // Wait for server to be ready
-      yield* waitForReady({ stdout, showLogs })
+      // Wait for server to be ready and parse the actual bound host:port from stdout
+      const readyInfo = yield* waitForReady({ stdout, showLogs })
+
+      const actualPort = readyInfo.port
+      const actualHost = readyInfo.host
+      const url = `http://${actualHost}:${actualPort}`
+
+      // Use longer timeout in CI environments to account for slower startup times
+      const defaultTimeout = Duration.seconds(IS_CI ? 30 : 5)
+
+      yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: args.connectTimeout ?? defaultTimeout })
 
       if (showLogs) {
-        yield* Effect.logDebug(`Wrangler dev server ready on port ${port}`)
+        yield* Effect.logDebug(
+          `Wrangler dev server ready and accepting connections on port ${actualPort} (preferred: ${preferredPort})`,
+        )
       }
 
       return {
-        port,
-        url: `http://localhost:${port}`,
+        port: actualPort,
+        url,
         processId,
       } satisfies WranglerDevServer
     }).pipe(
       Effect.withSpan('WranglerDevServerService', {
-        attributes: { port: args.port ?? 'auto', cwd: args.cwd },
+        attributes: { preferredPort: args.preferredPort ?? 'auto', cwd: args.cwd },
       }),
     ),
 }) {}
@@ -187,20 +218,85 @@ const waitForReady = ({
 }: {
   stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError, never>
   showLogs: boolean
-}): Effect.Effect<void, WranglerDevServerError, never> =>
+}): Effect.Effect<{ host: string; port: number }, WranglerDevServerError, never> =>
   stdout.pipe(
     Stream.decodeText('utf8'),
     Stream.splitLines,
     Stream.tap((line) => (showLogs ? Effect.logDebug(`[wrangler] ${line}`) : Effect.void)),
-    Stream.takeUntil((line) => line.includes('Ready on')),
-    Stream.runDrain,
-    Effect.timeout('30 seconds'),
-    Effect.mapError(
-      (error) =>
+    // Find the first readiness line and try to parse the port from it
+    Stream.filterMap<string, { host: string; port: number }>((line) => {
+      if (line.includes('Ready on')) {
+        // Expect: "Ready on http://<host>:<port>"
+        const m = line.match(/https?:\/\/([^:\s]+):(\d+)/i)
+        if (!m) return shouldNeverHappen('Could not parse host:port from Wrangler "Ready on" line', line)
+        const host = m[1]! as string
+        const port = Number.parseInt(m[2]!, 10)
+        if (!Number.isFinite(port)) return shouldNeverHappen('Parsed non-finite port from Wrangler output', line)
+        return Option.some({ host, port } as const)
+      } else {
+        return Option.none()
+      }
+    }),
+    Stream.take(1),
+    Stream.runHead,
+    Effect.flatten,
+    Effect.orElse(
+      () =>
+        new WranglerDevServerError({
+          cause: 'WranglerReadyLineMissing',
+          message: 'Wrangler server did not emit a "Ready on" line',
+          port: 0,
+        }),
+    ),
+    Effect.timeoutFail({
+      duration: '30 seconds',
+      onTimeout: () =>
         new WranglerDevServerError({
           cause: error,
           message: 'Wrangler server failed to start within timeout',
           port: 0,
         }),
-    ),
+    }),
   )
+
+/**
+ * Verifies the server is actually accepting HTTP connections by making a test request
+ */
+const verifyHttpConnectivity = ({
+  url,
+  showLogs,
+  connectTimeout,
+}: {
+  url: string
+  showLogs: boolean
+  connectTimeout: Duration.DurationInput
+}): Effect.Effect<void, WranglerDevServerError, HttpClient.HttpClient> =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+
+    if (showLogs) {
+      yield* Effect.logDebug(`Verifying HTTP connectivity to ${url}`)
+    }
+
+    // Try to connect with retries using exponential backoff
+    yield* client.get(url).pipe(
+      Effect.retryOrElse(
+        Schedule.exponential('50 millis', 2).pipe(
+          Schedule.jittered,
+          Schedule.intersect(Schedule.elapsed.pipe(Schedule.whileOutput(Duration.lessThanOrEqualTo(connectTimeout)))),
+          Schedule.compose(Schedule.count),
+        ),
+        (error, attemptCount) =>
+          Effect.fail(
+            new WranglerDevServerError({
+              cause: error,
+              message: `Failed to establish HTTP connection to Wrangler server at ${url} after ${attemptCount} attempts (timeout: ${Duration.toMillis(connectTimeout)}ms)`,
+              port: 0,
+            }),
+          ),
+      ),
+      Effect.tap(() => (showLogs ? Effect.logDebug(`HTTP connectivity verified for ${url}`) : Effect.void)),
+      Effect.asVoid,
+      Effect.withSpan('verifyHttpConnectivity'),
+    )
+  })

package/src/node-vitest/Vitest.ts

@@ -20,12 +20,17 @@ export * from '@effect/vitest'
 
 export const DEBUGGER_ACTIVE = Boolean(process.env.DEBUGGER_ACTIVE ?? inspector.url() !== undefined)
 
-export const makeWithTestCtx =
-  <R1 = never, E1 = never>(ctxParams: WithTestCtxParams<R1, E1>) =>
-  (testContext: Vitest.TestContext) =>
+export const makeWithTestCtx: <R1, E1>(
+  ctxParams: WithTestCtxParams<R1, E1>,
+) => (
+  testContext: Vitest.TestContext,
+) => <A, E>(
+  self: Effect.Effect<A, E, Scope.Scope | NoInfer<R1> | OtelTracer.OtelTracer>,
+) => Effect.Effect<A, E1 | Cause.TimeoutException | E, Scope.Scope> =
+  (ctxParams) => (testContext: Vitest.TestContext) =>
     withTestCtx(testContext, ctxParams)
 
-export type WithTestCtxParams<R1 = never, E1 = never> = {
+export type WithTestCtxParams<R1, E1> = {
   suffix?: string
   makeLayer?: (testContext: Vitest.TestContext) => Layer.Layer<R1, E1, Scope.Scope>
   timeout?: Duration.DurationInput