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

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/ChildProcessRunner.test.ts

@@ -1,13 +1,12 @@
-// import * as WorkerThreads from 'node:worker_threads'
 import * as ChildProcess from 'node:child_process'
 
 import * as EffectWorker from '@effect/platform/Worker'
 import { assert, describe, it } from '@effect/vitest'
-import { Chunk, Effect, Stream } from 'effect'
+import { Chunk, Effect, Exit, Fiber, Scope, Stream } from 'effect'
 
 import * as ChildProcessWorker from '../ChildProcessWorker.ts'
 import type { WorkerMessage } from './schema.ts'
-import { GetPersonById, GetUserById, InitialMessage, Person, User } from './schema.ts'
+import { GetPersonById, GetUserById, InitialMessage, Person, StartStubbornWorker, User } from './schema.ts'
 
 const WorkerLive = ChildProcessWorker.layer(() =>
   ChildProcess.fork(
@@ -49,4 +48,255 @@ describe('ChildProcessRunner', { timeout: 10_000 }, () => {
         new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
       ])
     }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
+
+  describe('Process Cleanup', { timeout: 15_000 }, () => {
+    const isProcessRunning = (pid: number) => {
+      try {
+        process.kill(pid, 0) // Signal 0 checks if process exists
+        return true
+      } catch {
+        return false
+      }
+    }
+
+    it('should clean up child processes when Effect is interrupted', () =>
+      Effect.gen(function* () {
+        let workerPid: number | undefined
+
+        const testEffect = Effect.gen(function* () {
+          const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+            size: 1,
+            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
+          })
+          const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 }))
+          workerPid = result.pid
+
+          // Verify the worker process is running
+          assert.strictEqual(isProcessRunning(workerPid), true, 'Worker process should be running')
+
+          // Start a long-running operation that we'll interrupt
+          yield* Effect.sleep('60 seconds')
+        }).pipe(Effect.scoped, Effect.provide(WorkerLive))
+
+        // Run the test effect but interrupt it after 2 seconds
+        const fiber = yield* Effect.fork(testEffect)
+        yield* Effect.sleep('2 seconds')
+        yield* Fiber.interrupt(fiber)
+
+        // Wait a moment for cleanup to complete
+        yield* Effect.sleep('1 second')
+
+        // Verify the child process was cleaned up
+        if (workerPid) {
+          assert.strictEqual(
+            isProcessRunning(workerPid),
+            false,
+            `Worker process ${workerPid} should be terminated after Effect interruption`,
+          )
+        } else {
+          assert.fail('Worker PID was not captured')
+        }
+      }).pipe(Effect.runPromise))
+
+    it('should clean up child processes when scope is closed abruptly', () =>
+      Effect.gen(function* () {
+        let workerPid: number | undefined
+
+        // Create a scope that we can close manually
+        const scope = yield* Scope.make()
+
+        try {
+          const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+            size: 1,
+            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
+          }).pipe(Scope.extend(scope), Effect.provide(WorkerLive))
+
+          const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 }))
+          workerPid = result.pid
+
+          // Verify the worker is running
+          assert.strictEqual(isProcessRunning(workerPid!), true, 'Worker process should be running')
+        } finally {
+          // Abruptly close the scope (simulating test abortion)
+          yield* Scope.close(scope, Exit.void)
+        }
+
+        // Wait for cleanup
+        yield* Effect.sleep('1 second')
+
+        // This should pass but will initially fail due to zombie process issue
+        if (workerPid) {
+          assert.strictEqual(
+            isProcessRunning(workerPid),
+            false,
+            `Worker process ${workerPid} should be terminated after scope closure`,
+          )
+        } else {
+          assert.fail('Worker PID was not captured')
+        }
+      }).pipe(Effect.runPromise))
+
+    it('should clean up child processes when parent receives SIGINT', () =>
+      Effect.gen(function* () {
+        let workerPid: number | undefined
+
+        const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+          size: 1,
+          initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
+        })
+
+        const result = yield* pool.executeEffect(new StartStubbornWorker({ blockDuration: 60_000 }))
+        workerPid = result.pid
+
+        // Verify the worker is running
+        assert.strictEqual(isProcessRunning(workerPid), true, 'Worker process should be running')
+
+        // Simulate SIGINT being sent to current process (like Ctrl+C in vitest)
+        // This should trigger cleanup of child processes
+        yield* Effect.async<void>((resume) => {
+          // Store current listeners before we manipulate them
+          const currentSIGINTListeners = process.listeners('SIGINT').slice()
+
+          // Set up our test handler
+          const testHandler = () => {
+            // Emit SIGINT to all current listeners to trigger cleanup
+            currentSIGINTListeners.forEach((listener) => {
+              try {
+                ;(listener as Function)()
+              } catch {
+                // Ignore errors
+              }
+            })
+            resume(Effect.void)
+          }
+
+          // Remove all current SIGINT listeners and add our test handler
+          process.removeAllListeners('SIGINT')
+          process.once('SIGINT', testHandler)
+
+          // Send SIGINT after a short delay
+          setTimeout(() => {
+            process.kill(process.pid, 'SIGINT')
+          }, 1000)
+        })
+
+        // Wait for cleanup to complete
+        yield* Effect.sleep('2 seconds')
+
+        // This test should initially fail - child process will still be running
+        if (workerPid) {
+          assert.strictEqual(
+            isProcessRunning(workerPid),
+            false,
+            `Worker process ${workerPid} should be terminated after SIGINT`,
+          )
+        } else {
+          assert.fail('Worker PID was not captured')
+        }
+      }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
+
+    it('should clean up multiple concurrent child processes', () =>
+      Effect.gen(function* () {
+        let workerPids: number[] = []
+
+        const testEffect = Effect.gen(function* () {
+          const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+            size: 3, // Multiple workers
+            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
+          })
+
+          // Start multiple stubborn workers
+          const workers = yield* Effect.all(
+            [
+              pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 })),
+              pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 })),
+              pool.executeEffect(new StartStubbornWorker({ blockDuration: 30_000 })),
+            ],
+            { concurrency: 'unbounded' },
+          )
+
+          workerPids = workers.map((w) => w.pid)
+
+          // Verify all workers are running
+          for (const pid of workerPids) {
+            assert.strictEqual(isProcessRunning(pid), true, `Worker process ${pid} should be running`)
+          }
+
+          yield* Effect.sleep('30 seconds') // Keep running until interrupted
+        }).pipe(Effect.scoped, Effect.provide(WorkerLive))
+
+        // Run with timeout to force termination
+        const fiber = yield* Effect.fork(testEffect)
+        yield* Effect.sleep('2 seconds')
+        yield* Fiber.interrupt(fiber)
+
+        // Wait for cleanup
+        yield* Effect.sleep('2 seconds')
+
+        // All worker processes should be cleaned up
+        for (const pid of workerPids) {
+          assert.strictEqual(
+            isProcessRunning(pid),
+            false,
+            `Worker process ${pid} should be terminated after pool cleanup`,
+          )
+        }
+      }).pipe(Effect.runPromise))
+
+    it('should handle direct ChildProcess.fork cleanup (node-sync pattern)', () =>
+      Effect.gen(function* () {
+        let childPid: number | undefined
+
+        // This mimics the exact pattern used in node-sync tests
+        const nodeChildProcess = ChildProcess.fork(
+          new URL(
+            '../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js',
+            import.meta.url,
+          ),
+          ['test-client'],
+        )
+
+        childPid = nodeChildProcess.pid
+
+        const testEffect = Effect.gen(function* () {
+          const worker = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+            size: 1,
+            concurrency: 100,
+            initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
+          }).pipe(Effect.provide(ChildProcessWorker.layer(() => nodeChildProcess)))
+
+          // Start stubborn worker
+          yield* worker.executeEffect(new StartStubbornWorker({ blockDuration: 60_000 }))
+
+          // Verify process is running
+          if (childPid) {
+            assert.strictEqual(isProcessRunning(childPid), true, 'Child process should be running')
+          }
+
+          // Keep running until interrupted
+          yield* Effect.sleep('30 seconds')
+        }).pipe(Effect.scoped)
+
+        // Simulate the exact abortion pattern from node-sync
+        const fiber = yield* Effect.fork(testEffect)
+        yield* Effect.sleep('2 seconds')
+
+        // Force kill the fiber without proper cleanup (simulates Ctrl+C)
+        yield* Fiber.interrupt(fiber)
+
+        // Wait for cleanup
+        yield* Effect.sleep('3 seconds')
+
+        // This test should initially fail - demonstrating the zombie process issue
+        if (childPid) {
+          assert.strictEqual(
+            isProcessRunning(childPid),
+            false,
+            `Child process ${childPid} should be terminated after forced interruption`,
+          )
+        } else {
+          assert.fail('Child PID was not captured')
+        }
+      }).pipe(Effect.runPromise))
+  })
 })

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/schema.ts

@@ -35,6 +35,12 @@ export class RunnerInterrupt extends Schema.TaggedRequest<RunnerInterrupt>()('Ru
   payload: {},
 }) {}
 
+export class StartStubbornWorker extends Schema.TaggedRequest<StartStubbornWorker>()('StartStubbornWorker', {
+  failure: Schema.Never,
+  success: Schema.Struct({ pid: Schema.Number }),
+  payload: { blockDuration: Schema.Number },
+}) {}
+
 export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
   failure: Schema.Never,
   success: Schema.Void,
@@ -61,5 +67,12 @@ export class GetSpan extends Schema.TaggedRequest<GetSpan>()('GetSpan', {
   payload: {},
 }) {}
 
-export const WorkerMessage = Schema.Union(GetUserById, GetPersonById, InitialMessage, GetSpan, RunnerInterrupt)
+export const WorkerMessage = Schema.Union(
+  GetUserById,
+  GetPersonById,
+  InitialMessage,
+  GetSpan,
+  RunnerInterrupt,
+  StartStubbornWorker,
+)
 export type WorkerMessage = Schema.Schema.Type<typeof WorkerMessage>

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.ts

@@ -22,7 +22,7 @@ const WorkerLive = Runner.layerSerialized(WorkerMessage, {
   // InitialMessage: (req) => Layer.succeed(Name, req.name),
   InitialMessage: (req) =>
     Effect.gen(function* () {
-      yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
+      // yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
       return Layer.succeed(Name, req.name)
     }).pipe(Layer.unwrapScoped),
   // InitialMessage: (req) =>
@@ -47,6 +47,19 @@ const WorkerLive = Runner.layerSerialized(WorkerMessage, {
       }
     }).pipe(Effect.withSpan('GetSpan')),
   RunnerInterrupt: () => Effect.interrupt,
+  StartStubbornWorker: ({ blockDuration }) =>
+    Effect.gen(function* () {
+      // Start a blocking operation that won't respond to normal shutdown signals
+      const pid = process.pid
+      yield* Effect.fork(
+        Effect.gen(function* () {
+          // Block for the specified duration, ignoring shutdown attempts
+          yield* Effect.sleep(`${blockDuration} millis`)
+          yield* Effect.log('Stubborn worker finished blocking')
+        }).pipe(Effect.uninterruptible),
+      )
+      return { pid }
+    }),
 }).pipe(Layer.provide(ChildProcessRunner.layer))
 // }).pipe(Layer.provide(PlatformNode.NodeWorkerRunner.layer))
 

package/src/node/ChildProcessRunner/ChildProcessWorker.ts

@@ -7,22 +7,114 @@ import * as Exit from 'effect/Exit'
 import * as Layer from 'effect/Layer'
 import * as Scope from 'effect/Scope'
 
+// Track child processes for cleanup on process signals
+const childProcesses = new Set<ChildProcess.ChildProcess>()
+
+// Force cleanup all tracked child processes
+const forceCleanupChildren = (signal: NodeJS.Signals = 'SIGKILL') => {
+  for (const child of childProcesses) {
+    try {
+      if (!child.killed) {
+        child.kill(signal)
+      }
+    } catch {
+      // Ignore errors during cleanup
+    }
+  }
+  childProcesses.clear()
+}
+
+// Install signal handlers once to clean up all child processes
+let signalHandlersInstalled = false
+
+const installSignalHandlers = () => {
+  if (signalHandlersInstalled) return
+  signalHandlersInstalled = true
+
+  // Use 'beforeExit' instead of signal handlers since tests may interfere with signals
+  process.on('beforeExit', () => {
+    forceCleanupChildren('SIGKILL')
+  })
+
+  // Also try to cleanup on uncaught exceptions
+  process.on('uncaughtException', () => {
+    forceCleanupChildren('SIGKILL')
+  })
+
+  // Install signal handlers but make them more robust
+  const sigintHandler = () => {
+    forceCleanupChildren('SIGINT')
+  }
+
+  const sigtermHandler = () => {
+    forceCleanupChildren('SIGTERM')
+  }
+
+  const exitHandler = () => {
+    forceCleanupChildren('SIGKILL')
+  }
+
+  // Add handlers that will persist even if tests remove/add other handlers
+  process.prependListener('SIGINT', sigintHandler)
+  process.prependListener('SIGTERM', sigtermHandler)
+  process.prependListener('exit', exitHandler)
+}
+
 const platformWorkerImpl = Worker.makePlatform<ChildProcess.ChildProcess>()({
   setup({ scope, worker: childProcess }) {
     return Effect.flatMap(Deferred.make<void, WorkerError>(), (exitDeferred) => {
+      // Install signal handlers for process-wide cleanup
+      installSignalHandlers()
+
+      // Track this child process for cleanup
+      childProcesses.add(childProcess)
+
       childProcess.on('exit', () => {
+        // Remove from tracking when process exits
+        childProcesses.delete(childProcess)
         Deferred.unsafeDone(exitDeferred, Exit.void)
       })
+
+      childProcess.send(['setup-parent-death-detection', { parentPid: process.pid }])
+
       return Effect.as(
         Scope.addFinalizer(
           scope,
           Effect.suspend(() => {
-            childProcess.send([1])
+            // Try graceful shutdown first
+            try {
+              childProcess.send([1])
+            } catch {
+              // IPC channel might be closed, proceed to forceful termination
+            }
+
             return Deferred.await(exitDeferred)
           }).pipe(
-            Effect.timeout(5000),
+            Effect.timeout(3000), // Reduced timeout for faster cleanup
             Effect.interruptible,
-            Effect.catchAllCause(() => Effect.sync(() => childProcess.kill())),
+            Effect.catchAllCause(() =>
+              Effect.sync(() => {
+                // Enhanced cleanup with escalating signals
+                if (!childProcess.killed) {
+                  try {
+                    // First try SIGTERM
+                    childProcess.kill('SIGTERM')
+
+                    // If still running after a short delay, use SIGKILL
+                    setTimeout(() => {
+                      if (!childProcess.killed) {
+                        childProcess.kill('SIGKILL')
+                      }
+                    }, 1000)
+                  } catch {
+                    // Process might already be dead
+                  } finally {
+                    // Ensure it's removed from tracking
+                    childProcesses.delete(childProcess)
+                  }
+                }
+              }),
+            ),
           ),
         ),
         {
@@ -56,5 +148,21 @@ export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerIm
 
 export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
 
+/**
+ * @example
+ * ```ts
+ * import * as ChildProcess from 'node:child_process'
+ * import { Effect, Worker } from '@effect/platform/Worker'
+ * import { ChildProcessWorker } from '@livestore/utils/node'
+ *
+ * Worker.makePoolSerialized<WorkerMessage>({
+ *   size: 1,
+ *   initialMessage: () => new InitialMessage({ name: 'test', data: new Uint8Array([1, 2, 3]) }),
+ * }).pipe(
+ *   Effect.provide(ChildProcessWorker.layer(() => ChildProcess.fork(new URL('worker.ts', import.meta.url)))),
+ * )
+ * ```
+ *
+ */
 export const layer = (spawn: (id: number) => ChildProcess.ChildProcess) =>
   Layer.merge(layerManager, Worker.layerSpawner(spawn))

package/src/node/mod.ts

@@ -37,8 +37,8 @@ export const getFreePort: Effect.Effect<number, UnknownError> = Effect.async<num
   })
 
   // Error handling in case the server encounters an error
-  server.on('error', (err) => {
-    server.close(() => cb(Effect.fail(new UnknownError({ cause: err }))))
+  server.on('error', (cause) => {
+    server.close(() => cb(Effect.fail(new UnknownError({ cause, payload: 'Failed to get a free port' }))))
   })
 })