Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283const std = @import("std");const builtin = @import("builtin");const command_admission = @import("../permissions/command_admission.zig");const command_environment = @import("command_environment.zig");const command_effect = @import("../shell_command/command_effect.zig");const debug_trace = @import("../shared/debug_trace.zig");const local_executor = @import("local_executor.zig");const command_runner = @import("../execution/command_runner.zig");
pub const RouteKind = local_executor.RouteKind;pub const PreparedCommandRoute = local_executor.PreparedCommand;pub const RoutedCommandResult = local_executor.CommandResult;
/// Upper bound for raw callback bytes that can still be represented by the/// route's ordinary foreground result. Above this bound the route either/// rejects output or promotes it to an unordered command artifact.pub fn foregroundResultComparisonLimit( route: PreparedCommandRoute, approved_shell_limit: usize,) usize { return local_executor.foregroundResultComparisonLimit(route, approved_shell_limit);}
pub fn prepareAuthorizedRoute( alloc: std.mem.Allocator, command_ctx: command_admission.CommandContext, authority: command_admission.CommandExecutionAuthority,) !PreparedCommandRoute { if (command_ctx.target_os != builtin.os.tag) return error.CommandTargetMismatch; return switch (authority) { .direct_only => |fingerprint| blk: { if (!fingerprint.matches(command_ctx)) return error.CommandAdmissionChanged; var admission = command_effect.plan( alloc, command_ctx.command, command_ctx.resolved_cwd, false, command_ctx.target_os, ) catch return error.CommandAdmissionChanged; switch (admission) { .direct_read_only => |plan| { debug_trace.logf("core", "shell.run authority=direct_only route=direct_read_only", .{}); break :blk .{ .direct_read_only = plan }; }, .approval_required => { admission.deinit(alloc); return error.CommandAdmissionChanged; }, } }, .shell_allowed => |shell| blk: { if (!shell.fingerprint.matches(command_ctx)) { return error.CommandAuthorityContextMismatch; } if (command_ctx.environment.requiresShellRoute()) { debug_trace.logf( "core", "shell.run authority=shell_allowed source={s} route=approved_shell environment={s}", .{ @tagName(shell.source), @tagName(std.meta.activeTag(command_ctx.environment)), }, ); break :blk .{ .approved_shell = .{ .command_ctx = command_ctx, .reason = .dynamic_shell, .source = shell.source, } }; } const admission = command_effect.plan( alloc, command_ctx.command, command_ctx.resolved_cwd, false, command_ctx.target_os, ) catch break :blk .{ .approved_shell = .{ .command_ctx = command_ctx, .reason = .planning_failure, .source = shell.source, } }; switch (admission) { .direct_read_only => |plan| { debug_trace.logf("core", "shell.run authority=shell_allowed source={s} route=direct_read_only", .{@tagName(shell.source)}); break :blk .{ .direct_read_only = plan }; }, .approval_required => |reason| { debug_trace.logf("core", "shell.run authority=shell_allowed source={s} route=approved_shell reason={s}", .{ @tagName(shell.source), @tagName(reason) }); break :blk .{ .approved_shell = .{ .command_ctx = command_ctx, .reason = reason, .source = shell.source, } }; }, } }, };}
pub fn executePreparedRoute( cfg: command_runner.Config, alloc: std.mem.Allocator, route: PreparedCommandRoute,) !RoutedCommandResult { return local_executor.executePreparedCommand(cfg, alloc, route);}
pub fn executePlannedCommand( cfg: command_runner.Config, alloc: std.mem.Allocator, command_ctx: command_admission.CommandContext, authority: command_admission.CommandExecutionAuthority,) !RoutedCommandResult { try validateConfigContext(cfg, command_ctx); const route = try prepareAuthorizedRoute(alloc, command_ctx, authority); return executePreparedRoute(cfg, alloc, route);}
pub fn validateConfigContext( cfg: command_runner.Config, command_ctx: command_admission.CommandContext,) !void { _ = cfg; if (command_ctx.target_os != builtin.os.tag) return error.CommandTargetMismatch;}
fn context(command: []const u8, background: bool) command_admission.CommandContext { _ = background; return .{ .command = command, .resolved_cwd = "/tmp", .target_os = builtin.os.tag, };}
fn directAuthority(ctx: command_admission.CommandContext) command_admission.CommandExecutionAuthority { return .{ .direct_only = .init(ctx) };}
fn shellAuthority( ctx: command_admission.CommandContext, source: command_admission.ShellAuthorizationSource,) command_admission.CommandExecutionAuthority { return .{ .shell_allowed = .{ .fingerprint = .init(ctx), .source = source, } };}
test { _ = @import("local_executor.zig");}
test "router revalidates direct-only authority and rejects changed admission" { const ctx = context("pwd", false); var route = try prepareAuthorizedRoute(std.testing.allocator, ctx, directAuthority(ctx)); defer route.deinit(std.testing.allocator); try std.testing.expect(route == .direct_read_only);
var changed = ctx; changed.command = "touch changed"; try std.testing.expectError( error.CommandAdmissionChanged, prepareAuthorizedRoute(std.testing.allocator, changed, directAuthority(ctx)), );}
test "router keeps direct grammar on the safer route for every shell source" { const ctx = context("pwd", false); const sources = [_]command_admission.ShellAuthorizationSource{ .configured_rule, .session_grant, .js_host, .interactive_once, .interactive_always, .auto_mode, .auto_classifier, .yolo, }; for (sources) |source| { var route = try prepareAuthorizedRoute( std.testing.allocator, ctx, shellAuthority(ctx, source), ); defer route.deinit(std.testing.allocator); try std.testing.expect(route == .direct_read_only); }}
test "router never sends explicit profiles through direct execution" { for ([_]command_environment.Environment{ .{ .clean = "/bin/zsh" }, .{ .user = "/bin/zsh" }, }) |environment| { var ctx = context("ls -l", false); ctx.environment = environment; var route = try prepareAuthorizedRoute( std.testing.allocator, ctx, shellAuthority(ctx, .interactive_once), ); defer route.deinit(std.testing.allocator); try std.testing.expect(route == .approved_shell); try std.testing.expectEqual( command_effect.ApprovalReason.dynamic_shell, route.approved_shell.reason, ); }}
test "router permits approval-bearing grammar only with sourced shell authority" { const ctx = context("touch created.txt", false); try std.testing.expectError( error.CommandAdmissionChanged, prepareAuthorizedRoute(std.testing.allocator, ctx, directAuthority(ctx)), );
var route = try prepareAuthorizedRoute( std.testing.allocator, ctx, shellAuthority(ctx, .configured_rule), ); defer route.deinit(std.testing.allocator); try std.testing.expect(route == .approved_shell); try std.testing.expectEqual( @as(usize, 1024), foregroundResultComparisonLimit(route, 1024), ); try std.testing.expectEqual(command_effect.ApprovalReason.filesystem_write, route.approved_shell.reason); try std.testing.expectEqual( command_admission.ShellAuthorizationSource.configured_rule, route.approved_shell.source, );}
test "router rejects shell fingerprint and target mismatches" { const ctx = context("git status", false); var changed = ctx; changed.resolved_cwd = "/other"; try std.testing.expectError( error.CommandAuthorityContextMismatch, prepareAuthorizedRoute( std.testing.allocator, changed, shellAuthority(ctx, .interactive_once), ), );
var changed_target = ctx; changed_target.target_os = if (builtin.os.tag == .macos) .linux else .macos; try std.testing.expectError( error.CommandTargetMismatch, validateConfigContext(.{ .max_command_output_bytes = 1024 }, changed_target), );
var changed_environment = ctx; changed_environment.environment = .{ .clean = "/bin/zsh" }; try std.testing.expectError( error.CommandAuthorityContextMismatch, prepareAuthorizedRoute( std.testing.allocator, changed_environment, shellAuthority(ctx, .interactive_once), ), );}
test "router executes direct plan without consulting approved shell capacity" { var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena_state.deinit(); const arena = arena_state.allocator(); const ctx = context("printf x | wc -c", false); const routed = try executePlannedCommand(.{ .max_command_output_bytes = 1, }, arena, ctx, directAuthority(ctx)); try std.testing.expectEqual(RouteKind.direct_read_only, routed.route); try std.testing.expect(std.mem.find(u8, routed.result.output, "<stdout>\n1\n</stdout>") != null); try std.testing.expectEqual( @as(?[]const u8, null), routed.result.command_result.?.output_file, );}