@livestore/utils-dev 0.4.0-dev.5 → 0.4.0-dev.6

package/src/node/WranglerDevServer/WranglerDevServer.ts

@@ -0,0 +1,266 @@
+import * as path from 'node:path'
+import { IS_CI } from '@livestore/utils'
+import {
+  Command,
+  Duration,
+  Effect,
+  Exit,
+  HttpClient,
+  type PlatformError,
+  Schedule,
+  Schema,
+  Stream,
+} from '@livestore/utils/effect'
+import { getFreePort } from '@livestore/utils/node'
+import { cleanupOrphanedProcesses, killProcessTree } from './process-tree-manager.ts'
+
+/**
+ * Error type for WranglerDevServer operations
+ */
+export class WranglerDevServerError extends Schema.TaggedError<WranglerDevServerError>()('WranglerDevServerError', {
+  cause: Schema.Unknown,
+  message: Schema.String,
+  port: Schema.Number,
+}) {}
+
+/**
+ * WranglerDevServer instance interface
+ */
+export interface WranglerDevServer {
+  readonly port: number
+  readonly url: string
+  readonly processId: number
+}
+
+/**
+ * Configuration for starting WranglerDevServer
+ */
+export interface StartWranglerDevServerArgs {
+  wranglerConfigPath?: string
+  cwd: string
+  port?: number
+  /** @default false */
+  showLogs?: boolean
+  connectTimeout?: Duration.DurationInput
+}
+
+/**
+ * WranglerDevServer as an Effect.Service.
+ *
+ * This service provides the WranglerDevServer properties and can be accessed
+ * directly to get port, url, and processId.
+ *
+ * TODO: Allow for config to be passed in via code instead of `wrangler.toml` file
+ * (would need to be placed in temporary file as wrangler only accepts files as config)
+ */
+export class WranglerDevServerService extends Effect.Service<WranglerDevServerService>()('WranglerDevServerService', {
+  scoped: (args: StartWranglerDevServerArgs) =>
+    Effect.gen(function* () {
+      const showLogs = args.showLogs ?? false
+
+      // Clean up any orphaned processes before starting (defensive cleanup)
+      yield* cleanupOrphanedProcesses(['wrangler', 'workerd']).pipe(
+        Effect.tap((result) =>
+          showLogs && (result.cleaned.length > 0 || result.failed.length > 0)
+            ? Effect.logInfo(`Cleanup result: ${result.cleaned.length} cleaned, ${result.failed.length} failed`)
+            : Effect.void,
+        ),
+        Effect.ignore, // Don't fail startup if cleanup fails
+      )
+
+      // Allocate port
+      const port =
+        args.port ??
+        (yield* getFreePort.pipe(
+          Effect.mapError(
+            (cause) => new WranglerDevServerError({ cause, message: 'Failed to get free port', port: -1 }),
+          ),
+        ))
+
+      yield* Effect.annotateCurrentSpan({ port })
+
+      // Resolve config path
+      const configPath = path.resolve(args.wranglerConfigPath ?? path.join(args.cwd, 'wrangler.toml'))
+
+      // Start wrangler process using Effect Command
+      const process = yield* Command.make(
+        'bunx',
+        'wrangler',
+        'dev',
+        '--port',
+        port.toString(),
+        '--config',
+        configPath,
+      ).pipe(
+        Command.workingDirectory(args.cwd),
+        Command.stdout('pipe'),
+        Command.stderr('pipe'),
+        Command.start,
+        Effect.catchAllCause(
+          (error) =>
+            new WranglerDevServerError({
+              cause: error,
+              message: `Failed to start wrangler process in directory: ${args.cwd}`,
+              port,
+            }),
+        ),
+        Effect.withSpan('WranglerDevServerService:startProcess'),
+      )
+
+      if (showLogs) {
+        yield* process.stderr.pipe(
+          Stream.decodeText('utf8'),
+          Stream.tapLogWithLabel('wrangler:stderr'),
+          Stream.runDrain,
+          Effect.forkScoped,
+        )
+      }
+
+      const processId = process.pid
+
+      // We need to keep the `stdout` stream open, as we drain it in the waitForReady function
+      // Otherwise we'll get a EPIPE error
+      const stdout = yield* Stream.broadcastDynamic(process.stdout, 100)
+
+      // Register cleanup finalizer with intelligent timeout handling
+      yield* Effect.addFinalizer((exit) =>
+        Effect.gen(function* () {
+          const isInterrupted = Exit.isInterrupted(exit)
+          if (showLogs) {
+            yield* Effect.logDebug(`Cleaning up wrangler process ${processId}, interrupted: ${isInterrupted}`)
+          }
+          // yield* Effect.logDebug(`Cleaning up wrangler process ${processId}, interrupted: ${isInterrupted}`)
+
+          // Check if process is still running
+          const isRunning = yield* process.isRunning
+
+          if (isRunning) {
+            // Use our enhanced process tree cleanup
+            yield* killProcessTree(processId, {
+              timeout: isInterrupted ? 500 : 3000, // Fast cleanup on interruption
+              signals: ['SIGTERM', 'SIGKILL'],
+              includeRoot: true,
+            }).pipe(
+              Effect.tap((result) =>
+                showLogs
+                  ? Effect.logDebug(
+                      `Cleaned up ${result.killedPids.length} processes, ${result.failedPids.length} failed`,
+                    )
+                  : Effect.void,
+              ),
+              Effect.mapError(
+                (error) =>
+                  new WranglerDevServerError({
+                    cause: error,
+                    message: `Failed to kill process tree for PID ${processId}`,
+                    port: 0,
+                  }),
+              ),
+              Effect.ignore, // Don't fail the finalizer if cleanup has issues
+            )
+
+            // Also kill the command process handle
+            yield* process.kill()
+          } else if (showLogs) {
+            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 })
+
+      const url = `http://localhost:${port}`
+
+      // Use longer timeout in CI environments to account for slower startup times
+      const defaultTimeout = Duration.seconds(IS_CI ? 15 : 5)
+      yield* verifyHttpConnectivity({ url, showLogs, connectTimeout: args.connectTimeout ?? defaultTimeout })
+
+      if (showLogs) {
+        yield* Effect.logDebug(`Wrangler dev server ready and accepting connections on port ${port}`)
+      }
+
+      return {
+        port,
+        url,
+        processId,
+      } satisfies WranglerDevServer
+    }).pipe(
+      Effect.withSpan('WranglerDevServerService', {
+        attributes: { port: args.port ?? 'auto', cwd: args.cwd },
+      }),
+    ),
+}) {}
+
+/**
+ * Waits for Wrangler server to be ready by monitoring stdout for "Ready on" message
+ */
+const waitForReady = ({
+  stdout,
+  showLogs,
+}: {
+  stdout: Stream.Stream<Uint8Array, PlatformError.PlatformError, never>
+  showLogs: boolean
+}): Effect.Effect<void, 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) =>
+        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/WranglerDevServer/fixtures/cf-worker.ts

@@ -0,0 +1,11 @@
+export default {
+  async fetch(_request: Request): Promise<Response> {
+    return new Response('Hello from Wrangler Dev Server test worker!')
+  },
+}
+
+export class TestDO {
+  async fetch(_request: Request): Promise<Response> {
+    return new Response('Hello from Test Durable Object!')
+  }
+}

package/src/node/WranglerDevServer/fixtures/wrangler.toml

@@ -0,0 +1,11 @@
+name = "wrangler-dev-server-test"
+main = "./cf-worker.ts"
+compatibility_date = "2024-05-12"
+
+[[durable_objects.bindings]]
+name = "TEST_DO"
+class_name = "TestDO"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["TestDO"]

package/src/node/WranglerDevServer/process-tree-manager.ts

@@ -0,0 +1,263 @@
+import { Command, type CommandExecutor, Effect, Schema, type Scope, Stream } from '@livestore/utils/effect'
+
+export class ProcessTreeError extends Schema.TaggedError<ProcessTreeError>()('ProcessTreeError', {
+  cause: Schema.Unknown,
+  message: Schema.String,
+  pid: Schema.Number,
+}) {}
+
+/**
+ * Finds all child processes of a given parent PID
+ */
+export const findChildProcesses = (
+  parentPid: number,
+): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const result = yield* Command.make('ps', '-o', 'pid,ppid', '-ax').pipe(
+      Command.start,
+      Effect.flatMap((command) =>
+        command.stdout.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runCollect,
+          Effect.map((chunks) => Array.from(chunks).join('')),
+        ),
+      ),
+      Effect.catchAll(() => Effect.succeed('')), // Return empty string if command fails
+    )
+
+    if (!result) return []
+
+    const lines = result.split('\n')
+    const pattern = new RegExp(`^\\s*([0-9]+)\\s+${parentPid}\\s*$`)
+
+    const childPids = lines
+      .map((line) => {
+        const match = line.trim().match(pattern)
+        return match ? Number.parseInt(match[1]!, 10) : null
+      })
+      .filter((pid): pid is number => pid !== null)
+
+    return childPids
+  })
+
+/**
+ * Recursively finds all descendants of a process
+ */
+export const findProcessTree = (
+  rootPid: number,
+): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const allPids = new Set<number>([rootPid])
+    const toProcess = [rootPid]
+
+    while (toProcess.length > 0) {
+      const currentPid = toProcess.pop()!
+      const children = yield* findChildProcesses(currentPid)
+
+      for (const childPid of children) {
+        if (!allPids.has(childPid)) {
+          allPids.add(childPid)
+          toProcess.push(childPid)
+        }
+      }
+    }
+
+    return Array.from(allPids)
+  })
+
+/**
+ * Checks if a process is running
+ */
+export const isProcessRunning = (pid: number): Effect.Effect<boolean, never, never> =>
+  Effect.sync(() => {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  })
+
+/**
+ * Kills a process tree with escalating signals
+ */
+export const killProcessTree = (
+  rootPid: number,
+  options: {
+    timeout?: number
+    signals?: NodeJS.Signals[]
+    includeRoot?: boolean
+  } = {},
+): Effect.Effect<
+  { killedPids: number[]; failedPids: number[] },
+  never,
+  CommandExecutor.CommandExecutor | Scope.Scope
+> =>
+  Effect.gen(function* () {
+    const { timeout = 5000, signals = ['SIGTERM', 'SIGKILL'], includeRoot = true } = options
+
+    // Find all processes in the tree
+    const allPids = yield* findProcessTree(rootPid)
+    const pidsToKill = includeRoot ? allPids : allPids.filter((pid) => pid !== rootPid)
+
+    if (pidsToKill.length === 0) {
+      return { killedPids: [], failedPids: [] }
+    }
+
+    const killedPids: number[] = []
+    const failedPids: number[] = []
+
+    // Try each signal with timeout
+    for (const signal of signals) {
+      // Check which processes are still running and not yet killed
+      const stillRunningChecks = yield* Effect.all(
+        pidsToKill
+          .filter((pid) => !killedPids.includes(pid))
+          .map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
+      )
+      const remainingPids = stillRunningChecks.filter(({ running }) => running).map(({ pid }) => pid)
+
+      if (remainingPids.length === 0) break
+
+      // Send signal to all remaining processes
+      for (const pid of remainingPids) {
+        yield* Effect.sync(() => {
+          try {
+            process.kill(pid, signal)
+          } catch {
+            // Process might already be dead, continue
+          }
+        })
+      }
+
+      // Wait for processes to terminate with polling
+      const waitStart = Date.now()
+      while (Date.now() - waitStart < timeout) {
+        const runningChecks = yield* Effect.all(
+          remainingPids.map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
+        )
+        const stillRunning = runningChecks.filter(({ running }) => running).map(({ pid }) => pid)
+
+        if (stillRunning.length === 0) {
+          // All processes terminated
+          killedPids.push(...remainingPids)
+          break
+        }
+
+        // Short sleep before checking again
+        yield* Effect.sleep('100 millis')
+      }
+    }
+
+    // Check final status
+    const finalChecks = yield* Effect.all(
+      pidsToKill.map((pid) => isProcessRunning(pid).pipe(Effect.map((running) => ({ pid, running })))),
+    )
+
+    for (const { pid, running } of finalChecks) {
+      if (!killedPids.includes(pid) && running) {
+        failedPids.push(pid)
+      }
+    }
+
+    return { killedPids, failedPids }
+  })
+
+/**
+ * Finds orphaned processes by name pattern
+ */
+export const findOrphanedProcesses = (
+  namePattern: string,
+): Effect.Effect<number[], never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    // Find processes that match the pattern and have init (PID 1) as parent
+    const result = yield* Command.make('ps', '-eo', 'pid,ppid,comm').pipe(
+      Command.start,
+      Effect.flatMap((command) =>
+        command.stdout.pipe(
+          Stream.decodeText('utf8'),
+          Stream.runCollect,
+          Effect.map((chunks) => Array.from(chunks).join('')),
+        ),
+      ),
+      Effect.catchAll(() => Effect.succeed('')), // Return empty string if command fails
+    )
+
+    if (!result) return []
+
+    const lines = result.split('\n')
+    const patternRegex = new RegExp(namePattern)
+    const parentRegex = /^\s*(\d+)\s+1\s+/
+
+    const orphanedPids = lines
+      .filter((line) => patternRegex.test(line))
+      .map((line) => {
+        const match = line.trim().match(parentRegex)
+        return match ? Number.parseInt(match[1]!, 10) : null
+      })
+      .filter((pid): pid is number => pid !== null)
+
+    return orphanedPids
+  })
+
+/**
+ * Defensive cleanup for orphaned processes matching given patterns.
+ *
+ * This function provides fallback cleanup for edge cases where normal process
+ * termination mechanisms fail (e.g., hard crashes, SIGKILL before cleanup runs,
+ * or limitations in synchronous exit handlers). While proper process tree cleanup
+ * should prevent orphans in most cases, this serves as a safety net for scenarios
+ * where child processes become orphaned despite cleanup efforts.
+ *
+ * @param processPatterns - Array of process name patterns to search for (e.g., ['wrangler', 'workerd'])
+ * @returns Object with arrays of successfully cleaned and failed PIDs
+ */
+export const cleanupOrphanedProcesses = (
+  processPatterns: string[],
+): Effect.Effect<{ cleaned: number[]; failed: number[] }, never, CommandExecutor.CommandExecutor | Scope.Scope> =>
+  Effect.gen(function* () {
+    const cleaned: number[] = []
+    const failed: number[] = []
+
+    // Find all orphaned processes matching the patterns
+    const allOrphanedPids: number[] = []
+    const patternCounts: Record<string, number> = {}
+
+    for (const pattern of processPatterns) {
+      const orphaned = yield* findOrphanedProcesses(pattern)
+      allOrphanedPids.push(...orphaned)
+      patternCounts[pattern] = orphaned.length
+    }
+
+    if (allOrphanedPids.length === 0) {
+      return { cleaned, failed }
+    }
+
+    const patternSummary = Object.entries(patternCounts)
+      .map(([pattern, count]) => `${count} ${pattern}`)
+      .join(', ')
+
+    yield* Effect.logInfo(
+      `Found ${allOrphanedPids.length} orphaned processes (${patternSummary}): ${allOrphanedPids.join(', ')}`,
+    )
+
+    for (const pid of allOrphanedPids) {
+      const result = yield* killProcessTree(pid, {
+        timeout: 2000,
+        signals: ['SIGTERM', 'SIGKILL'],
+        includeRoot: true,
+      }).pipe(Effect.orElse(() => Effect.succeed({ killedPids: [], failedPids: [pid] })))
+
+      if (result.failedPids.length === 0) {
+        cleaned.push(...result.killedPids)
+        yield* Effect.logInfo(
+          `Cleaned up orphaned process tree starting with ${pid} (${result.killedPids.length} processes)`,
+        )
+      } else {
+        failed.push(pid, ...result.failedPids)
+        yield* Effect.logWarning(`Failed to clean up some processes in tree ${pid}: ${result.failedPids.join(', ')}`)
+      }
+    }
+
+    return { cleaned, failed }
+  })

package/src/node/mod.ts

@@ -14,9 +14,23 @@ import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
 export { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http'
 export { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http'
 export * from './cmd.ts'
+export {
+  type DockerComposeArgs,
+  DockerComposeError,
+  type DockerComposeOperations,
+  DockerComposeService,
+  type LogsOptions,
+  type StartOptions,
+  startDockerComposeServicesScoped,
+} from './DockerComposeService/DockerComposeService.ts'
 export * as FileLogger from './FileLogger.ts'
-export * from './vitest-docker-compose-setup.ts'
-export * from './vitest-wrangler-setup.ts'
+export * from './WranglerDevServer/process-tree-manager.ts'
+export {
+  type StartWranglerDevServerArgs,
+  type WranglerDevServer,
+  WranglerDevServerError,
+  WranglerDevServerService,
+} from './WranglerDevServer/WranglerDevServer.ts'
 
 export const OtelLiveHttp = ({
   serviceName,

package/src/node-vitest/Vitest.test.ts

@@ -0,0 +1,101 @@
+import { Effect, FastCheck } from '@livestore/utils/effect'
+import * as Vitest from './Vitest.ts'
+
+// Demonstrate enhanced asProp functionality with clear shrinking progress
+// This showcases the fix for the "Run 26/6" bug and accurate shrinking detection
+
+Vitest.describe('Vitest.asProp', () => {
+  const IntArbitrary = FastCheck.integer({ min: 1, max: 100 })
+
+  // Always-passing test - should only show initial phase
+  Vitest.asProp(
+    Vitest.scopedLive,
+    'always-pass test (shows only initial runs)',
+    [IntArbitrary],
+    (properties, _ctx, enhanced) =>
+      Effect.gen(function* () {
+        const [value] = properties
+        if (value === undefined) {
+          return yield* Effect.fail(new Error('Value is undefined'))
+        }
+
+        console.log(
+          `✅ ALWAYS-PASS [${enhanced._tag.toUpperCase()}]: ` +
+            (enhanced._tag === 'initial'
+              ? `Run ${enhanced.runIndex + 1}/${enhanced.numRuns}`
+              : `Shrink #${enhanced.shrinkAttempt} (finding minimal counterexample)`) +
+            `, value=${value}, total=${enhanced.totalExecutions}`,
+        )
+
+        // This test always passes, so no shrinking will occur
+        return
+      }),
+    { fastCheck: { numRuns: 4 } },
+  )
+
+  // Failing test - should show initial + shrinking phases
+  let alreadyFailed = false
+  Vitest.asProp(
+    Vitest.scopedLive,
+    'failing test (shows initial runs + shrinking)',
+    [IntArbitrary],
+    (properties, ctx, enhanced) =>
+      Effect.gen(function* () {
+        const [value] = properties
+        if (value === undefined) {
+          return yield* Effect.fail(new Error('Value is undefined'))
+        }
+
+        const displayInfo =
+          enhanced._tag === 'initial'
+            ? `Run ${enhanced.runIndex + 1}/${enhanced.numRuns}`
+            : `Shrink #${enhanced.shrinkAttempt} (finding minimal counterexample)`
+
+        const status = value > 80 ? '💥' : '✅'
+        console.log(
+          `${status} FAILING-TEST [${enhanced._tag.toUpperCase()}]: ${displayInfo}, value=${value}, total=${enhanced.totalExecutions}`,
+        )
+
+        // Fail when value is greater than 80 to trigger shrinking
+        if (value > 80) {
+          alreadyFailed = true
+          return yield* Effect.fail(new Error(`Value ${value} is too large (> 80)`))
+        }
+
+        if (alreadyFailed && enhanced._tag === 'shrinking') {
+          ctx.skip("For the sake of this test, we don't want to fail but want to skip")
+          return
+        }
+
+        return
+      }),
+    { fastCheck: { numRuns: 3 } },
+  )
+
+  // Test with endOnFailure: true - should not show shrinking
+  Vitest.asProp(
+    Vitest.scopedLive,
+    'failing test with endOnFailure (no shrinking)',
+    [IntArbitrary],
+    (properties, _ctx, enhanced) =>
+      Effect.gen(function* () {
+        const [value] = properties
+        if (value === undefined) {
+          return yield* Effect.fail(new Error('Value is undefined'))
+        }
+
+        console.log(
+          `🚫 END-ON-FAILURE [${enhanced._tag.toUpperCase()}]: ` +
+            `Run ${enhanced.runIndex + 1}/${enhanced.numRuns}, value=${value}, total=${enhanced.totalExecutions}`,
+        )
+
+        // This will fail but shrinking is disabled
+        if (value > 50) {
+          yield* Effect.fail(new Error(`Value ${value} is too large (> 50) - but no shrinking!`))
+        }
+
+        return
+      }),
+    { fastCheck: { numRuns: 5, endOnFailure: true }, fails: true },
+  )
+})