fix: disable scale-to-zero when process is spawned (#102)

## Problem

`ProcessSpawn` starts asynchronous processes that continue running after
the HTTP request completes. The middleware only disables scale-to-zero
during the HTTP request lifecycle, meaning the VM could scale down while
a spawned process was still running.

## Solution

Explicitly call `stz.Disable()` after starting the process, and
`stz.Enable()` when the process exits. Uses `context.WithoutCancel()`
for the Enable call since the goroutine runs after the HTTP request
returns.

The `DebouncedController` handles reference counting, so multiple
spawned processes correctly keep scale-to-zero disabled until all have
exited.

## Changes

- Add `s.stz.Disable(ctx)` after `cmd.Start()` succeeds
- Add `s.stz.Enable(stzCtx)` in the waiter goroutine when the process
exits
- Use `context.WithoutCancel(ctx)` to ensure Enable works after HTTP
request completes

This follows the same pattern used by `FFmpegRecorder.Start()` for
handling long-running processes.

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Disables scale-to-zero after spawning a process and re-enables it on
exit using a non-cancelled context; tests updated to use a Noop
scale-to-zero controller.
> 
> - **Backend (Process management)**
> - `ProcessSpawn`: call `s.stz.Disable(ctx)` after `cmd.Start()` and
track success via `stzDisabled`.
> - Waiter goroutine: use `context.WithoutCancel(ctx)` and re-enable via
`s.stz.Enable(stzCtx)` only if previously disabled.
> - Minor: pass `stzDisabled` into waiter; add log on enable/disable
errors.
> - **Tests**
> - Update spawn/stream/stdin/kill tests to initialize `ApiService` with
`scaletozero.NewNoopController()`.
>   - Add `scaletozero` import.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
bdb981c. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: rgarcia

server/cmd/api/api/process.go

@@ -240,6 +240,15 @@ func (s *ApiService) ProcessSpawn(ctx context.Context, request oapi.ProcessSpawn
 		return oapi.ProcessSpawn500JSONResponse{InternalErrorJSONResponse: oapi.InternalErrorJSONResponse{Message: "failed to start process"}}, nil
 	}
 
+	// Disable scale-to-zero while the process is running.
+	// Track success so we only re-enable if disable succeeded.
+	stzDisabled := false
+	if err := s.stz.Disable(ctx); err != nil {
+		log.Error("failed to disable scale-to-zero", "err", err)
+	} else {
+		stzDisabled = true
+	}
+
 	id := openapi_types.UUID(uuid.New())
 	h := &processHandle{
 		id:      id,
@@ -294,8 +303,10 @@ func (s *ApiService) ProcessSpawn(ctx context.Context, request oapi.ProcessSpawn
 		}
 	}()
 
-	// Waiter goroutine
-	go func() {
+	// Waiter goroutine - use context without cancel since HTTP request may complete
+	// before the process exits
+	stzCtx := context.WithoutCancel(ctx)
+	go func(stzWasDisabled bool) {
 		err := cmd.Wait()
 		code := 0
 		if err != nil {
@@ -310,6 +321,15 @@ func (s *ApiService) ProcessSpawn(ctx context.Context, request oapi.ProcessSpawn
 			}
 		}
 		h.setExited(code)
+
+		// Re-enable scale-to-zero now that the process has exited,
+		// but only if we successfully disabled it earlier
+		if stzWasDisabled {
+			if err := s.stz.Enable(stzCtx); err != nil {
+				log.Error("failed to enable scale-to-zero", "err", err)
+			}
+		}
+
 		// Send exit event
 		evt := oapi.ProcessStreamEventEvent("exit")
 		h.outCh <- oapi.ProcessStreamEvent{Event: &evt, ExitCode: &code}
@@ -325,7 +345,7 @@ func (s *ApiService) ProcessSpawn(ctx context.Context, request oapi.ProcessSpawn
 			delete(s.procs, procID)
 			s.procMu.Unlock()
 		}(id.String())
-	}()
+	}(stzDisabled)
 
 	startedAt := h.started
 	pid := h.pid

server/cmd/api/api/process_test.go

@@ -15,6 +15,7 @@ import (
 	"github.com/google/uuid"
 	openapi_types "github.com/oapi-codegen/runtime/types"
 	oapi "github.com/onkernel/kernel-images/server/lib/oapi"
+	"github.com/onkernel/kernel-images/server/lib/scaletozero"
 	"github.com/stretchr/testify/require"
 )
 
@@ -43,7 +44,7 @@ func TestProcessExec(t *testing.T) {
 func TestProcessSpawnStatusAndStream(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
-	svc := &ApiService{procs: make(map[string]*processHandle)}
+	svc := &ApiService{procs: make(map[string]*processHandle), stz: scaletozero.NewNoopController()}
 
 	// Spawn a short-lived process that emits stdout and stderr then exits
 	cmd := "sh"
@@ -111,7 +112,7 @@ func TestProcessSpawnStatusAndStream(t *testing.T) {
 func TestProcessStdinAndExit(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
-	svc := &ApiService{procs: make(map[string]*processHandle)}
+	svc := &ApiService{procs: make(map[string]*processHandle), stz: scaletozero.NewNoopController()}
 
 	// Spawn a process that reads exactly 3 bytes then exits
 	cmd := "sh"
@@ -150,7 +151,7 @@ func TestProcessStdinAndExit(t *testing.T) {
 func TestProcessKill(t *testing.T) {
 	t.Parallel()
 	ctx := context.Background()
-	svc := &ApiService{procs: make(map[string]*processHandle)}
+	svc := &ApiService{procs: make(map[string]*processHandle), stz: scaletozero.NewNoopController()}
 
 	cmd := "sh"
 	args := []string{"-c", "sleep 5"}