Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441const std = @import("std");const builtin = @import("builtin");const process_supervisor = @import("../background/process_supervisor.zig");
const Allocator = std.mem.Allocator;
pub const exit_marker = "__FX_EXIT_CODE__=";
pub fn isValidPidText(pid: []const u8) bool { if (pid.len == 0) return false; for (pid) |byte| { if (!std.ascii.isDigit(byte)) return false; } return true;}
pub const ProviderError = Allocator.Error || std.process.SpawnError || std.Io.File.ReadStreamingError || std.Io.File.Writer.Error || error{ Unsupported, SpawnFailed, BackgroundWrapperNotReady, BackgroundProcessIdentityIndeterminate, BackgroundProcessIdentityMismatch, BackgroundProcessIdentityUnavailable, BackgroundReleaseFailed, BackgroundLogUnavailable, ProcessIdentityUnavailable, ProcessIdentityUnsupported, ProcessNotFound, PermissionDenied, Unexpected, InvalidPid,};
pub const Isolation = union(enum) { none, macos_profile: []const u8,};
pub const OutputCapability = struct { /// Opaque, borrowed output authority supplied by the host composition. context: *const anyopaque,};
pub const SpawnRequest = struct { cwd: []const u8, output: OutputCapability, isolation: Isolation,};
pub const CleanupStatus = enum { confirmed, timed_out,};
pub const OwnedProcess = struct { context: *anyopaque, wait_fn: *const fn (*anyopaque) void, forget_fn: *const fn (*anyopaque) void,
/// Consumes the handle after the provider-owned child has exited. pub fn wait(self: *OwnedProcess) void { self.wait_fn(self.context); self.* = undefined; }
/// Consumes the handle without changing the child process lifecycle. pub fn forget(self: *OwnedProcess) void { self.forget_fn(self.context); self.* = undefined; }};
pub const PreparedProcess = struct { context: *anyopaque, /// Borrowed from `context` and valid until a consuming method succeeds. pid: []const u8, close_and_wait_fn: *const fn ( *anyopaque, ?process_supervisor.ProcessInstanceToken, i64, ) CleanupStatus, wait_for_exit_fn: *const fn ( *anyopaque, ?process_supervisor.ProcessInstanceToken, i64, ) bool, detach_reaper_fn: *const fn (*anyopaque) bool, release_fn: *const fn (*anyopaque, []const u8) ProviderError!OwnedProcess,
/// Consumes the handle only when cleanup is confirmed. pub fn closeAndWaitUnreleased( self: *PreparedProcess, process_token: ?process_supervisor.ProcessInstanceToken, timeout_ms: i64, ) CleanupStatus { const status = self.close_and_wait_fn( self.context, process_token, timeout_ms, ); if (status == .confirmed) self.* = undefined; return status; }
/// Consumes the handle only when process exit is confirmed. pub fn waitForUnreleasedExit( self: *PreparedProcess, process_token: ?process_supervisor.ProcessInstanceToken, timeout_ms: i64, ) bool { const exited = self.wait_for_exit_fn( self.context, process_token, timeout_ms, ); if (exited) self.* = undefined; return exited; }
/// Consumes the handle only when the provider retains cleanup ownership. pub fn detachUnreleasedReaper(self: *PreparedProcess) bool { const detached = self.detach_reaper_fn(self.context); if (detached) self.* = undefined; return detached; }
/// Releases the blocked command and consumes the prepared handle. pub fn release( self: *PreparedProcess, original_command: []const u8, ) ProviderError!OwnedProcess { const owned = try self.release_fn(self.context, original_command); self.* = undefined; return owned; }};
pub const Provider = struct { /// Provider implementations own `context`; callers borrow it. context: ?*anyopaque = null, spawn_prepared_fn: *const fn ( ?*anyopaque, Allocator, SpawnRequest, ) ProviderError!PreparedProcess, capture_token_fn: *const fn ( ?*anyopaque, Allocator, []const u8, ) ProviderError!process_supervisor.ProcessInstanceToken, match_token_fn: *const fn ( ?*anyopaque, Allocator, []const u8, process_supervisor.ProcessInstanceToken, ) process_supervisor.TokenMatch, signal_process_fn: *const fn ( ?*anyopaque, Allocator, []const u8, process_supervisor.ProcessInstanceToken, ) ProviderError!void,
pub fn spawnPrepared( self: Provider, alloc: Allocator, request: SpawnRequest, ) ProviderError!PreparedProcess { return self.spawn_prepared_fn( self.context, alloc, request, ); }
pub fn captureToken( self: Provider, alloc: Allocator, pid: []const u8, ) ProviderError!process_supervisor.ProcessInstanceToken { return self.capture_token_fn(self.context, alloc, pid); }
pub fn matchToken( self: Provider, alloc: Allocator, pid: []const u8, expected: process_supervisor.ProcessInstanceToken, ) process_supervisor.TokenMatch { return self.match_token_fn( self.context, alloc, pid, expected, ); }
pub fn signalProcess( self: Provider, alloc: Allocator, pid: []const u8, expected: process_supervisor.ProcessInstanceToken, ) ProviderError!void { return self.signal_process_fn( self.context, alloc, pid, expected, ); }};
fn unsupportedSpawnPrepared( _: ?*anyopaque, _: Allocator, _: SpawnRequest,) ProviderError!PreparedProcess { return error.Unsupported;}
fn unsupportedCaptureToken( _: ?*anyopaque, _: Allocator, _: []const u8,) ProviderError!process_supervisor.ProcessInstanceToken { return error.Unsupported;}
fn unavailableMatchToken( _: ?*anyopaque, _: Allocator, _: []const u8, _: process_supervisor.ProcessInstanceToken,) process_supervisor.TokenMatch { return .unavailable;}
fn captureTokenThroughProcessSupervisor( _: ?*anyopaque, alloc: Allocator, pid: []const u8,) ProviderError!process_supervisor.ProcessInstanceToken { return process_supervisor.captureProcessInstanceToken( alloc, pid, ) catch |err| switch (err) { error.OutOfMemory => error.OutOfMemory, error.InvalidPid => error.InvalidPid, error.ProcessNotFound => error.ProcessNotFound, error.ProcessIdentityUnavailable => error.ProcessIdentityUnavailable, else => error.ProcessIdentityUnsupported, };}
fn matchTokenThroughProcessSupervisor( _: ?*anyopaque, alloc: Allocator, pid: []const u8, expected: process_supervisor.ProcessInstanceToken,) process_supervisor.TokenMatch { return process_supervisor.matchProcessInstanceToken( alloc, pid, expected, );}
fn unsupportedSignalProcess( _: ?*anyopaque, _: Allocator, _: []const u8, _: process_supervisor.ProcessInstanceToken,) ProviderError!void { return error.Unsupported;}
pub const unavailable_provider = Provider{ .spawn_prepared_fn = unsupportedSpawnPrepared, .capture_token_fn = unsupportedCaptureToken, .match_token_fn = unavailableMatchToken, .signal_process_fn = unsupportedSignalProcess,};
pub const process_supervisor_test_provider = if (builtin.is_test) Provider{ .spawn_prepared_fn = unsupportedSpawnPrepared, .capture_token_fn = captureTokenThroughProcessSupervisor, .match_token_fn = matchTokenThroughProcessSupervisor, .signal_process_fn = unsupportedSignalProcess, }else unavailable_provider;
test "unavailable provider does not consult process supervisor test hooks" { const Stub = struct { var calls: usize = 0;
fn capture( _: Allocator, _: []const u8, ) anyerror!process_supervisor.ProcessInstanceToken { calls += 1; return error.ProcessNotFound; } }; Stub.calls = 0; process_supervisor.process_token_capture_for_test = Stub.capture; defer process_supervisor.process_token_capture_for_test = null;
try std.testing.expectError( error.Unsupported, unavailable_provider.captureToken(std.testing.allocator, "123"), ); try std.testing.expectEqual(@as(usize, 0), Stub.calls);}
test "provider routes lifecycle operations through one injected owner" { const Fake = struct { spawns: usize = 0, releases: usize = 0, waits: usize = 0,
fn spawn( raw: ?*anyopaque, _: Allocator, request: SpawnRequest, ) ProviderError!PreparedProcess { const self: *@This() = @ptrCast(@alignCast(raw.?)); if (!std.mem.eql(u8, request.cwd, "/workspace") or request.isolation != .none) { return error.SpawnFailed; } if (request.output.context != @as(*const anyopaque, @ptrCast(self))) { return error.SpawnFailed; } self.spawns += 1; return .{ .context = self, .pid = "42", .close_and_wait_fn = close, .wait_for_exit_fn = waitForExit, .detach_reaper_fn = detach, .release_fn = release, }; }
fn release(raw: *anyopaque, command: []const u8) ProviderError!OwnedProcess { const self: *@This() = @ptrCast(@alignCast(raw)); if (!std.mem.eql(u8, "npm run dev", command)) { return error.BackgroundReleaseFailed; } self.releases += 1; return .{ .context = raw, .wait_fn = wait, .forget_fn = forget, }; }
fn wait(raw: *anyopaque) void { const self: *@This() = @ptrCast(@alignCast(raw)); self.waits += 1; }
fn forget(_: *anyopaque) void {}
fn close( _: *anyopaque, _: ?process_supervisor.ProcessInstanceToken, _: i64, ) CleanupStatus { return .timed_out; }
fn waitForExit( _: *anyopaque, _: ?process_supervisor.ProcessInstanceToken, _: i64, ) bool { return false; }
fn detach(_: *anyopaque) bool { return false; } };
var fake = Fake{}; var provider = unavailable_provider; provider.context = &fake; provider.spawn_prepared_fn = Fake.spawn; var prepared = try provider.spawnPrepared(std.testing.allocator, .{ .cwd = "/workspace", .output = .{ .context = &fake }, .isolation = .none, }); try std.testing.expectEqualStrings("42", prepared.pid); var owned = try prepared.release("npm run dev"); owned.wait();
try std.testing.expectEqual(@as(usize, 1), fake.spawns); try std.testing.expectEqual(@as(usize, 1), fake.releases); try std.testing.expectEqual(@as(usize, 1), fake.waits);}
test "provider preserves macos isolation as typed request data" { const Fake = struct { fn spawn( _: ?*anyopaque, _: Allocator, request: SpawnRequest, ) ProviderError!PreparedProcess { switch (request.isolation) { .macos_profile => |path| if (!std.mem.eql( u8, path, "/private/tmp/fx.sb", )) return error.SpawnFailed, .none => return error.Unsupported, } return error.Unsupported; } };
var provider = unavailable_provider; provider.spawn_prepared_fn = Fake.spawn; var output_marker: u8 = 0; try std.testing.expectError(error.Unsupported, provider.spawnPrepared( std.testing.allocator, .{ .cwd = "/workspace", .output = .{ .context = &output_marker }, .isolation = .{ .macos_profile = "/private/tmp/fx.sb" }, }, ));}