Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679const std = @import("std");const builtin = @import("builtin");const contracts = @import("contracts.zig");const protocol = @import("protocol.zig");const terminal_operation = @import("operation.zig");const policy = @import("host_policy.zig");const native_session = @import("native_session.zig");const terminal_store = @import("store.zig");const host_capabilities = @import("../hosts/host.zig");const io_mod = @import("../shared/io.zig");const profile_paths = @import("../shared/profile_paths.zig");const debug_trace = @import("../shared/debug_trace.zig");const background_process_provider = @import( "../execution/background_process_provider.zig",);const process_supervisor = @import("../background/process_supervisor.zig");
const Allocator = std.mem.Allocator;
pub const internal_mode = "--fx-internal-terminal-host";pub const endpoint_name = "host.sock";pub const lock_name = "host.lock";const identity_name = "host.json";const host_dir_name = "terminal-host";const default_idle_grace_ms: u64 = 30_000;const identity_max_bytes: usize = 1024;const max_connection_requests: usize = 32;const listener_poll_ms = 50;const transport_hash_bytes: usize = 16;const transport_hash_context = "fx.terminal.transport.v1\x00";const socket_permissions: std.Io.File.Permissions = switch (builtin.os.tag) { .macos, .linux => .fromMode(0o600), else => .default_file,};
pub fn isSupported() bool { return isSupportedForOs(builtin.os.tag);}
fn isSupportedForOs(os_tag: std.Target.Os.Tag) bool { return host_capabilities.terminalSupportForOs(os_tag).isSupported();}
pub fn isInternalModeRaw(raw_args: []const [*:0]const u8) bool { return raw_args.len == 2 and std.mem.eql(u8, std.mem.sliceTo(raw_args[1], 0), internal_mode);}
pub fn validateEndpointPath(path: []const u8) !void { return validateEndpointPathForTarget(builtin.os.tag, path);}
fn nativeEndpointPathLimit(target: std.Target.Os.Tag) ?usize { return switch (target) { .macos => 104, .linux => 108, else => null, };}
fn runtimeBase(target: std.Target.Os.Tag) ?[]const u8 { return switch (target) { .macos => "/private/tmp", .linux => "/tmp", else => null, };}
fn validateEndpointPathForTarget( target: std.Target.Os.Tag, path: []const u8,) !void { const limit = nativeEndpointPathLimit(target) orelse return error.TerminalHostUnsupported; if (path.len >= limit) return error.NameTooLong;}
const EndpointSelection = struct { authority_root: []u8, transport_root: []u8, endpoint_path: []u8, uses_fallback: bool,
fn deinit(self: *EndpointSelection, alloc: Allocator) void { alloc.free(self.endpoint_path); alloc.free(self.transport_root); alloc.free(self.authority_root); self.* = undefined; }};
fn resolveEndpointSelection( alloc: Allocator, target: std.Target.Os.Tag, home: []const u8, uid: std.c.uid_t,) !EndpointSelection { const runtime_base = runtimeBase(target) orelse return error.TerminalHostUnsupported; const authority_root = try std.fs.path.join( alloc, &.{ home, profile_paths.root_dir_name, host_dir_name }, ); errdefer alloc.free(authority_root); const profile_endpoint = try std.fs.path.join( alloc, &.{ authority_root, endpoint_name }, ); if (validateEndpointPathForTarget(target, profile_endpoint)) { errdefer alloc.free(profile_endpoint); const transport_root = try alloc.dupe(u8, authority_root); return .{ .authority_root = authority_root, .transport_root = transport_root, .endpoint_path = profile_endpoint, .uses_fallback = false, }; } else |err| switch (err) { error.NameTooLong => alloc.free(profile_endpoint), else => { alloc.free(profile_endpoint); return err; }, }
var hasher = std.crypto.hash.sha2.Sha256.init(.{}); hasher.update(transport_hash_context); hasher.update(home); var digest: [std.crypto.hash.sha2.Sha256.digest_length]u8 = undefined; hasher.final(&digest); const digest_hex = std.fmt.bytesToHex( digest[0..transport_hash_bytes].*, .lower, ); const runtime_name = try std.fmt.allocPrint( alloc, "fx-terminal-{d}-{s}", .{ uid, digest_hex }, ); defer alloc.free(runtime_name); const transport_root = try std.fs.path.join( alloc, &.{ runtime_base, runtime_name }, ); errdefer alloc.free(transport_root); const endpoint_path = try std.fs.path.join( alloc, &.{ transport_root, endpoint_name }, ); errdefer alloc.free(endpoint_path); try validateEndpointPathForTarget(target, endpoint_path); return .{ .authority_root = authority_root, .transport_root = transport_root, .endpoint_path = endpoint_path, .uses_fallback = true, };}
pub const Config = struct { process_provider: background_process_provider.Provider = background_process_provider.unavailable_provider, hello: contracts.ProtocolHello = .{ .range = contracts.local_protocol_range, .capabilities = contracts.known_protocol_capabilities, }, idle_grace_ms: u64 = default_idle_grace_ms,
pub fn fromEnvironment( process_provider: background_process_provider.Provider, ) !Config { var config: Config = .{ .process_provider = process_provider }; if (io_mod.getenv("FX_TERMINAL_HOST_PROTOCOL_MIN")) |value| { config.hello.range.minimum = try std.fmt.parseInt(u16, value, 10); } if (io_mod.getenv("FX_TERMINAL_HOST_PROTOCOL_CURRENT")) |value| { config.hello.range.current = try std.fmt.parseInt(u16, value, 10); } if (io_mod.getenv("FX_TERMINAL_HOST_PROTOCOL_CAPABILITIES")) |value| { config.hello.capabilities = try std.fmt.parseInt(u64, value, 10); } if (io_mod.getenv("FX_TERMINAL_HOST_IDLE_MS")) |value| { config.idle_grace_ms = try std.fmt.parseInt(u64, value, 10); } try config.hello.validate(); if (config.idle_grace_ms == 0) return error.InvalidIdleGrace; return config; }};
pub const Paths = struct { home_dir: io_mod.VerifiedDir, fx_dir: io_mod.VerifiedDir, host_dir: io_mod.VerifiedDir, transport_dir: ?io_mod.VerifiedDir, authority_root_path: []u8, transport_root_path: []u8, endpoint_path: []u8,
pub fn open(alloc: Allocator, home: []const u8) !Paths { if (!isSupported()) return error.TerminalHostUnsupported; var selection = try resolveEndpointSelection( alloc, builtin.os.tag, home, std.c.getuid(), ); var selection_owned = true; errdefer if (selection_owned) selection.deinit(alloc); var home_dir = io_mod.VerifiedDir{ .dir = try std.Io.Dir.openDirAbsolute(io_mod.getIo(), home, .{ .iterate = true, .follow_symlinks = false, }), }; errdefer home_dir.close(); var fx_dir = try io_mod.openOrCreateVerifiedPrivateDir( &home_dir, profile_paths.root_dir_name, ); errdefer fx_dir.close(); var host_dir = try io_mod.openOrCreateVerifiedPrivateDir( &fx_dir, host_dir_name, ); errdefer host_dir.close(); var transport_dir: ?io_mod.VerifiedDir = null; errdefer if (transport_dir) |*dir| dir.close(); if (selection.uses_fallback) { transport_dir = try openRuntimeTransportDir( selection.transport_root, std.c.getuid(), ); } selection_owned = false; return .{ .home_dir = home_dir, .fx_dir = fx_dir, .host_dir = host_dir, .transport_dir = transport_dir, .authority_root_path = selection.authority_root, .transport_root_path = selection.transport_root, .endpoint_path = selection.endpoint_path, }; }
pub fn endpointDir(self: *Paths) *io_mod.VerifiedDir { if (self.transport_dir) |*dir| return dir; return &self.host_dir; }
pub fn deinit(self: *Paths, alloc: Allocator) void { alloc.free(self.endpoint_path); alloc.free(self.transport_root_path); alloc.free(self.authority_root_path); if (self.transport_dir) |*dir| dir.close(); self.host_dir.close(); self.fx_dir.close(); self.home_dir.close(); self.* = undefined; }};
fn openRuntimeTransportDir( transport_root: []const u8, uid: std.c.uid_t,) !io_mod.VerifiedDir { const parent_path = std.fs.path.dirname(transport_root) orelse return error.RuntimeDirectoryUnsafe; const name = std.fs.path.basename(transport_root); var parent = try std.Io.Dir.openDirAbsolute(io_mod.getIo(), parent_path, .{ .iterate = true, .follow_symlinks = false, }); defer parent.close(io_mod.getIo()); return openVerifiedPrivateRuntimeDir(parent, name, uid);}
fn openVerifiedPrivateRuntimeDir( parent: std.Io.Dir, name: []const u8, uid: std.c.uid_t,) !io_mod.VerifiedDir { const zio = io_mod.getIo(); var dir = parent.openDir(zio, name, .{ .iterate = true, .follow_symlinks = false, }) catch |err| switch (err) { error.FileNotFound => blk: { parent.createDir( zio, name, std.Io.File.Permissions.fromMode(0o700), ) catch |create_err| switch (create_err) { error.PathAlreadyExists => {}, else => return create_err, }; break :blk parent.openDir(zio, name, .{ .iterate = true, .follow_symlinks = false, }) catch |open_err| switch (open_err) { error.SymLinkLoop, error.NotDir => return error.RuntimeDirectoryUnsafe, else => return open_err, }; }, error.SymLinkLoop, error.NotDir => return error.RuntimeDirectoryUnsafe, else => return err, }; errdefer dir.close(zio); try verifyPrivateRuntimeDir(dir, uid); return .{ .dir = dir };}
fn verifyPrivateRuntimeDir(dir: std.Io.Dir, uid: std.c.uid_t) !void { const stat = try dir.stat(io_mod.getIo()); const owner_uid = try directoryOwner(dir); try validatePrivateRuntimeDir(stat, owner_uid, uid);}
fn directoryOwner(dir: std.Io.Dir) !std.c.uid_t { return switch (builtin.os.tag) { .linux => blk: { const linux = std.os.linux; while (true) { var stat = std.mem.zeroes(linux.Statx); switch (linux.errno(linux.statx( dir.handle, "", linux.AT.EMPTY_PATH, .{ .UID = true }, &stat, ))) { .SUCCESS => { if (!stat.mask.UID) { return error.RuntimeDirectoryOwnershipUnavailable; } break :blk stat.uid; }, .INTR => {}, else => return error.RuntimeDirectoryOwnershipUnavailable, } } }, .macos => blk: { while (true) { var stat = std.mem.zeroes(std.c.Stat); switch (std.c.errno(std.c.fstat(dir.handle, &stat))) { .SUCCESS => break :blk stat.uid, .INTR => {}, else => return error.RuntimeDirectoryOwnershipUnavailable, } } }, else => error.TerminalHostUnsupported, };}
fn validatePrivateRuntimeDir( stat: std.Io.File.Stat, owner_uid: std.c.uid_t, uid: std.c.uid_t,) !void { if (stat.kind != .directory) return error.RuntimeDirectoryUnsafe; if (owner_uid != uid) return error.RuntimeDirectoryOwnerMismatch; if (stat.permissions.toMode() & 0o777 != 0o700) { return error.PrivateStatePermissionsUnsupported; }}
const IdentityRecord = struct { pid: []const u8, process_token: []const u8, instance: []const u8, protocol_minimum: u16, protocol_current: u16,};
pub fn run(alloc: Allocator, config: Config) !void { if (comptime !isSupported()) return error.TerminalHostUnsupported; return runSupported(alloc, config);}
fn runSupported(alloc: Allocator, config: Config) !void { const home = io_mod.getenv("HOME") orelse return error.HomeNotSet; var paths = try Paths.open(alloc, home); defer paths.deinit(alloc);
var authority_lock = io_mod.acquireTimedAdvisoryLock( &paths.host_dir, lock_name, 0, ) catch |err| switch (err) { error.LockBusy => return, else => return err, }; defer authority_lock.release();
const identity_evidence = identityEvidence( alloc, config.process_provider, &paths.host_dir, ); if (identity_evidence == .live or identity_evidence == .unverifiable) { return error.HostIdentityConflict; } cleanupEndpoint(paths.endpointDir()); cleanupIdentity(&paths.host_dir);
const address = try std.Io.net.UnixAddress.init(paths.endpoint_path); var server = try address.listen(io_mod.getIo(), .{}); defer server.deinit(io_mod.getIo()); var endpoint_created = true; defer if (endpoint_created) cleanupEndpoint(paths.endpointDir()); try paths.endpointDir().dir.setFilePermissions( io_mod.getIo(), endpoint_name, socket_permissions, .{ .follow_symlinks = false }, ); try verifyEndpointPermissions(paths.endpointDir());
var instance_bytes: [16]u8 = undefined; io_mod.getIo().random(&instance_bytes); const host_instance = std.fmt.bytesToHex(instance_bytes, .lower); try writeIdentity( alloc, config.process_provider, &paths.host_dir, config.hello.range, &host_instance, ); var identity_created = true; defer if (identity_created) cleanupIdentity(&paths.host_dir);
var state = HostState{ .idle_grace_ms = config.idle_grace_ms, }; var persistent_store = try terminal_store.ProfileStore.init( alloc, home, config.process_provider, ); defer persistent_store.deinit(); var registry = try native_session.Registry.init(alloc, .{ .context = &state, .update_fn = updateLiveWork, .monitor_update_fn = updateMonitorWork, }, &persistent_store, &host_instance, paths.authority_root_path, paths.transport_root_path); defer registry.deinit(); var idle_thread = try std.Thread.spawn(.{}, idleOwner, .{&state}); defer { state.stopping.store(true, .release); state.changed.set(io_mod.getIo()); idle_thread.join(); }
debug_trace.logf( "terminal_host", "host listening pid={d} protocol={d}-{d}", .{ std.c.getpid(), config.hello.range.minimum, config.hello.range.current }, );
while (!state.stopping.load(.acquire)) { if (!try listenerReady(server.socket.handle)) continue; if (state.stopping.load(.acquire)) break; var stream = server.accept(io_mod.getIo()) catch |err| switch (err) { error.SocketNotListening => break, else => return err, }; if (state.stopping.load(.acquire)) { stream.close(io_mod.getIo()); break; } _ = state.connected_clients.fetchAdd(1, .acq_rel); state.noteChanged(); var thread = std.Thread.spawn(.{}, clientMain, .{ alloc, stream, config.process_provider, config.hello, &state, ®istry, }) catch |err| { stream.close(io_mod.getIo()); _ = state.connected_clients.fetchSub(1, .acq_rel); state.noteChanged(); return err; }; thread.detach(); }
debug_trace.logf("terminal_host", "host retiring idle=true", .{}); maybeDelayForTest("FX_TERMINAL_TEST_IDLE_EXIT_DELAY_MS"); identity_created = false; cleanupIdentity(&paths.host_dir); endpoint_created = false; cleanupEndpoint(paths.endpointDir()); debug_trace.logf("terminal_host", "host exited idle=true", .{});}
const HostState = struct { idle_grace_ms: u64, connected_clients: std.atomic.Value(usize) = .init(0), pending_requests: std.atomic.Value(usize) = .init(0), live_work: std.atomic.Value(usize) = .init(0), monitor_required: std.atomic.Value(usize) = .init(0), generation: std.atomic.Value(u64) = .init(0), stopping: std.atomic.Value(bool) = .init(false), changed: std.Io.Event = .unset, ordered_mutex: std.Io.Mutex = .init, ordered_changed: std.Io.Condition = .init, next_ordered_ticket: u64 = 0, serving_ordered_ticket: u64 = 0,
fn facts(self: *const HostState) policy.IdleFacts { return .{ .connected_clients = self.connected_clients.load(.acquire), .pending_requests = self.pending_requests.load(.acquire), .live_work = self.live_work.load(.acquire), .monitor_required = self.monitor_required.load(.acquire) != 0, }; }
fn noteChanged(self: *HostState) void { _ = self.generation.fetchAdd(1, .acq_rel); self.changed.set(io_mod.getIo()); }
fn issueOrderedMutation(self: *HostState) u64 { const zio = io_mod.getIo(); self.ordered_mutex.lockUncancelable(zio); defer self.ordered_mutex.unlock(zio); const ticket = self.next_ordered_ticket; self.next_ordered_ticket += 1; return ticket; }
fn awaitOrderedMutation(self: *HostState, ticket: u64) void { const zio = io_mod.getIo(); self.ordered_mutex.lockUncancelable(zio); while (self.serving_ordered_ticket != ticket) { self.ordered_changed.waitUncancelable(zio, &self.ordered_mutex); } self.ordered_mutex.unlock(zio); }
fn completeOrderedMutation(self: *HostState, ticket: u64) void { const zio = io_mod.getIo(); self.ordered_mutex.lockUncancelable(zio); std.debug.assert(self.serving_ordered_ticket == ticket); self.serving_ordered_ticket += 1; self.ordered_changed.broadcast(zio); self.ordered_mutex.unlock(zio); }
fn abandonOrderedMutation(self: *HostState, ticket: u64) void { self.awaitOrderedMutation(ticket); self.completeOrderedMutation(ticket); }};
fn updateLiveWork(raw: ?*anyopaque, live: bool) void { const state: *HostState = @ptrCast(@alignCast(raw.?)); if (live) { _ = state.live_work.fetchAdd(1, .acq_rel); } else { const previous = state.live_work.fetchSub(1, .acq_rel); std.debug.assert(previous > 0); } state.noteChanged();}
fn updateMonitorWork(raw: ?*anyopaque, required: bool) void { const state: *HostState = @ptrCast(@alignCast(raw.?)); if (required) { _ = state.monitor_required.fetchAdd(1, .acq_rel); } else { const previous = state.monitor_required.fetchSub(1, .acq_rel); std.debug.assert(previous > 0); } state.noteChanged();}
fn idleOwner(state: *HostState) void { const timeout_ns = std.math.mul(u64, state.idle_grace_ms, std.time.ns_per_ms) catch std.math.maxInt(u64); while (!state.stopping.load(.acquire)) { const generation = state.generation.load(.acquire); state.changed.reset(); if (state.generation.load(.acquire) != generation) continue; if (!policy.idleEligible(state.facts())) { state.changed.waitUncancelable(io_mod.getIo()); continue; } state.changed.waitTimeout( io_mod.getIo(), .{ .duration = .{ .clock = .awake, .raw = .{ .nanoseconds = @intCast(@min( timeout_ns, std.math.maxInt(i64), )) }, } }, ) catch |err| switch (err) { error.Timeout => { if (state.generation.load(.acquire) != generation) continue; if (!policy.idleEligible(state.facts())) continue; state.stopping.store(true, .release); return; }, error.Canceled => return, }; }}
fn listenerReady(handle: std.Io.net.Socket.Handle) !bool { var poll_fds = [_]std.posix.pollfd{.{ .fd = handle, .events = std.posix.POLL.IN, .revents = 0, }}; if (try std.posix.poll(&poll_fds, listener_poll_ms) == 0) return false; if ((poll_fds[0].revents & std.posix.POLL.IN) != 0) return true; return error.SocketNotListening;}
fn clientMain( alloc: Allocator, stream: std.Io.net.Stream, process_provider: background_process_provider.Provider, host_hello: contracts.ProtocolHello, state: *HostState, registry: *native_session.Registry,) void { defer { _ = state.connected_clients.fetchSub(1, .acq_rel); state.noteChanged(); } handleClient( alloc, stream, process_provider, host_hello, state, registry, ) catch |err| { debug_trace.logf( "terminal_host", "client disconnected err={s}", .{@errorName(err)}, ); };}
fn handleClient( alloc: Allocator, stream: std.Io.net.Stream, process_provider: background_process_provider.Provider, host_hello: contracts.ProtocolHello, state: *HostState, registry: *native_session.Registry,) !void { defer stream.close(io_mod.getIo()); if (!peerMatchesCurrentUser(stream.socket.handle)) { return error.ForeignTerminalHostPeer; } const peer_process_owner = try peerProcessOwner( alloc, process_provider, stream.socket.handle, ); applySocketTimeout(stream); var read_buffer: [4096]u8 = undefined; var reader = stream.reader(io_mod.getIo(), &read_buffer); var write_buffer: [4096]u8 = undefined; var writer = stream.writer(io_mod.getIo(), &write_buffer);
var client_frame = try protocol.readFrame(alloc, &reader.interface); defer client_frame.deinit(); const client_message = client_frame.message(); const client_hello = switch (client_message.payload) { .hello => |hello| hello, else => return error.HandshakeRequired, }; const negotiation = try contracts.negotiate_protocol(client_hello, host_hello); const reply_revision = switch (negotiation) { .compatible => |compatible| compatible.revision, .incompatible => @min( contracts.current_protocol_revision, client_message.envelope.revision, ), }; var hello_frame = try protocol.encodeFrame( alloc, reply_revision, 0, null, .{ .hello = host_hello }, ); defer hello_frame.deinit(alloc); try protocol.writeFrame(&writer.interface, hello_frame);
const negotiated = switch (negotiation) { .compatible => |compatible| compatible, .incompatible => return, };
var connection = Connection{ .alloc = alloc, .stream = stream, .revision = negotiated.revision, .capabilities = negotiated.capabilities, .state = state, .registry = registry, .peer_process_owner = peer_process_owner, }; defer connection.finish(); var seen: policy.PendingRequests = .{}; while (!state.stopping.load(.acquire)) { var frame = protocol.readFrame(alloc, &reader.interface) catch |err| switch (err) { error.TruncatedFrame, error.EndOfStream => return, else => return err, }; defer frame.deinit(); const message = frame.message(); if (message.envelope.revision != negotiated.revision) { return error.ProtocolRevisionChanged; } switch (message.payload) { .request => |request| { const correlation_id = message.envelope.correlation_id.?; try seen.add(correlation_id); const authority_capability = contracts.protocol_capability_authority_generations; const tmux_recovery_capability = contracts.protocol_capability_tmux_recovery; const rejection: ?contracts.StructuredErrorCode = if (message.envelope.required_capabilities & authority_capability == 0) .protocol_incompatible else if (message.envelope.required_capabilities & ~negotiated.capabilities != 0) .unsupported_host else if (request == .start and request.start.backend == .tmux and negotiated.capabilities & tmux_recovery_capability == 0) .protocol_incompatible else null; try connection.start( correlation_id, request, rejection, ); }, .cancel => { const correlation_id = message.envelope.correlation_id.?; connection.cancel(correlation_id); }, .hello, .response => return error.InvalidClientMessage, } }}
const Connection = struct { alloc: Allocator, stream: std.Io.net.Stream, revision: u16, capabilities: u64, state: *HostState, registry: *native_session.Registry, peer_process_owner: contracts.ProcessOwner, mutex: std.Io.Mutex = .init, done: std.Io.Condition = .init, writer_mutex: std.Io.Mutex = .init, tasks: [max_connection_requests]?*RequestTask = @splat(null), active: usize = 0,
fn start( self: *Connection, correlation_id: contracts.CorrelationId, request: contracts.ActionRequest, rejection: ?contracts.StructuredErrorCode, ) !void { if (testRequestFailureRequested("task_allocation", correlation_id)) { return error.OutOfMemory; } const task = try self.alloc.create(RequestTask); var owned_request = contracts.OwnedActionRequest.init( self.alloc, request, ) catch |err| { self.alloc.destroy(task); return err; }; terminal_operation.attachProcessOwner( &owned_request.value, self.peer_process_owner, ); task.* = .{ .connection = self, .correlation_id = correlation_id, .request = owned_request, .rejection = rejection, };
const zio = io_mod.getIo(); self.mutex.lockUncancelable(zio); const slot = for (&self.tasks, 0..) |*entry, index| { if (entry.* == null) break index; } else { self.mutex.unlock(zio); task.request.deinit(self.alloc); self.alloc.destroy(task); return error.CapacityExceeded; }; self.tasks[slot] = task; task.slot = slot; if (terminal_operation.requiresOrderedMutation(task.request.value)) { task.ordered_ticket = self.state.issueOrderedMutation(); } self.active += 1; _ = self.state.pending_requests.fetchAdd(1, .acq_rel); self.state.noteChanged(); self.mutex.unlock(zio);
if (testRequestFailureRequested("worker_start", correlation_id)) { if (task.ordered_ticket) |ticket| { self.state.abandonOrderedMutation(ticket); } self.complete(task); task.request.deinit(self.alloc); self.alloc.destroy(task); return error.ThreadQuotaExceeded; } var thread = std.Thread.spawn(.{}, RequestTask.run, .{task}) catch |err| { if (task.ordered_ticket) |ticket| { self.state.abandonOrderedMutation(ticket); } self.complete(task); task.request.deinit(self.alloc); self.alloc.destroy(task); return err; }; thread.detach(); }
fn cancel( self: *Connection, correlation_id: contracts.CorrelationId, ) void { const zio = io_mod.getIo(); self.mutex.lockUncancelable(zio); defer self.mutex.unlock(zio); for (self.tasks) |entry| { const task = entry orelse continue; if (task.correlation_id.value == correlation_id.value) { task.cancelled.store(true, .release); return; } } }
fn finish(self: *Connection) void { const zio = io_mod.getIo(); self.mutex.lockUncancelable(zio); for (self.tasks) |entry| { const task = entry orelse continue; task.cancelled.store(true, .release); } while (self.active != 0) { self.done.waitUncancelable(zio, &self.mutex); } self.mutex.unlock(zio); }
fn complete(self: *Connection, task: *RequestTask) void { const zio = io_mod.getIo(); self.mutex.lockUncancelable(zio); std.debug.assert(self.tasks[task.slot] == task); self.tasks[task.slot] = null; self.active -= 1; _ = self.state.pending_requests.fetchSub(1, .acq_rel); self.state.noteChanged(); self.done.broadcast(zio); self.mutex.unlock(zio); }
fn fail(self: *Connection) void { self.stream.shutdown(io_mod.getIo(), .both) catch {}; }
fn send( self: *Connection, correlation_id: contracts.CorrelationId, result: contracts.Result, ) !void { if (testRequestFailureRequested("response_encoding", correlation_id)) { return error.OutOfMemory; } const compatible_result = protocol.projectResultForCapabilities( result, self.capabilities, ); var frame = try protocol.encodeFrame( self.alloc, self.revision, 0, correlation_id, .{ .response = compatible_result }, ); defer frame.deinit(self.alloc); const zio = io_mod.getIo(); self.writer_mutex.lockUncancelable(zio); defer self.writer_mutex.unlock(zio); var write_buffer: [4096]u8 = undefined; var writer = self.stream.writer(zio, &write_buffer); if (testRequestFailureRequested("response_write", correlation_id)) { return error.WriteFailed; } try protocol.writeFrame(&writer.interface, frame); }};
const RequestTask = struct { connection: *Connection, correlation_id: contracts.CorrelationId, request: contracts.OwnedActionRequest, rejection: ?contracts.StructuredErrorCode, slot: usize = 0, ordered_ticket: ?u64 = null, cancelled: std.atomic.Value(bool) = .init(false),
fn run(self: *RequestTask) void { var response_sent = false; var cancellation_persisted = false; defer { self.connection.complete(self); self.request.deinit(self.connection.alloc); self.connection.alloc.destroy(self); } defer if (self.ordered_ticket) |ticket| { self.connection.state.completeOrderedMutation(ticket); }; if (self.ordered_ticket) |ticket| { noteTestOrderedAdmission(self.correlation_id) catch { self.connection.state.awaitOrderedMutation(ticket); self.connection.fail(); return; }; self.connection.state.awaitOrderedMutation(ticket); awaitTestOrderedBoundary(self.correlation_id, &self.cancelled) catch { self.connection.fail(); return; }; } defer if (!response_sent and !cancellation_persisted and self.rejection == null and self.cancelled.load(.acquire)) { self.persistCancellation() catch |err| { self.logCancellationFailure(err); self.connection.fail(); }; }; if (self.cancelled.load(.acquire)) return; if (testRequestFailureRequested("result_allocation", self.correlation_id)) { self.connection.fail(); return; } var result = if (self.rejection) |code| contracts.OwnedResult.init( self.connection.alloc, .{ .failure = .{ .action = self.request.value.action(), .code = code, } }, ) catch { self.connection.fail(); return; } else self.execute() catch |err| switch (err) { error.MissingTerminalAuthority, error.InvalidAuthorityClaim, error.InvalidAuthorityGeneration, error.InvalidPrincipal, => contracts.OwnedResult.init( self.connection.alloc, .{ .failure = .{ .action = self.request.value.action(), .code = .authority_denied, } }, ) catch { self.connection.fail(); return; }, else => { debug_trace.logf( "terminal_host", "request execution failed action={s} err={s}", .{ @tagName(self.request.value.action()), @errorName(err), }, ); self.connection.fail(); return; }, }; if (self.rejection == null and self.cancelled.load(.acquire)) { cancellation_persisted = true; self.persistCancellation() catch |err| { self.logCancellationFailure(err); result.deinit(self.connection.alloc); result = contracts.OwnedResult.init( self.connection.alloc, .{ .failure = .{ .action = self.request.value.action(), .code = .invalid_request, .session_id = terminal_operation.authoritySessionId( self.request.value, ), } }, ) catch { self.connection.fail(); return; }; }; } defer result.deinit(self.connection.alloc); self.connection.send(self.correlation_id, result.view()) catch |err| { debug_trace.logf( "terminal_host", "response failed correlation={d} err={s}", .{ self.correlation_id.value, @errorName(err) }, ); self.connection.fail(); return; }; response_sent = true; }
fn execute(self: *RequestTask) !contracts.OwnedResult { if (testRequestFailureRequested("operation_execution", self.correlation_id)) { return error.RequestExecutionFailed; } return terminal_operation.execute( self.connection.registry, self.request.value, &self.cancelled, ); }
fn persistCancellation(self: *RequestTask) !void { const request = self.request.value; const claim = terminal_operation.claim(request) orelse return; const session_id = terminal_operation.authoritySessionId(request) orelse return; try self.connection.registry.cancelAuthorized(session_id, claim); }
fn logCancellationFailure(self: *RequestTask, err: anyerror) void { const session_id = terminal_operation.authoritySessionId( self.request.value, ) orelse "none"; debug_trace.logf( "terminal_host", "cancellation persistence failed correlation={d} session={s} err={s}", .{ self.correlation_id.value, session_id, @errorName(err) }, ); }};
fn testRequestFailureRequested( point: []const u8, correlation_id: contracts.CorrelationId,) bool { const requested_point = io_mod.getenv("FX_TERMINAL_TEST_HOST_FAILURE_POINT") orelse return false; if (!std.mem.eql(u8, requested_point, point)) return false; const requested_correlation = io_mod.getenv( "FX_TERMINAL_TEST_HOST_FAILURE_CORRELATION", ) orelse return false; const value = std.fmt.parseInt(u64, requested_correlation, 10) catch return false; return value == correlation_id.value;}
fn maybeDelayForTest(name: []const u8) void { const value = io_mod.getenv(name) orelse return; const delay_ms = std.fmt.parseInt(u64, value, 10) catch return; const delay_ns = std.math.mul( u64, @min(delay_ms, 5_000), std.time.ns_per_ms, ) catch return; io_mod.sleep(delay_ns);}
fn noteTestOrderedAdmission(correlation_id: contracts.CorrelationId) !void { const prefix = io_mod.getenv("FX_TERMINAL_TEST_ORDER_BARRIER") orelse return; var path_buffer: [4096]u8 = undefined; const path = try std.fmt.bufPrint( &path_buffer, "{s}.{d}.admitted", .{ prefix, correlation_id.value }, ); var file = try std.Io.Dir.createFileAbsolute(io_mod.getIo(), path, .{}); file.close(io_mod.getIo());}
fn awaitTestOrderedBoundary( correlation_id: contracts.CorrelationId, cancelled: *const std.atomic.Value(bool),) !void { const prefix = io_mod.getenv("FX_TERMINAL_TEST_ORDER_BARRIER") orelse return; const first_target = testCorrelationFromEnvironment( "FX_TERMINAL_TEST_ORDER_HOLD_CORRELATION", ); const second_target = testCorrelationFromEnvironment( "FX_TERMINAL_TEST_ORDER_HOLD_CORRELATION_2", ); if ((first_target == null or first_target.? != correlation_id.value) and (second_target == null or second_target.? != correlation_id.value)) { return; }
var ready_buffer: [4096]u8 = undefined; const ready_path = try std.fmt.bufPrint( &ready_buffer, "{s}.{d}.ready", .{ prefix, correlation_id.value }, ); var ready = try std.Io.Dir.createFileAbsolute( io_mod.getIo(), ready_path, .{}, ); ready.close(io_mod.getIo());
var release_buffer: [4096]u8 = undefined; const release_path = try std.fmt.bufPrint( &release_buffer, "{s}.{d}.release", .{ prefix, correlation_id.value }, ); while (!cancelled.load(.acquire)) { std.Io.Dir.accessAbsolute(io_mod.getIo(), release_path, .{}) catch |err| switch (err) { error.FileNotFound => { io_mod.sleep(std.time.ns_per_ms); continue; }, else => return err, }; return; }}
fn testCorrelationFromEnvironment(name: []const u8) ?u64 { const text = io_mod.getenv(name) orelse return null; return std.fmt.parseInt(u64, text, 10) catch null;}
fn applySocketTimeout(stream: std.Io.net.Stream) void { if (comptime !isSupported()) return; const timeout = std.posix.timeval{ .sec = 5, .usec = 0 }; std.posix.setsockopt( stream.socket.handle, std.posix.SOL.SOCKET, std.posix.SO.SNDTIMEO, std.mem.asBytes(&timeout), ) catch {};}
fn peerMatchesCurrentUser(handle: std.Io.net.Socket.Handle) bool { if (comptime builtin.os.tag == .macos) { var peer_uid: std.c.uid_t = undefined; var peer_gid: std.c.gid_t = undefined; const Peer = struct { extern "c" fn getpeereid( socket: std.c.fd_t, effective_uid: *std.c.uid_t, effective_gid: *std.c.gid_t, ) c_int; }; if (Peer.getpeereid(handle, &peer_uid, &peer_gid) != 0) return false; return peer_uid == std.c.getuid(); } if (comptime builtin.os.tag == .linux) { const UCred = extern struct { pid: std.c.pid_t, uid: std.c.uid_t, gid: std.c.gid_t, }; var credentials: UCred = undefined; var credentials_len: std.c.socklen_t = @sizeOf(UCred); if (std.c.getsockopt( handle, std.c.SOL.SOCKET, std.c.SO.PEERCRED, &credentials, &credentials_len, ) != 0) return false; return credentials_len == @sizeOf(UCred) and credentials.uid == std.c.getuid(); } return false;}
fn peerProcessOwner( alloc: Allocator, process_provider: background_process_provider.Provider, handle: std.Io.net.Socket.Handle,) !contracts.ProcessOwner { const pid: std.c.pid_t = if (comptime builtin.os.tag == .macos) blk: { const local_peer_pid = 0x002; var peer_pid: std.c.pid_t = undefined; var peer_pid_len: std.c.socklen_t = @sizeOf(std.c.pid_t); if (std.c.getsockopt( handle, 0, local_peer_pid, &peer_pid, &peer_pid_len, ) != 0 or peer_pid_len != @sizeOf(std.c.pid_t)) { return error.TerminalPeerIdentityUnavailable; } break :blk peer_pid; } else if (comptime builtin.os.tag == .linux) blk: { const UCred = extern struct { pid: std.c.pid_t, uid: std.c.uid_t, gid: std.c.gid_t, }; var credentials: UCred = undefined; var credentials_len: std.c.socklen_t = @sizeOf(UCred); if (std.c.getsockopt( handle, std.c.SOL.SOCKET, std.c.SO.PEERCRED, &credentials, &credentials_len, ) != 0 or credentials_len != @sizeOf(UCred)) { return error.TerminalPeerIdentityUnavailable; } break :blk credentials.pid; } else return error.TerminalHostUnsupported;
var pid_buffer: [32]u8 = undefined; const pid_text = try std.fmt.bufPrint(&pid_buffer, "{d}", .{pid}); const token = try process_provider.captureToken( alloc, pid_text, ); return contracts.ProcessOwner.init(@intCast(pid), token.view());}
fn writeIdentity( alloc: Allocator, process_provider: background_process_provider.Provider, host_dir: *io_mod.VerifiedDir, range: contracts.ProtocolRange, instance: []const u8,) !void { var pid_buffer: [32]u8 = undefined; const pid = try std.fmt.bufPrint(&pid_buffer, "{d}", .{std.c.getpid()}); const process_token = try process_provider.captureToken( alloc, pid, ); var out: std.Io.Writer.Allocating = .init(alloc); defer out.deinit(); try std.json.Stringify.value(IdentityRecord{ .pid = pid, .process_token = process_token.view(), .instance = instance, .protocol_minimum = range.minimum, .protocol_current = range.current, }, .{}, &out.writer); try out.writer.writeByte('\n'); try io_mod.durableReplaceVerified( alloc, host_dir, identity_name, out.written(), );}
pub fn identityEvidence( alloc: Allocator, process_provider: background_process_provider.Provider, host_dir: *io_mod.VerifiedDir,) policy.IdentityEvidence { var file = host_dir.dir.openFile(io_mod.getIo(), identity_name, .{ .mode = .read_only, .allow_directory = false, .follow_symlinks = false, .resolve_beneath = true, }) catch |err| switch (err) { error.FileNotFound => return .absent, else => return .unverifiable, }; defer file.close(io_mod.getIo()); var read_buffer: [identity_max_bytes]u8 = undefined; var reader = file.reader(io_mod.getIo(), &read_buffer); const bytes = reader.interface.allocRemaining( alloc, .limited(identity_max_bytes), ) catch return .unverifiable; defer alloc.free(bytes); var parsed = std.json.parseFromSlice( IdentityRecord, alloc, bytes, .{ .allocate = .alloc_always }, ) catch return .unverifiable; defer parsed.deinit(); const token = process_supervisor.ProcessInstanceToken.parse( parsed.value.process_token, ) catch return .unverifiable; return switch (process_provider.matchToken( alloc, parsed.value.pid, token, )) { .matched => .live, .missing, .mismatched => .dead, .unavailable => .unverifiable, };}
/// The caller must hold `host.lock` and must have classified the identity as/// absent or dead. This keeps destructive stale cleanup behind both proofs.pub fn removeStaleArtifacts( host_dir: *io_mod.VerifiedDir, endpoint_dir: *io_mod.VerifiedDir,) void { cleanupEndpoint(endpoint_dir); cleanupIdentity(host_dir);}
fn cleanupEndpoint(host_dir: *io_mod.VerifiedDir) void { const stat = host_dir.dir.statFile( io_mod.getIo(), endpoint_name, .{ .follow_symlinks = false }, ) catch return; if (stat.kind != .unix_domain_socket) return; host_dir.dir.deleteFile(io_mod.getIo(), endpoint_name) catch {};}
fn cleanupIdentity(host_dir: *io_mod.VerifiedDir) void { const stat = host_dir.dir.statFile( io_mod.getIo(), identity_name, .{ .follow_symlinks = false }, ) catch return; if (stat.kind != .file or stat.nlink != 1) return; host_dir.dir.deleteFile(io_mod.getIo(), identity_name) catch {};}
fn verifyEndpointPermissions(host_dir: *io_mod.VerifiedDir) !void { const stat = try host_dir.dir.statFile( io_mod.getIo(), endpoint_name, .{ .follow_symlinks = false }, ); if (stat.kind != .unix_domain_socket or stat.permissions.toMode() & 0o777 != 0o600) { return error.PrivateEndpointPermissionsUnsupported; }}
test "hidden host mode is exact and remains private" { const exact = [_][*:0]const u8{ "fx", internal_mode }; try std.testing.expect(isInternalModeRaw(&exact)); const public_like = [_][*:0]const u8{ "fx", "terminal-host" }; try std.testing.expect(!isInternalModeRaw(&public_like)); const extra = [_][*:0]const u8{ "fx", internal_mode, "extra" }; try std.testing.expect(!isInternalModeRaw(&extra));}
test "terminal host selection follows canonical platform support" { const os_tags = [_]std.Target.Os.Tag{ .macos, .linux, .windows, .wasi, .freebsd, .emscripten, }; for (os_tags) |os_tag| { try std.testing.expectEqual( host_capabilities.terminalSupportForOs(os_tag).isSupported(), isSupportedForOs(os_tag), ); } try std.testing.expectEqual(isSupportedForOs(builtin.os.tag), isSupported());}
test "host identity capture and reconciliation use the injected provider" { const Fake = struct { captures: usize = 0, matches: usize = 0, match_result: process_supervisor.TokenMatch = .matched,
fn provider(self: *@This()) background_process_provider.Provider { return .{ .context = self, .spawn_prepared_fn = spawnPrepared, .capture_token_fn = captureToken, .match_token_fn = matchToken, .signal_process_fn = signalProcess, }; }
fn spawnPrepared( _: ?*anyopaque, _: Allocator, _: background_process_provider.SpawnRequest, ) background_process_provider.ProviderError!background_process_provider.PreparedProcess { return error.Unsupported; }
fn captureToken( raw: ?*anyopaque, _: Allocator, _: []const u8, ) background_process_provider.ProviderError!process_supervisor.ProcessInstanceToken { const self: *@This() = @ptrCast(@alignCast(raw.?)); self.captures += 1; return process_supervisor.ProcessInstanceToken.parse( "macos:00000000000000000000000000000000:1:2", ) catch unreachable; }
fn matchToken( raw: ?*anyopaque, _: Allocator, _: []const u8, _: process_supervisor.ProcessInstanceToken, ) process_supervisor.TokenMatch { const self: *@This() = @ptrCast(@alignCast(raw.?)); self.matches += 1; return self.match_result; }
fn signalProcess( _: ?*anyopaque, _: Allocator, _: []const u8, _: process_supervisor.ProcessInstanceToken, ) background_process_provider.ProviderError!void { return error.Unsupported; } };
var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); var host_dir = io_mod.VerifiedDir{ .dir = try tmp.dir.openDir( std.testing.io, ".", .{ .iterate = true, .follow_symlinks = false }, ) }; defer host_dir.close();
var fake = Fake{}; try writeIdentity( std.testing.allocator, fake.provider(), &host_dir, contracts.local_protocol_range, "test-instance", ); try std.testing.expectEqual(@as(usize, 1), fake.captures);
try std.testing.expectEqual( policy.IdentityEvidence.live, identityEvidence(std.testing.allocator, fake.provider(), &host_dir), ); fake.match_result = .unavailable; try std.testing.expectEqual( policy.IdentityEvidence.unverifiable, identityEvidence(std.testing.allocator, fake.provider(), &host_dir), ); fake.match_result = .missing; try std.testing.expectEqual( policy.IdentityEvidence.dead, identityEvidence(std.testing.allocator, fake.provider(), &host_dir), ); fake.match_result = .mismatched; try std.testing.expectEqual( policy.IdentityEvidence.dead, identityEvidence(std.testing.allocator, fake.provider(), &host_dir), ); try std.testing.expectEqual(@as(usize, 4), fake.matches); try std.testing.expectError( error.Unsupported, writeIdentity( std.testing.allocator, background_process_provider.unavailable_provider, &host_dir, contracts.local_protocol_range, "test-instance", ), );}
test "endpoint paths honor the native sockaddr capacity" { if (!isSupported()) return error.SkipZigTest; const path_limit = comptime nativeEndpointPathLimit(builtin.os.tag).?; var maximum: [path_limit - 1]u8 = @splat('x'); var oversized: [path_limit]u8 = @splat('x'); try validateEndpointPath(&maximum); try std.testing.expectError(error.NameTooLong, validateEndpointPath(&oversized));}
test "endpoint selection preserves short homes and deterministically separates long homes" { if (!isSupported()) return error.SkipZigTest; const alloc = std.testing.allocator; const short_home = "/Users/terminal-short"; var short = try resolveEndpointSelection( alloc, builtin.os.tag, short_home, 501, ); defer short.deinit(alloc); const expected_short = try std.fs.path.join( alloc, &.{ short_home, profile_paths.root_dir_name, host_dir_name }, ); defer alloc.free(expected_short); try std.testing.expect(!short.uses_fallback); try std.testing.expectEqualStrings(expected_short, short.authority_root); try std.testing.expectEqualStrings(short.authority_root, short.transport_root);
const first_home = "/profiles/" ++ "a" ** 160; const second_home = "/profiles/" ++ "b" ** 160; var first = try resolveEndpointSelection( alloc, builtin.os.tag, first_home, 501, ); defer first.deinit(alloc); var reopened = try resolveEndpointSelection( alloc, builtin.os.tag, first_home, 501, ); defer reopened.deinit(alloc); var second = try resolveEndpointSelection( alloc, builtin.os.tag, second_home, 501, ); defer second.deinit(alloc);
try std.testing.expect(first.uses_fallback); try std.testing.expectEqualStrings(first.transport_root, reopened.transport_root); try std.testing.expect(!std.mem.eql(u8, first.transport_root, second.transport_root)); try std.testing.expect(std.mem.find(u8, first.transport_root, first_home) == null); try validateEndpointPath(first.endpoint_path); try std.testing.expect(std.mem.endsWith( u8, first.authority_root, "/.fx/terminal-host", )); try std.testing.expect(!std.mem.eql( u8, first.authority_root, first.transport_root, ));}
test "endpoint selection allocation and unsupported targets fail closed" { const alloc = std.testing.allocator; try std.testing.expectError( error.TerminalHostUnsupported, resolveEndpointSelection(alloc, .windows, "C:\\profile", 501), );
const long_home = "/profiles/" ++ "x" ** 160; var probe = std.testing.FailingAllocator.init(alloc, .{}); var selected = try resolveEndpointSelection( probe.allocator(), .macos, long_home, 501, ); selected.deinit(probe.allocator()); try std.testing.expectEqual(probe.allocated_bytes, probe.freed_bytes);
for (0..probe.alloc_index) |fail_index| { var failing = std.testing.FailingAllocator.init( alloc, .{ .fail_index = fail_index }, ); if (resolveEndpointSelection( failing.allocator(), .macos, long_home, 501, )) |value| { var owned = value; owned.deinit(failing.allocator()); } else |err| switch (err) { error.OutOfMemory => {}, else => return err, } try std.testing.expect(failing.has_induced_failure); try std.testing.expectEqual(failing.allocated_bytes, failing.freed_bytes); }}
test "runtime transport directories reject symlinks non-private modes and foreign owners" { if (!isSupported()) return error.SkipZigTest; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup();
var private = try openVerifiedPrivateRuntimeDir( tmp.dir, "private", std.c.getuid(), ); defer private.close(); const private_stat = try private.dir.stat(std.testing.io); try std.testing.expectEqual( @as(std.posix.mode_t, 0o700), private_stat.permissions.toMode() & 0o777, ); try std.testing.expectError( error.RuntimeDirectoryOwnerMismatch, validatePrivateRuntimeDir( private_stat, std.c.getuid() + 1, std.c.getuid(), ), );
try tmp.dir.createDir( std.testing.io, "public", std.Io.File.Permissions.fromMode(0o755), ); try tmp.dir.setFilePermissions( std.testing.io, "public", std.Io.File.Permissions.fromMode(0o755), .{ .follow_symlinks = false }, ); const public_stat = try tmp.dir.statFile( std.testing.io, "public", .{ .follow_symlinks = false }, ); try std.testing.expectEqual( @as(std.posix.mode_t, 0o755), public_stat.permissions.toMode() & 0o777, ); try std.testing.expectError( error.PrivateStatePermissionsUnsupported, openVerifiedPrivateRuntimeDir(tmp.dir, "public", std.c.getuid()), );
try tmp.dir.symLink( std.testing.io, "private", "linked", .{ .is_directory = true }, ); try std.testing.expectError( error.RuntimeDirectoryUnsafe, openVerifiedPrivateRuntimeDir(tmp.dir, "linked", std.c.getuid()), );}