Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242const std = @import("std");const builtin = @import("builtin");const app_process_runtime = @import("app_process_runtime.zig");const app_session_runtime = @import("app_session_runtime.zig");const auto_upgrade = @import("../upgrade/auto_upgrade.zig");const acp_runner = @import("../cli/acp_runner.zig");const cli_surface = @import("../cli/cli_surface.zig");const devbox_executor = @import("../execution/devbox_executor.zig");const background_process_provider = @import( "../execution/background_process_provider.zig",);const gateway_provider = @import("../gateway/gateway_provider.zig");const model_catalog = @import("../gateway/model_catalog.zig");const agent_stream_provider = @import("../agent/stream_provider.zig");const host = @import("../hosts/host.zig");const host_target = @import("../hosts/target.zig");const io_mod = @import("../shared/io.zig");const permission_auto_classifier = @import("../permissions/auto_classifier.zig");const prompt_policy = @import("../config/prompt_policy.zig");const sandbox = @import("../permissions/sandbox.zig");const skill_contract = @import("../skills/skill_contract.zig");const command_specs = @import("../slash_commands/command_specs.zig");const context_contract = @import("../workspace/context_contract.zig");const mode_registry = @import("../modes/mode_registry.zig");const mcp_contract = @import("../mcp/mcp_contract.zig");const mcp_runtime = @import("../mcp/mcp_runtime.zig");const tool_set_contract = @import("../tooling/tool_set.zig");const update_target = @import("../upgrade/update_target.zig");const test_builtin_gateway = if (builtin.is_test) @import("../../builtins/gateway.zig")else struct {};const test_builtin_commands = if (builtin.is_test) @import("../../builtins/commands.zig")else struct {};
const Allocator = std.mem.Allocator;
pub const Config = struct { version: []const u8 = "", revision: []const u8 = "", build_channel: update_target.Channel = .stable, command_catalog: command_specs.TopLevelRegistry, default_model: []const u8, default_agent_step_limit: usize, models_path: []const u8, gateway_retry_count: usize, gateway_chat_url: []const u8, gateway_provider: gateway_provider.Provider, codex_agent_stream: ?agent_stream_provider.Provider = null, codex_cli_model_catalog: ?gateway_provider.CliModelCatalogProvider = null, codex_model_catalog: ?model_catalog.Provider = null, background_process_provider: background_process_provider.Provider = background_process_provider.unavailable_provider, url_opener: host.UrlOpener, secret_store: host.SecretStore, prompt_policy: prompt_policy.Policy, skill_root_policy: skill_contract.RootPolicy, ignored_list_entries: []const []const u8, max_list_entries: usize, max_read_file_bytes: usize, max_read_file_lines: usize, max_read_file_line_len: usize, max_command_output_bytes: usize, max_tool_result_bytes: usize, max_history_turns: usize, context_registry: context_contract.Registry, mode_registry: mode_registry.Registry, tool_set: tool_set_contract.ToolSet, inspect_mcp_profile_config: mcp_contract.InspectProfileConfigFn, load_mcp_runtime: mcp_runtime.LoadRuntimeFn, acp_runner: acp_runner.Runner, devbox_provider: ?devbox_executor.Provider = null, permission_reviewer_provider: ?permission_auto_classifier.Provider = null, codex_permission_reviewer_provider: ?permission_auto_classifier.Provider = null,};
pub fn run(comptime App: type, alloc: Allocator, args: []const [:0]const u8, cfg: Config) !void { const outcome = try runWithDeps(App, alloc, args, cfg, .{}); switch (outcome) { .returned => return, .exit => |code| std.process.exit(code), }}
pub const RunOutcome = union(enum) { returned, exit: u8,};
pub const BeforeInteractiveResult = union(enum) { interactive: cli_surface.InteractiveLaunch, returned, exit: u8,};
const RunIfRequestedFn = *const fn (?*anyopaque, Allocator, []const [:0]const u8, cli_surface.Config) anyerror!cli_surface.RunResult;const GetenvFn = *const fn (?*anyopaque, []const u8) ?[]const u8;const WriteFn = *const fn (?*anyopaque, []const u8) anyerror!void;const FormatUnexpectedErrorFn = *const fn ([]u8, anyerror) anyerror![]const u8;const StartWorkerThreadFn = *const fn (?*anyopaque, *anyopaque) anyerror!void;const ReplaceProcessFn = *const fn ( ?*anyopaque, std.Io, std.process.ReplaceOptions,) std.process.ReplaceError;const RunDeps = struct { cli_ctx: ?*anyopaque = null, run_if_requested: RunIfRequestedFn = if (host_target.is_wasm) unavailableCliDispatch else runIfRequestedDefault, env_ctx: ?*anyopaque = null, getenv: GetenvFn = getenvDefault, stderr_ctx: ?*anyopaque = null, write_stderr: WriteFn = writeRealStderr, stdout_ctx: ?*anyopaque = null, write_stdout: WriteFn = writeRealStdout, format_unexpected_error: FormatUnexpectedErrorFn = formatUnexpectedError, worker_ctx: ?*anyopaque = null, start_worker_thread: ?StartWorkerThreadFn = null, replace_ctx: ?*anyopaque = null, replace_process: ReplaceProcessFn = replaceProcessDefault,};
fn runWithDeps(comptime App: type, alloc: Allocator, args: []const [:0]const u8, cfg: Config, deps: RunDeps) !RunOutcome { var launch: cli_surface.InteractiveLaunch = .{}; defer launch.deinit(alloc);
const before = try runBeforeInteractiveWithDeps(alloc, args, cfg, deps); switch (before) { .interactive => |value| launch = value, .returned => return .returned, .exit => |code| return .{ .exit = code }, }
return runInteractiveWithDeps(App, false, alloc, &launch, deps);}
pub fn runBeforeInteractive(alloc: Allocator, args: []const [:0]const u8, cfg: Config) !BeforeInteractiveResult { _ = cli_surface.recordRequested(args) catch { writeStderr(.{}, cli_surface.record_modifier_usage); return .{ .exit = 1 }; }; const run_result = cli_surface.runIfRequested(alloc, args, cliSurfaceConfig(cfg)) catch |err| switch (err) { error.UnknownCliCommand => return .{ .exit = 1 }, else => { tryWriteErrorMessage(.{}, err); return .{ .exit = 1 }; }, };
return beforeInteractiveResultFromRunResult(alloc, run_result, benchEnabled());}
pub fn runNoConfigBeforeInteractive( alloc: Allocator, args: []const [:0]const u8, version: []const u8, command_catalog: command_specs.TopLevelRegistry,) !?RunOutcome { return if (try cli_surface.runNoConfigIfRequested(alloc, args, version, command_catalog)) .returned else null;}
fn runBeforeInteractiveWithDeps(alloc: Allocator, args: []const [:0]const u8, cfg: Config, deps: RunDeps) !BeforeInteractiveResult { _ = cli_surface.recordRequested(args) catch { writeStderr(deps, cli_surface.record_modifier_usage); return .{ .exit = 1 }; }; const run_result = deps.run_if_requested(deps.cli_ctx, alloc, args, cliSurfaceConfig(cfg)) catch |err| switch (err) { error.UnknownCliCommand => return .{ .exit = 1 }, else => { tryWriteErrorMessage(deps, err); return .{ .exit = 1 }; }, };
return beforeInteractiveResultFromRunResult(alloc, run_result, deps.getenv(deps.env_ctx, "FX_BENCH") != null);}
fn beforeInteractiveResultFromRunResult(alloc: Allocator, run_result: cli_surface.RunResult, bench: bool) BeforeInteractiveResult { switch (run_result) { .interactive => |launch| { if (bench) { var mutable_launch = launch; mutable_launch.deinit(alloc); return .returned; } return .{ .interactive = launch }; }, .handled_success => return .returned, .handled_failure => return .{ .exit = 1 }, .handled_exit => |code| return if (code == 0) .returned else .{ .exit = code }, }}
fn benchEnabled() bool { if (comptime builtin.link_libc) { return std.c.getenv("FX_BENCH") != null; } return io_mod.getenv("FX_BENCH") != null;}
pub fn runInteractive(comptime App: type, alloc: Allocator, launch: *cli_surface.InteractiveLaunch) !RunOutcome { return runInteractiveWithDeps(App, false, alloc, launch, .{});}
/// Runs the interactive product without native CLI dispatch, process replacement,/// or a worker thread. Single-threaded hosts must arrange cooperative prompt work.pub fn runInteractiveCooperative(comptime App: type, alloc: Allocator, launch: *cli_surface.InteractiveLaunch) !RunOutcome { return runInteractiveWithDeps(App, true, alloc, launch, .{});}
fn unavailableCliDispatch(_: ?*anyopaque, _: Allocator, _: []const [:0]const u8, _: cli_surface.Config) anyerror!cli_surface.RunResult { return error.UnknownCliCommand;}
fn runInteractiveWithDeps(comptime App: type, comptime cooperative: bool, alloc: Allocator, launch: *cli_surface.InteractiveLaunch, deps: RunDeps) !RunOutcome { const resume_requested = launch.requested_resume != null; var app = App.init(alloc, launch) catch |err| { switch (err) { error.NotATerminal => { writeStderr(deps, "fx requires an interactive terminal (TTY).\n"); return .{ .exit = 1 }; }, error.TerminalTooSmall => { writeStderr(deps, "fx needs at least 5 terminal rows.\n"); return .returned; }, error.RecordingStartFailed => { writeStderr(deps, "fx: unable to start terminal recording.\n"); return .{ .exit = 1 }; }, error.NoSavedSessions => { writeStderr(deps, "fx: no saved sessions for this workspace.\n"); return .{ .exit = 1 }; }, error.SessionNotFound => { writeStderr(deps, "fx: saved session not found.\n"); return .{ .exit = 1 }; }, error.SessionBusy => { writeStderr(deps, "fx: another Fx process may be using this session (running or suspended); check other terminals or run jobs, then use fg or quit that process\n"); return .{ .exit = 1 }; }, error.SessionLockUnsupported => { writeStderr(deps, "fx: the filesystem cannot provide the required session lock\n"); return .{ .exit = 1 }; }, error.SessionAuthorityBoundaryUnavailable, error.SessionCommitBoundaryUnavailable, => { writeStderr(deps, "fx: this session is being updated; wait a moment and retry\n"); return .{ .exit = 1 }; }, error.OneOffSessionNotResumable => { writeStderr(deps, "fx: one-off child sessions cannot accept additional prompts; create a persistent child to continue the conversation\n"); return .{ .exit = 1 }; }, error.InvalidSessionFormat => { writeStderr(deps, "fx: saved session is unreadable. Run `fx doctor`; if it is recoverable, use `fx session recover <id>`.\n"); return .{ .exit = 1 }; }, error.UnsupportedSessionSchema => { writeStderr(deps, "fx: saved session uses an unsupported version and cannot be resumed by this fx build.\n"); return .{ .exit = 1 }; }, error.RetiredSandboxValue, error.UnsupportedSandboxValue => { tryWriteErrorMessage(deps, err); return .{ .exit = 1 }; }, else => { reportUnexpectedInteractiveError(deps, err); return err; }, } }; if (comptime !cooperative) { if (@hasDecl(App, "startMcpDiscovery")) app.startMcpDiscovery(); if (@hasDecl(App, "rebindAfterInit")) app.rebindAfterInit(); } var app_needs_deinit = true; defer if (app_needs_deinit) app.deinit(); if (comptime !cooperative and @hasField(App, "session") and @hasDecl(@TypeOf(app.session), "attachProfileUsagePublisher")) { app.session.attachProfileUsagePublisher(app.alloc); } if (comptime !cooperative) { if (resume_requested) app.startResumedSessionReconciliation(); if (@hasDecl(App, "configureNotifications")) try app.configureNotifications(); if (@hasDecl(App, "playStartupSound")) app.playStartupSound(); if (@hasDecl(App, "startAutoUpgrade")) app.startAutoUpgrade(); if (@hasDecl(App, "startFileIndex")) app.startFileIndex(); startWorkerThread(App, &app, deps) catch |err| { app.releaseTerminal(); reportUnexpectedInteractiveError(deps, err); return err; }; app.startModelCacheWarmup(); }
app.run() catch |err| { app.releaseTerminal(); if (err == error.TerminalInputClosed) return .returned; reportUnexpectedInteractiveError(deps, err); return err; }; const relaunch_request: ?auto_upgrade.RelaunchRequest = if (comptime cooperative) null else if (comptime @hasDecl(App, "takeUpgradeRelaunchRequest")) app.takeUpgradeRelaunchRequest() else null; const resume_handoff_columns: u16 = if (comptime cooperative) 0 else if (comptime @hasDecl(App, "resumeHandoffColumns")) app.resumeHandoffColumns() else 0; app_needs_deinit = false; const handoff_value = if (comptime cooperative) blk: { app.deinit(); break :blk null; } else app.deinitWithResumeHandoff(); if (relaunch_request) |request| { if (handoff_value) |value| { var handoff = value; defer handoff.deinit(alloc); var argv = [_][]const u8{ request.executablePath(), "resume", handoff.session_id, cli_surface.upgrade_relaunch_arg, }; const replace_err = deps.replace_process( deps.replace_ctx, io_mod.getIo(), .{ .argv = &argv }, ); writeUpgradeRelaunchFailure(deps, replace_err, handoff.session_id); } else { writeStderr( deps, "fx: upgrade installed, but no validated resume handoff was available. Your conversation remains on disk; run `fx doctor`.\n", ); } return .{ .exit = 1 }; } if (handoff_value) |value| { var handoff = value; defer handoff.deinit(alloc); var message_buffer: [512]u8 = undefined; const message = (if (comptime @hasDecl(App, "formatResumeHandoff")) App.formatResumeHandoff( &message_buffer, handoff.session_id, resume_handoff_columns, ) else formatResumeHandoff(&message_buffer, handoff.session_id)) catch return .returned; deps.write_stdout(deps.stdout_ctx, message) catch {}; } return .returned;}
fn replaceProcessDefault( _: ?*anyopaque, zio: std.Io, options: std.process.ReplaceOptions,) std.process.ReplaceError { return std.process.replace(zio, options);}
fn writeUpgradeRelaunchFailure( deps: RunDeps, err: std.process.ReplaceError, session_id: []const u8,) void { var buffer: [768]u8 = undefined; const message = std.fmt.bufPrint( &buffer, "fx: upgrade installed, but relaunch failed: {s}\nContinue session with: fx --resume {s}\n", .{ @errorName(err), session_id }, ) catch "fx: upgrade installed, but relaunch failed; run `fx doctor`.\n"; writeStderr(deps, message);}
fn cliSurfaceConfig(cfg: Config) cli_surface.Config { return .{ .version = cfg.version, .revision = cfg.revision, .build_channel = cfg.build_channel, .command_catalog = cfg.command_catalog, .default_model = cfg.default_model, .default_agent_step_limit = cfg.default_agent_step_limit, .models_path = cfg.models_path, .gateway_retry_count = cfg.gateway_retry_count, .gateway_chat_url = cfg.gateway_chat_url, .gateway_provider = cfg.gateway_provider, .codex_agent_stream = cfg.codex_agent_stream, .codex_cli_model_catalog = cfg.codex_cli_model_catalog, .codex_model_catalog = cfg.codex_model_catalog, .background_process_provider = cfg.background_process_provider, .url_opener = cfg.url_opener, .secret_store = cfg.secret_store, .prompt_policy = cfg.prompt_policy, .skill_root_policy = cfg.skill_root_policy, .ignored_list_entries = cfg.ignored_list_entries, .max_list_entries = cfg.max_list_entries, .max_read_file_bytes = cfg.max_read_file_bytes, .max_read_file_lines = cfg.max_read_file_lines, .max_read_file_line_len = cfg.max_read_file_line_len, .max_command_output_bytes = cfg.max_command_output_bytes, .max_tool_result_bytes = cfg.max_tool_result_bytes, .max_history_turns = cfg.max_history_turns, .context_registry = cfg.context_registry, .mode_registry = cfg.mode_registry, .tool_set = cfg.tool_set, .inspect_mcp_profile_config = cfg.inspect_mcp_profile_config, .load_mcp_runtime = cfg.load_mcp_runtime, .acp_runner = cfg.acp_runner, .devbox_provider = cfg.devbox_provider, .permission_reviewer_provider = cfg.permission_reviewer_provider, .codex_permission_reviewer_provider = cfg.codex_permission_reviewer_provider, };}
fn startWorkerThread(comptime App: type, app: *App, deps: RunDeps) !void { if (!@hasField(App, "worker_thread")) { const start = deps.start_worker_thread orelse return error.MissingWorkerThreadDependency; return start(deps.worker_ctx, @ptrCast(app)); } if (deps.start_worker_thread) |start| { return start(deps.worker_ctx, @ptrCast(app)); } try app_process_runtime.Runtime(App).startWorkerThread(app);}
fn runIfRequestedDefault(_: ?*anyopaque, alloc: Allocator, args: []const [:0]const u8, cfg: cli_surface.Config) !cli_surface.RunResult { return cli_surface.runIfRequested(alloc, args, cfg);}
fn getenvDefault(_: ?*anyopaque, key: []const u8) ?[]const u8 { return io_mod.getenv(key);}
fn writeRealStderr(_: ?*anyopaque, text: []const u8) !void { try std.Io.File.stderr().writeStreamingAll(io_mod.getIo(), text);}
fn writeRealStdout(_: ?*anyopaque, text: []const u8) !void { try std.Io.File.stdout().writeStreamingAll(io_mod.getIo(), text);}
fn formatResumeHandoff(buffer: []u8, session_id: []const u8) ![]const u8 { return std.fmt.bufPrint( buffer, "Continue session with: fx --resume {s}\n", .{session_id}, );}
fn formatUnexpectedError(buffer: []u8, err: anyerror) ![]const u8 { return std.fmt.bufPrint(buffer, "fx: {s}\n", .{@errorName(err)});}
fn reportUnexpectedInteractiveError(deps: RunDeps, err: anyerror) void { var buffer: [256]u8 = undefined; const message = deps.format_unexpected_error(&buffer, err) catch return; deps.write_stderr(deps.stderr_ctx, message) catch {};}
fn writeStderr(deps: RunDeps, text: []const u8) void { deps.write_stderr(deps.stderr_ctx, text) catch {};}
fn tryWriteErrorMessage(deps: RunDeps, err: anyerror) void { writeStderr(deps, "fx: "); if (sandbox.configErrorMessage(err)) |message| { writeStderr(deps, message); } else { writeStderr(deps, @errorName(err)); } writeStderr(deps, "\n");}
fn gatherNoopContextForTest(_: Allocator, _: context_contract.InitialContextInput) context_contract.ProviderError!context_contract.ProviderContext { return .{};}
fn appendNoopStaticContextForTest(_: context_contract.StaticContextInput, _: Allocator, _: *std.ArrayList(@import("../shared/types.zig").ChatMessage)) context_contract.ProviderError!void {}
fn appendNoopTransientContextForTest(_: context_contract.TransientContextInput, _: Allocator, _: *std.ArrayList(@import("../shared/types.zig").ChatMessage)) context_contract.ProviderError!void {}
const test_entry_context_registry = context_contract.Registry{ .default_provider = .{ .id = "test.entry_context", .gather_project_context_fn = gatherNoopContextForTest, .select_applicable_project_context_fn = context_contract.selectNoApplicableProjectContext, .append_static_fn = appendNoopStaticContextForTest, .append_transient_fn = appendNoopTransientContextForTest,} };
fn unavailableDevboxForTest( _: ?*anyopaque, _: Allocator, _: []const u8, _: []const u8, _: devbox_executor.Control,) devbox_executor.ProviderError!devbox_executor.VercelOutcome { return .unavailable;}
const test_devbox_provider = devbox_executor.Provider{ .execute_fn = unavailableDevboxForTest };
fn noMcpRuntimeForTest(_: Allocator, _: @import("../mcp/elicitation.zig").Capabilities) !?*mcp_runtime.McpRuntime { return null;}
fn noMcpConfigInspectionForTest( _: Allocator,) error{OutOfMemory}!mcp_contract.ProfileConfigDiagnostic { return .clear;}
fn unexpectedAcpRunForTest(_: ?*anyopaque, _: Allocator, _: acp_runner.Config) anyerror!void { return error.TestUnexpectedAcpRun;}
fn testConfig() Config { return .{ .version = "0.2.10", .command_catalog = test_builtin_commands.top_level_registry, .default_model = "model", .default_agent_step_limit = 12, .models_path = "/models", .gateway_retry_count = 2, .gateway_chat_url = "https://gateway/chat", .gateway_provider = test_builtin_gateway.provider, .url_opener = host.unavailable_url_opener, .secret_store = host.unavailable_secret_store, .prompt_policy = .{ .system_prompt = "system" }, .skill_root_policy = .{ .managed_root_source = .global_fx }, .ignored_list_entries = &.{ ".git", "zig-out" }, .max_list_entries = 100, .max_read_file_bytes = 1024, .max_read_file_lines = 10, .max_read_file_line_len = 80, .max_command_output_bytes = 2048, .max_tool_result_bytes = 2048, .max_history_turns = 32, .context_registry = test_entry_context_registry, .mode_registry = .{ .default_mode_id = "entry" }, .inspect_mcp_profile_config = noMcpConfigInspectionForTest, .load_mcp_runtime = noMcpRuntimeForTest, .acp_runner = .{ .run_fn = unexpectedAcpRunForTest }, .devbox_provider = test_devbox_provider, .tool_set = .{ .registry = .{ .tools = &.{} }, .order = &.{"entry_test_tool"}, .read_only_tool_names = &.{}, }, };}
var test_events: [16][]const u8 = undefined;var test_event_count: usize = 0;var test_init_event_buf: [128]u8 = undefined;var active_capture: ?*TestCapture = null;
fn resetTestEvents() void { test_event_count = 0;}
fn appendTestEvent(text: []const u8) void { test_events[test_event_count] = text; test_event_count += 1;}
fn appendInitEvent(launch: *const cli_surface.InteractiveLaunch) void { if (launch.requested_resume) |target| { switch (target) { .pick => appendTestEvent("init:pick"), .last => appendTestEvent("init:last"), .id => |id| appendTestEvent(std.fmt.bufPrint(&test_init_event_buf, "init:{s}", .{id}) catch "init:<invalid>"), } } else { appendTestEvent("init:none"); }}
fn expectEvents(expected: []const []const u8) !void { try std.testing.expectEqual(expected.len, test_event_count); for (expected, test_events[0..test_event_count]) |want, got| { try std.testing.expectEqualStrings(want, got); }}
const TestCapture = struct { run_result: cli_surface.RunResult, cli_calls: usize = 0, seen_config: ?cli_surface.Config = null, stderr: std.Io.Writer.Allocating, stdout: std.Io.Writer.Allocating, bench_value: ?[]const u8 = null, init_error: ?anyerror = null, worker_error: ?anyerror = null, run_error: ?anyerror = null, stderr_error: ?anyerror = null, stdout_error: ?anyerror = null, stderr_calls: usize = 0, stdout_calls: usize = 0, record_stderr_event: bool = false, record_stdout_event: bool = false, resume_handoff_id: ?[]const u8 = null, upgrade_relaunch_path: ?[]const u8 = null, replace_error: std.process.ReplaceError = error.InvalidExe, replace_calls: usize = 0, replace_arg_count: usize = 0, replace_arg_bufs: [4][128]u8 = undefined, replace_arg_lens: [4]usize = .{ 0, 0, 0, 0 }, fail_unexpected_format: bool = false,
fn init(run_result: cli_surface.RunResult) TestCapture { resetTestEvents(); return .{ .run_result = run_result, .stderr = .init(std.testing.allocator), .stdout = .init(std.testing.allocator), }; }
fn deinit(self: *TestCapture) void { active_capture = null; self.stderr.deinit(); self.stdout.deinit(); }
fn deps(self: *TestCapture) RunDeps { active_capture = self; return .{ .cli_ctx = self, .run_if_requested = runIfRequestedForTest, .env_ctx = self, .getenv = getenvForTest, .stderr_ctx = self, .write_stderr = writeStderrForTest, .stdout_ctx = self, .write_stdout = writeStdoutForTest, .format_unexpected_error = if (self.fail_unexpected_format) failUnexpectedErrorFormatForTest else formatUnexpectedError, .worker_ctx = self, .start_worker_thread = startWorkerThreadForTest, .replace_ctx = self, .replace_process = replaceProcessForTest, }; }
fn replaceArg(self: *const TestCapture, index: usize) []const u8 { return self.replace_arg_bufs[index][0..self.replace_arg_lens[index]]; }};
fn runIfRequestedForTest(ctx: ?*anyopaque, _: Allocator, _: []const [:0]const u8, cfg: cli_surface.Config) !cli_surface.RunResult { const capture: *TestCapture = @ptrCast(@alignCast(ctx.?)); capture.cli_calls += 1; capture.seen_config = cfg; return capture.run_result;}
fn getenvForTest(ctx: ?*anyopaque, key: []const u8) ?[]const u8 { const capture: *TestCapture = @ptrCast(@alignCast(ctx.?)); if (std.mem.eql(u8, key, "FX_BENCH")) return capture.bench_value; return null;}
fn writeStderrForTest(ctx: ?*anyopaque, text: []const u8) !void { const capture: *TestCapture = @ptrCast(@alignCast(ctx.?)); capture.stderr_calls += 1; if (capture.record_stderr_event) appendTestEvent("stderr-attempt"); if (capture.stderr_error) |err| return err; try capture.stderr.writer.writeAll(text);}
fn writeStdoutForTest(ctx: ?*anyopaque, text: []const u8) !void { const capture: *TestCapture = @ptrCast(@alignCast(ctx.?)); capture.stdout_calls += 1; if (capture.record_stdout_event) appendTestEvent("stdout-attempt"); if (capture.stdout_error) |err| return err; try capture.stdout.writer.writeAll(text);}
fn replaceProcessForTest( ctx: ?*anyopaque, _: std.Io, options: std.process.ReplaceOptions,) std.process.ReplaceError { const capture: *TestCapture = @ptrCast(@alignCast(ctx.?)); capture.replace_calls += 1; capture.replace_arg_count = options.argv.len; const count = @min(options.argv.len, capture.replace_arg_bufs.len); for (options.argv[0..count], 0..) |arg, index| { if (arg.len > capture.replace_arg_bufs[index].len) { return error.SystemResources; } @memcpy(capture.replace_arg_bufs[index][0..arg.len], arg); capture.replace_arg_lens[index] = arg.len; } return capture.replace_error;}
fn failUnexpectedErrorFormatForTest(_: []u8, _: anyerror) ![]const u8 { return error.TestUnexpectedErrorFormatFailed;}
fn startWorkerThreadForTest(ctx: ?*anyopaque, _: *anyopaque) !void { appendTestEvent("worker-thread"); const capture: *TestCapture = @ptrCast(@alignCast(ctx.?)); if (capture.worker_error) |err| return err;}
const TestApp = struct { requested_resume: ?cli_surface.ResumeTarget = null, terminal_released: bool = false,
fn init(_: Allocator, launch: *cli_surface.InteractiveLaunch) !TestApp { appendInitEvent(launch); if (active_capture.?.init_error) |err| return err;
var app = TestApp{}; if (launch.requested_resume) |target| { app.requested_resume = target; launch.requested_resume = null; } return app; }
fn deinit(self: *TestApp) void { self.releaseTerminal(); if (self.requested_resume) |*target| target.deinit(std.testing.allocator); appendTestEvent("deinit"); self.* = undefined; }
fn deinitWithResumeHandoff(self: *TestApp) ?app_session_runtime.ResumeHandoff { const handoff: ?app_session_runtime.ResumeHandoff = if (active_capture.?.resume_handoff_id) |id| blk: { const session_id = std.testing.allocator.dupe(u8, id) catch { self.deinit(); return null; }; break :blk .{ .session_id = session_id }; } else null; self.deinit(); return handoff; }
fn takeUpgradeRelaunchRequest(_: *TestApp) ?auto_upgrade.RelaunchRequest { const path = active_capture.?.upgrade_relaunch_path orelse return null; var request = auto_upgrade.RelaunchRequest{ .executable_path_len = path.len, }; @memcpy(request.executable_path_buf[0..path.len], path); return request; }
fn releaseTerminal(self: *TestApp) void { if (self.terminal_released) return; self.terminal_released = true; appendTestEvent("terminal-release"); }
fn startResumedSessionReconciliation(_: *TestApp) void { appendTestEvent("resume-reconciliation"); }
fn startAutoUpgrade(_: *TestApp) void { appendTestEvent("auto-upgrade"); }
fn startFileIndex(_: *TestApp) void { appendTestEvent("file-index"); }
fn startMcpDiscovery(_: *TestApp) void { appendTestEvent("mcp-discovery"); }
fn rebindAfterInit(_: *TestApp) void { appendTestEvent("rebind-after-init"); }
fn startModelCacheWarmup(_: *TestApp) void { appendTestEvent("model-cache"); }
fn run(_: *TestApp) !void { appendTestEvent("run"); if (active_capture.?.run_error) |err| return err; }};
test "app entry returns after handled CLI success without initializing app" { const alloc = std.testing.allocator; var capture = TestCapture.init(.handled_success); defer capture.deinit(); const skill_roots = [_]skill_contract.RootSpec{ .{ .source = .workspace_shared, .path = "skills" }, }; var cfg = testConfig(); var url_opener_context: u8 = 0; var secret_store_context: u8 = 0; cfg.url_opener.context = &url_opener_context; cfg.secret_store.context = &secret_store_context; cfg.skill_root_policy.workspace_roots = &skill_roots; const outcome = try runWithDeps(TestApp, alloc, &.{@constCast("help")}, cfg, capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqual(@as(usize, 1), capture.cli_calls); try std.testing.expectEqualStrings("0.2.10", capture.seen_config.?.version); try std.testing.expectEqualStrings("help", capture.seen_config.?.command_catalog.specs[0].token); try std.testing.expectEqualStrings("test.entry_context", capture.seen_config.?.context_registry.defaultProvider().id); try std.testing.expectEqualStrings("entry", capture.seen_config.?.mode_registry.default_mode_id); try std.testing.expectEqualStrings("entry_test_tool", capture.seen_config.?.tool_set.order[0]); try std.testing.expectEqualStrings("skills", capture.seen_config.?.skill_root_policy.workspace_roots[0].path); try std.testing.expect(capture.seen_config.?.gateway_provider.chat_url.resolve_fn == test_builtin_gateway.chat_url_provider.resolve_fn); try std.testing.expect(capture.seen_config.?.gateway_provider.cli_model_catalog.fetch_fn == test_builtin_gateway.cli_model_catalog_provider.fetch_fn); try std.testing.expect(capture.seen_config.?.gateway_provider.web_search.execute_fn == test_builtin_gateway.default_web_search_provider.execute_fn); try std.testing.expect(capture.seen_config.?.gateway_provider.model_catalog.fetch_fn == test_builtin_gateway.model_catalog_provider.fetch_fn); try std.testing.expect( capture.seen_config.?.background_process_provider.spawn_prepared_fn == cfg.background_process_provider.spawn_prepared_fn, ); try std.testing.expect(capture.seen_config.?.url_opener.context == cfg.url_opener.context); try std.testing.expect(capture.seen_config.?.url_opener.open_fn == cfg.url_opener.open_fn); try std.testing.expect(capture.seen_config.?.secret_store.context == cfg.secret_store.context); try std.testing.expect(capture.seen_config.?.secret_store.load_fn == cfg.secret_store.load_fn); try std.testing.expect(capture.seen_config.?.inspect_mcp_profile_config == noMcpConfigInspectionForTest); try std.testing.expect(capture.seen_config.?.load_mcp_runtime == noMcpRuntimeForTest); try std.testing.expect(capture.seen_config.?.devbox_provider.?.execute_fn == unavailableDevboxForTest); try std.testing.expectEqual(@as(usize, 0), test_event_count);}
test "app entry exits after handled CLI failure" { const alloc = std.testing.allocator; var capture = TestCapture.init(.handled_failure); defer capture.deinit(); const outcome = try runWithDeps(TestApp, alloc, &.{@constCast("models")}, testConfig(), capture.deps());
try std.testing.expectEqual(@as(u8, 1), outcome.exit); try std.testing.expectEqual(@as(usize, 0), test_event_count);}
test "app entry maps handled CLI exit without initializing app" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .handled_exit = 42 }); defer capture.deinit(); const outcome = try runWithDeps(TestApp, alloc, &.{ @constCast("replay"), @constCast("tape") }, testConfig(), capture.deps());
try std.testing.expectEqual(@as(u8, 42), outcome.exit); try std.testing.expectEqual(@as(usize, 1), capture.cli_calls); try std.testing.expectEqual(@as(usize, 0), test_event_count);}
test "app entry returns after handled zero exit without initializing app" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .handled_exit = 0 }); defer capture.deinit(); const outcome = try runWithDeps(TestApp, alloc, &.{ @constCast("replay"), @constCast("tape") }, testConfig(), capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqual(@as(usize, 1), capture.cli_calls); try std.testing.expectEqual(@as(usize, 0), test_event_count);}
test "app entry honors FX_BENCH before app initialization" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.bench_value = "1"; const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqual(@as(usize, 1), capture.cli_calls); try std.testing.expectEqual(@as(usize, 0), test_event_count);}
test "app entry runs interactive startup callbacks in active order" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqual(@as(usize, 0), capture.stdout_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "deinit" });}
test "app entry writes exact resume handoff after interactive teardown" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.resume_handoff_id = "session-123"; capture.record_stdout_event = true;
const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqualStrings( "Continue session with: fx --resume session-123\n", capture.stdout.written(), ); try std.testing.expectEqual(@as(usize, 1), capture.stdout_calls); try std.testing.expectEqualStrings("", capture.stderr.written()); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "deinit", "stdout-attempt", });}
test "app entry relaunches only after teardown with the validated handoff" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.resume_handoff_id = "session-123"; capture.upgrade_relaunch_path = "/tmp/fx-upgraded"; capture.record_stderr_event = true;
const outcome = try runWithDeps( TestApp, alloc, &.{}, testConfig(), capture.deps(), );
try std.testing.expectEqual(@as(u8, 1), outcome.exit); try std.testing.expectEqual(@as(usize, 1), capture.replace_calls); try std.testing.expectEqual(@as(usize, 4), capture.replace_arg_count); try std.testing.expectEqualStrings("/tmp/fx-upgraded", capture.replaceArg(0)); try std.testing.expectEqualStrings("resume", capture.replaceArg(1)); try std.testing.expectEqualStrings("session-123", capture.replaceArg(2)); try std.testing.expectEqualStrings("--upgrade-relaunch", capture.replaceArg(3)); try std.testing.expect(std.mem.find( u8, capture.stderr.written(), "relaunch failed: InvalidExe", ) != null); try std.testing.expect(std.mem.find( u8, capture.stderr.written(), "fx --resume session-123", ) != null); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "deinit", "stderr-attempt", });}
test "app entry never relaunches without a validated handoff" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.upgrade_relaunch_path = "/tmp/fx-upgraded";
const outcome = try runWithDeps( TestApp, alloc, &.{}, testConfig(), capture.deps(), );
try std.testing.expectEqual(@as(u8, 1), outcome.exit); try std.testing.expectEqual(@as(usize, 0), capture.replace_calls); try std.testing.expect(std.mem.find( u8, capture.stderr.written(), "no validated resume handoff", ) != null);}
test "app entry ignores resume handoff stdout failures" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.resume_handoff_id = "session-123"; capture.stdout_error = error.TestStdoutWriteFailed;
const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqual(@as(usize, 1), capture.stdout_calls); try std.testing.expectEqualStrings("", capture.stdout.written()); try std.testing.expectEqualStrings("", capture.stderr.written());}
fn runWithOuterCleanup(comptime App: type, alloc: Allocator, args: []const [:0]const u8, cfg: Config, deps: RunDeps) !RunOutcome { defer appendTestEvent("outer-defer"); return runWithDeps(App, alloc, args, cfg, deps);}
test "app entry reports unexpected init errors once and preserves identity" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.init_error = error.TestInitFailed; capture.record_stderr_event = true;
try std.testing.expectError(error.TestInitFailed, runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps())); try std.testing.expectEqualStrings("fx: TestInitFailed\n", capture.stderr.written()); try std.testing.expectEqual(@as(usize, 1), capture.stderr_calls); try expectEvents(&.{ "init:none", "stderr-attempt" });}
test "app entry releases terminal before reporting worker start errors" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.worker_error = error.TestWorkerStartFailed; capture.record_stderr_event = true;
try std.testing.expectError(error.TestWorkerStartFailed, runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps())); try std.testing.expectEqualStrings("fx: TestWorkerStartFailed\n", capture.stderr.written()); try std.testing.expectEqual(@as(usize, 1), capture.stderr_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "terminal-release", "stderr-attempt", "deinit" });}
test "app entry releases terminal before reporting initial context failures exactly" { const alloc = std.testing.allocator; const errors = [_]context_contract.ProviderError{ error.OutOfMemory, error.NoSpaceLeft, error.WriteFailed, };
for (errors) |expected_error| { var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.run_error = expected_error; capture.record_stderr_event = true;
try std.testing.expectError( expected_error, runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps()), ); var expected_stderr_buf: [64]u8 = undefined; const expected_stderr = try std.fmt.bufPrint( &expected_stderr_buf, "fx: {s}\n", .{@errorName(expected_error)}, ); try std.testing.expectEqualStrings(expected_stderr, capture.stderr.written()); try std.testing.expectEqual(@as(usize, 1), capture.stderr_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "stderr-attempt", "deinit", }); }}
test "app entry reports run errors before deinit and outer cleanup" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.run_error = error.TestRunFailed; capture.record_stderr_event = true;
try std.testing.expectError(error.TestRunFailed, runWithOuterCleanup(TestApp, alloc, &.{}, testConfig(), capture.deps())); try std.testing.expectEqualStrings("fx: TestRunFailed\n", capture.stderr.written()); try std.testing.expectEqual(@as(usize, 1), capture.stderr_calls); try std.testing.expectEqual(@as(usize, 0), capture.stdout_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "stderr-attempt", "deinit", "outer-defer" });}
test "app entry treats terminal input closure as abnormal cleanup without stderr" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.run_error = error.TerminalInputClosed; capture.record_stderr_event = true; capture.resume_handoff_id = "session-123";
const outcome = try runWithDeps( TestApp, alloc, &.{}, testConfig(), capture.deps(), );
try std.testing.expectEqual(RunOutcome.returned, outcome); try std.testing.expectEqualStrings("", capture.stderr.written()); try std.testing.expectEqual(@as(usize, 0), capture.stderr_calls); try std.testing.expectEqual(@as(usize, 0), capture.stdout_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "deinit", });}
test "app entry preserves run errors when fatal formatting fails" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.run_error = error.TestRunFailed; capture.fail_unexpected_format = true;
try std.testing.expectError(error.TestRunFailed, runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps())); try std.testing.expectEqualStrings("", capture.stderr.written()); try std.testing.expectEqual(@as(usize, 0), capture.stderr_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "deinit" });}
test "app entry preserves run errors when fatal writer fails" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.run_error = error.TestRunFailed; capture.stderr_error = error.TestStderrWriteFailed; capture.record_stderr_event = true;
try std.testing.expectError(error.TestRunFailed, runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps())); try std.testing.expectEqualStrings("", capture.stderr.written()); try std.testing.expectEqual(@as(usize, 1), capture.stderr_calls); try expectEvents(&.{ "init:none", "mcp-discovery", "rebind-after-init", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "stderr-attempt", "deinit" });}
test "app entry passes requested resume into app init" { const alloc = std.testing.allocator; const id = try alloc.dupe(u8, "session-123"); var capture = TestCapture.init(.{ .interactive = .{ .requested_resume = .{ .id = id } } }); defer capture.deinit(); const outcome = try runWithDeps(TestApp, alloc, &.{ @constCast("resume"), @constCast("session-123") }, testConfig(), capture.deps());
try std.testing.expectEqual(RunOutcome.returned, outcome); try expectEvents(&.{ "init:session-123", "mcp-discovery", "rebind-after-init", "resume-reconciliation", "auto-upgrade", "file-index", "worker-thread", "model-cache", "run", "terminal-release", "deinit" });}
test "app entry maps noninteractive terminal startup to exit one" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.init_error = error.NotATerminal; const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(@as(u8, 1), outcome.exit); try std.testing.expectEqualStrings("fx requires an interactive terminal (TTY).\n", capture.stderr.written()); try expectEvents(&.{"init:none"});}
test "app entry maps missing saved sessions to exit one" { const alloc = std.testing.allocator; var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.init_error = error.NoSavedSessions; const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(@as(u8, 1), outcome.exit); try std.testing.expectEqualStrings("fx: no saved sessions for this workspace.\n", capture.stderr.written());}
test "app entry maps unavailable session state to one expected startup failure" { const alloc = std.testing.allocator; const cases = [_]struct { init_error: anyerror, message: []const u8, }{ .{ .init_error = error.SessionBusy, .message = "fx: another Fx process may be using this session (running or suspended); check other terminals or run jobs, then use fg or quit that process\n", }, .{ .init_error = error.SessionLockUnsupported, .message = "fx: the filesystem cannot provide the required session lock\n", }, .{ .init_error = error.SessionAuthorityBoundaryUnavailable, .message = "fx: this session is being updated; wait a moment and retry\n", }, .{ .init_error = error.SessionCommitBoundaryUnavailable, .message = "fx: this session is being updated; wait a moment and retry\n", }, .{ .init_error = error.OneOffSessionNotResumable, .message = "fx: one-off child sessions cannot accept additional prompts; create a persistent child to continue the conversation\n", }, };
for (cases) |case| { var capture = TestCapture.init(.{ .interactive = .{} }); defer capture.deinit(); capture.init_error = case.init_error; capture.fail_unexpected_format = true;
const outcome = try runWithDeps(TestApp, alloc, &.{}, testConfig(), capture.deps());
try std.testing.expectEqual(@as(u8, 1), outcome.exit); try std.testing.expectEqualStrings(case.message, capture.stderr.written()); try std.testing.expectEqual(@as(usize, 1), capture.stderr_calls); try expectEvents(&.{"init:none"}); }}