Add signal handlers to release lock on SIGINT/SIGTERM/SIGHUP

This prevents stale lockfiles from being left behind when the build
process is interrupted by a signal (Ctrl+C, kill, terminal close).

The signal handlers:
- Register after the lock is acquired
- Release the lock before re-emitting the signal to allow normal termination
- Are cleaned up after normal build completion to avoid memory leaks

Also adds a test to verify signal handlers are properly registered
and removed during the build lifecycle.

Author: skypher

packages/app/src/cli/services/build/extension.test.ts

@@ -388,4 +388,36 @@ describe('buildFunctionExtension', () => {
     expect(lockfile.lock).toHaveBeenCalled()
     expect(releaseLock).toHaveBeenCalled()
   })
+
+  test('registers signal handlers after acquiring lock and removes them after release', async () => {
+    // Given
+    const processOnSpy = vi.spyOn(process, 'on')
+    const processRemoveListenerSpy = vi.spyOn(process, 'removeListener')
+
+    // When
+    await expect(
+      buildFunctionExtension(extension, {
+        stdout,
+        stderr,
+        signal,
+        app,
+        environment: 'production',
+      }),
+    ).resolves.toBeUndefined()
+
+    // Then
+    // Verify signal handlers were registered for SIGINT, SIGTERM, SIGHUP
+    expect(processOnSpy).toHaveBeenCalledWith('SIGINT', expect.any(Function))
+    expect(processOnSpy).toHaveBeenCalledWith('SIGTERM', expect.any(Function))
+    expect(processOnSpy).toHaveBeenCalledWith('SIGHUP', expect.any(Function))
+
+    // Verify signal handlers were removed after build completed
+    expect(processRemoveListenerSpy).toHaveBeenCalledWith('SIGINT', expect.any(Function))
+    expect(processRemoveListenerSpy).toHaveBeenCalledWith('SIGTERM', expect.any(Function))
+    expect(processRemoveListenerSpy).toHaveBeenCalledWith('SIGHUP', expect.any(Function))
+
+    // Cleanup spies
+    processOnSpy.mockRestore()
+    processRemoveListenerSpy.mockRestore()
+  })
 })

packages/app/src/cli/services/build/extension.ts

@@ -130,6 +130,42 @@ type BuildFunctionExtensionOptions = ExtensionBuildOptions
 // This should be long enough to allow for slow builds but short enough to recover from crashes
 const LOCK_STALE_MS = 10000
 
+// Signals that should trigger lock cleanup
+const CLEANUP_SIGNALS: NodeJS.Signals[] = ['SIGINT', 'SIGTERM', 'SIGHUP']
+
+/**
+ * Registers signal handlers to release the lock on abnormal termination.
+ * Returns a cleanup function to remove the handlers when the lock is released normally.
+ */
+function registerLockCleanupHandlers(releaseLock: () => Promise<void>): () => void {
+  const handlers: Map<NodeJS.Signals, NodeJS.SignalsListener> = new Map()
+
+  for (const signal of CLEANUP_SIGNALS) {
+    const handler: NodeJS.SignalsListener = () => {
+      outputDebug(`Received ${signal}, releasing build lock...`)
+      // Use sync-style cleanup since we're in a signal handler
+      // The lock release is async but we need to at least initiate it
+      releaseLock()
+        .catch((err) => outputDebug(`Failed to release lock on ${signal}: ${err}`))
+        .finally(() => {
+          // Re-emit the signal after cleanup so the process can terminate normally
+          // Remove our handler first to avoid infinite loop
+          process.removeListener(signal, handler)
+          process.kill(process.pid, signal)
+        })
+    }
+    handlers.set(signal, handler)
+    process.on(signal, handler)
+  }
+
+  // Return cleanup function to remove handlers
+  return () => {
+    for (const [signal, handler] of handlers) {
+      process.removeListener(signal, handler)
+    }
+  }
+}
+
 /**
  * Removes a stale lockfile if it exists and is not actively held.
  * This handles cases where a previous build process crashed without releasing the lock.
@@ -170,7 +206,8 @@ export async function buildFunctionExtension(
   // Clean up any stale locks from crashed builds before attempting to acquire
   await cleanupStaleLock(lockfilePath)
 
-  let releaseLock
+  let releaseLock: () => Promise<void>
+  let removeSignalHandlers: () => void
   try {
     releaseLock = await lockfile.lock(extension.directory, {
       retries: {
@@ -181,6 +218,8 @@ export async function buildFunctionExtension(
       stale: LOCK_STALE_MS,
       lockfilePath,
     })
+    // Register signal handlers to release lock on SIGINT, SIGTERM, SIGHUP
+    removeSignalHandlers = registerLockCleanupHandlers(releaseLock)
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
   } catch (error: any) {
     outputDebug(`Failed to acquire function build lock: ${error.message}`)
@@ -231,6 +270,8 @@ export async function buildFunctionExtension(
     newError.errors = error.errors
     throw newError
   } finally {
+    // Remove signal handlers before releasing lock (normal termination path)
+    removeSignalHandlers()
     await releaseLock()
   }
 }