Something went wrong. Try again.
My version of https://github.com/vercel-labs/fx
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533const std = @import("std");const io_mod = @import("../shared/io.zig");const types = @import("../shared/types.zig");const process_supervisor = @import("../background/process_supervisor.zig");const command_contract = @import("../execution/command_contract.zig");const session_child_store = @import("../session/session_child_store.zig");const session_runtime = @import("../session/session.zig");
const Allocator = std.mem.Allocator;
pub const StopSelection = process_supervisor.StopSelection;pub const TaskState = process_supervisor.TaskState;pub const TaskCompletion = process_supervisor.TaskCompletion;pub const ConversationLanguage = session_runtime.ConversationLanguage;
pub fn taskStateLabel(state: TaskState) []const u8 { return switch (state) { .running => "running", .exited => "exited", .failed => "failed", .stopped => "stopped", .dead => "dead", .stale => "stale", };}
pub fn parseTaskSelection(target: []const u8) !StopSelection { const trimmed = std.mem.trim(u8, target, " \t"); if (trimmed.len == 0 or std.mem.eql(u8, trimmed, "last")) return .last; return .{ .id = try std.fmt.parseInt(u64, trimmed, 10) };}
pub fn readExternalTaskLogTail(alloc: Allocator, log_path: []const u8, max_bytes: usize, max_lines: usize) ![]u8 { var file = try std.Io.Dir.openFileAbsolute(io_mod.getIo(), log_path, .{}); defer file.close(io_mod.getIo());
const stat = try file.stat(io_mod.getIo()); const size: usize = @intCast(stat.size); const tail_size = @min(size, max_bytes); const start = size - tail_size;
var read_buf: [8192]u8 = undefined; var reader = file.reader(io_mod.getIo(), &read_buf); if (start > 0) try reader.seekTo(start); const read_limit = std.math.add(usize, tail_size, 1) catch tail_size; const content = try reader.interface.allocRemaining(alloc, std.Io.Limit.limited(read_limit)); defer alloc.free(content);
const tail = tailLogSlice(content, start, max_lines); return std.fmt.allocPrint(alloc, "[logs] {s}\n{s}", .{ log_path, tail });}
pub fn readExternalTaskLogSummary(alloc: Allocator, log_path: []const u8, max_head_bytes: usize, max_tail_bytes: usize, max_lines: usize) ![]u8 { return readExternalTaskLogSummaryWithTopic(alloc, log_path, max_head_bytes, max_tail_bytes, max_lines, true);}
pub fn readExternalTaskLogSummaryBody(alloc: Allocator, log_path: []const u8, max_head_bytes: usize, max_tail_bytes: usize, max_lines: usize) ![]u8 { return readExternalTaskLogSummaryWithTopic(alloc, log_path, max_head_bytes, max_tail_bytes, max_lines, false);}
fn readExternalTaskLogSummaryWithTopic(alloc: Allocator, log_path: []const u8, max_head_bytes: usize, max_tail_bytes: usize, max_lines: usize, include_topic: bool) ![]u8 { var file = try std.Io.Dir.openFileAbsolute(io_mod.getIo(), log_path, .{}); defer file.close(io_mod.getIo());
const stat = try file.stat(io_mod.getIo()); const size: usize = @intCast(stat.size);
const head = try readLogRange(alloc, &file, 0, @min(size, max_head_bytes)); defer alloc.free(head);
const tail_size = @min(size, max_tail_bytes); const tail_start = size - tail_size; const tail_raw = try readLogRange(alloc, &file, tail_start, tail_size); defer alloc.free(tail_raw);
const head_slice = head[0..firstLinesEnd(head, max_lines)]; const tail_slice = tailLogSlice(tail_raw, tail_start, max_lines);
return formatTaskLogSummary(alloc, log_path, size, head_slice, tail_slice, include_topic);}
pub fn readManagedTaskLogTail( alloc: Allocator, file: *session_child_store.ManagedFile, display_path: []const u8, max_bytes: usize, max_lines: usize,) ![]u8 { const stat = try file.stat(); const size: usize = @intCast(stat.size); const tail_size = @min(size, max_bytes); const start = size - tail_size; const content = try file.readRange(alloc, start, tail_size); defer alloc.free(content);
const tail = tailLogSlice(content, start, max_lines); return std.fmt.allocPrint( alloc, "[logs] {s}\n{s}", .{ display_path, tail }, );}
pub fn readManagedTaskLogSummary( alloc: Allocator, file: *session_child_store.ManagedFile, display_path: []const u8, max_head_bytes: usize, max_tail_bytes: usize, max_lines: usize,) ![]u8 { return readManagedTaskLogSummaryWithTopic(alloc, file, display_path, max_head_bytes, max_tail_bytes, max_lines, true);}
pub fn readManagedTaskLogSummaryBody( alloc: Allocator, file: *session_child_store.ManagedFile, display_path: []const u8, max_head_bytes: usize, max_tail_bytes: usize, max_lines: usize,) ![]u8 { return readManagedTaskLogSummaryWithTopic(alloc, file, display_path, max_head_bytes, max_tail_bytes, max_lines, false);}
fn readManagedTaskLogSummaryWithTopic( alloc: Allocator, file: *session_child_store.ManagedFile, display_path: []const u8, max_head_bytes: usize, max_tail_bytes: usize, max_lines: usize, include_topic: bool,) ![]u8 { const stat = try file.stat(); const size: usize = @intCast(stat.size); const head = try file.readRange(alloc, 0, @min(size, max_head_bytes)); defer alloc.free(head);
const tail_size = @min(size, max_tail_bytes); const tail_start = size - tail_size; const tail_raw = try file.readRange(alloc, tail_start, tail_size); defer alloc.free(tail_raw);
const head_slice = head[0..firstLinesEnd(head, max_lines)]; const tail_slice = tailLogSlice(tail_raw, tail_start, max_lines);
return formatTaskLogSummary(alloc, display_path, size, head_slice, tail_slice, include_topic);}
fn formatTaskLogSummary( alloc: Allocator, display_path: []const u8, size: usize, head: []const u8, tail: []const u8, include_topic: bool,) ![]u8 { var out: std.Io.Writer.Allocating = .init(alloc); defer out.deinit(); if (include_topic) try out.writer.writeAll("[logs] "); try out.writer.print("{s}\nbytes={d}\n<head>\n{s}</head>\n<tail>\n{s}</tail>\n", .{ display_path, size, head, tail, }); return try out.toOwnedSlice();}
pub fn formatBackgroundCommandNotice(alloc: Allocator, task_id: u64, background: command_contract.BackgroundCommand, language: ConversationLanguage) ![]u8 { _ = language; if (background.url) |url| { return std.fmt.allocPrint(alloc, "Background #{d}: server running at {s}. Log: {s}", .{ task_id, url, background.log_path }); }
if (background.expect_url) { return std.fmt.allocPrint(alloc, "Background #{d}: server started. Waiting for local URL. Log: {s}", .{ task_id, background.log_path }); }
return std.fmt.allocPrint(alloc, "Background #{d}: command started. Log: {s}", .{ task_id, background.log_path });}
/// Returns a semantic notice whose body is owned by the caller.pub fn backgroundLaunchNotice(alloc: Allocator, task_id: u64, background: command_contract.BackgroundCommand, language: ConversationLanguage) !types.SemanticNotice { _ = language; const body = if (background.url) |url| try std.fmt.allocPrint(alloc, "Command #{d} started. Server: {s}. Log: {s}", .{ task_id, url, background.log_path }) else if (background.expect_url) try std.fmt.allocPrint(alloc, "Command #{d} started. Waiting for local URL. Log: {s}", .{ task_id, background.log_path }) else try std.fmt.allocPrint(alloc, "Command #{d} started. Log: {s}", .{ task_id, background.log_path }); return .{ .topic = "background", .tone = .neutral, .body = body, };}
/// Returns a semantic notice whose body is owned by the caller.pub fn backgroundServerReadyNotice(alloc: Allocator, task_id: u64, url: []const u8, language: ConversationLanguage) !types.SemanticNotice { _ = language; return .{ .topic = "background", .tone = .neutral, .body = try std.fmt.allocPrint(alloc, "Command #{d} server ready at {s}.", .{ task_id, url }), };}
/// Returns a semantic notice whose body is owned by the caller.pub fn backgroundCompletionNotice(alloc: Allocator, completion: TaskCompletion, language: ConversationLanguage) !types.SemanticNotice { _ = language; const tone: types.NoticeTone = switch (completion.state) { .exited, .running => .neutral, .failed, .dead, .stale => .@"error", .stopped => .cancelled, }; const body = switch (completion.state) { .exited => try std.fmt.allocPrint(alloc, "Command #{d} completed successfully.", .{completion.id}), .failed => if (completion.exit_code) |code| try std.fmt.allocPrint(alloc, "Command #{d} failed (exit {d}).", .{ completion.id, code }) else try std.fmt.allocPrint(alloc, "Command #{d} failed.", .{completion.id}), .stopped => try std.fmt.allocPrint(alloc, "Command #{d} stopped.", .{completion.id}), .dead => try std.fmt.allocPrint(alloc, "Command #{d} is no longer running.", .{completion.id}), .stale => try std.fmt.allocPrint(alloc, "Command #{d} is stale.", .{completion.id}), .running => try std.fmt.allocPrint(alloc, "Command #{d} is running.", .{completion.id}), }; return .{ .topic = "background", .tone = tone, .body = body, };}
fn tailLogSlice(content: []const u8, window_start: usize, max_lines: usize) []const u8 { var slice = content; if (window_start > 0) { slice = if (std.mem.findScalar(u8, slice, '\n')) |newline_index| slice[newline_index + 1 ..] else slice[slice.len..]; } return slice[finalLinesStart(slice, max_lines)..];}
fn readLogRange(alloc: Allocator, file: *std.Io.File, start: usize, len: usize) ![]u8 { if (len == 0) return alloc.dupe(u8, ""); var read_buf: [8192]u8 = undefined; var reader = file.reader(io_mod.getIo(), &read_buf); try reader.seekTo(start); const out = try alloc.alloc(u8, len); errdefer alloc.free(out); const read_len = try reader.interface.readSliceShort(out); if (read_len == out.len) return out; const resized = try alloc.realloc(out, read_len); return resized;}
fn firstLinesEnd(text: []const u8, max_lines: usize) usize { if (max_lines == 0) return 0;
var separator_count: usize = 0; for (text, 0..) |byte, i| { if (byte != '\n') continue; separator_count += 1; if (separator_count == max_lines) return i + 1; }
return text.len;}
fn finalLinesStart(text: []const u8, max_lines: usize) usize { if (max_lines == 0) return text.len;
var separator_count: usize = 0; var i = text.len; while (i > 0) { i -= 1; if (text[i] != '\n') continue; if (i == text.len - 1) continue;
separator_count += 1; if (separator_count == max_lines) return i + 1; }
return 0;}
fn writeAbsoluteFile(path: []const u8, text: []const u8) !void { var file = try std.Io.Dir.createFileAbsolute(io_mod.getIo(), path, .{ .truncate = true }); defer file.close(io_mod.getIo()); try file.writeStreamingAll(io_mod.getIo(), text);}
fn tmpPath(alloc: Allocator, tmp: std.testing.TmpDir, name: []const u8) ![]u8 { const root = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "."); defer alloc.free(root); return std.fs.path.join(alloc, &.{ root, name });}
test "parseTaskSelection accepts defaults and numeric ids and rejects malformed ids" { try std.testing.expectEqual(StopSelection.last, try parseTaskSelection("")); try std.testing.expectEqual(StopSelection.last, try parseTaskSelection(" \t ")); try std.testing.expectEqual(StopSelection.last, try parseTaskSelection("last")); try std.testing.expectEqual(StopSelection{ .id = 42 }, try parseTaskSelection("42"));
try std.testing.expectError(error.InvalidCharacter, parseTaskSelection("abc")); try std.testing.expectError(error.InvalidCharacter, parseTaskSelection("12abc"));}
test "taskStateLabel covers every task state" { try std.testing.expectEqualStrings("running", taskStateLabel(.running)); try std.testing.expectEqualStrings("exited", taskStateLabel(.exited)); try std.testing.expectEqualStrings("failed", taskStateLabel(.failed)); try std.testing.expectEqualStrings("stopped", taskStateLabel(.stopped)); try std.testing.expectEqualStrings("dead", taskStateLabel(.dead)); try std.testing.expectEqualStrings("stale", taskStateLabel(.stale));}
test "managed task log tail and summary read already open file" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.createDirPath(io_mod.getIo(), "logs"); const logs_dir = try io_mod.dirRealpathAlloc(alloc, tmp.dir, "logs"); defer alloc.free(logs_dir); var capability = try session_child_store.SessionChildCapability.initLegacyRoute( alloc, logs_dir, .background_logs, .writable, ); defer capability.deinit(); var file = try capability.createExclusiveFile( alloc, .background_logs, "managed.log", ); defer file.deinit(); try file.writeAll("one\ntwo\nthree\nfour\n"); try file.sync();
const tail = try readManagedTaskLogTail( alloc, &file, "managed.log", 64, 2, ); defer alloc.free(tail); try std.testing.expectEqualStrings("[logs] managed.log\nthree\nfour\n", tail);
const summary = try readManagedTaskLogSummary( alloc, &file, "managed.log", 8, 12, 2, ); defer alloc.free(summary); try std.testing.expectEqualStrings( "[logs] managed.log\nbytes=19\n<head>\none\ntwo\n</head>\n<tail>\nthree\nfour\n</tail>\n", summary, );}
test "background headless and interactive launch notices preserve distinct contracts" { const alloc = std.testing.allocator; const language = ConversationLanguage.default();
const with_url = try formatBackgroundCommandNotice(alloc, 7, .{ .pid = "100", .command = "npm run dev", .cwd = "/tmp/app", .log_path = "/tmp/fx-cmd.log", .url = "http://localhost:3000", .expect_url = true, }, language); defer alloc.free(with_url); try std.testing.expectEqualStrings("Background #7: server running at http://localhost:3000. Log: /tmp/fx-cmd.log", with_url);
const waiting = try formatBackgroundCommandNotice(alloc, 8, .{ .pid = "101", .command = "npm run dev", .cwd = "/tmp/app", .log_path = "/tmp/fx-cmd.log", .expect_url = true, }, language); defer alloc.free(waiting); try std.testing.expectEqualStrings("Background #8: server started. Waiting for local URL. Log: /tmp/fx-cmd.log", waiting);
const command = try formatBackgroundCommandNotice(alloc, 9, .{ .pid = "102", .command = "zig build test", .cwd = "/tmp/app", .log_path = "/tmp/fx-cmd.log", }, language); defer alloc.free(command); try std.testing.expectEqualStrings("Background #9: command started. Log: /tmp/fx-cmd.log", command);
const interactive = try backgroundLaunchNotice(alloc, 9, .{ .pid = "102", .command = "zig build test", .cwd = "/tmp/app", .log_path = "/tmp/fx-cmd.log", }, language); defer alloc.free(interactive.body); try std.testing.expectEqualStrings("background", interactive.topic); try std.testing.expectEqual(types.NoticeTone.neutral, interactive.tone); try std.testing.expectEqualStrings("Command #9 started. Log: /tmp/fx-cmd.log", interactive.body); try std.testing.expect(std.mem.find(u8, interactive.body, "Background") == null);}
test "background ready and completion notices own one semantic topic and outcome tone" { const alloc = std.testing.allocator; const language = ConversationLanguage.default();
const ready = try backgroundServerReadyNotice(alloc, 7, "http://localhost:3000", language); defer alloc.free(ready.body); try std.testing.expectEqualStrings("background", ready.topic); try std.testing.expectEqual(types.NoticeTone.neutral, ready.tone); try std.testing.expectEqualStrings("Command #7 server ready at http://localhost:3000.", ready.body);
const exited = try backgroundCompletionNotice(alloc, .{ .id = 7, .state = .exited, .exit_code = 0 }, language); defer alloc.free(exited.body); try std.testing.expectEqual(types.NoticeTone.neutral, exited.tone); try std.testing.expectEqualStrings("Command #7 completed successfully.", exited.body);
const failed_code = try backgroundCompletionNotice(alloc, .{ .id = 8, .state = .failed, .exit_code = 2 }, language); defer alloc.free(failed_code.body); try std.testing.expectEqual(types.NoticeTone.@"error", failed_code.tone); try std.testing.expectEqualStrings("Command #8 failed (exit 2).", failed_code.body);
const failed = try backgroundCompletionNotice(alloc, .{ .id = 9, .state = .failed, .exit_code = null }, language); defer alloc.free(failed.body); try std.testing.expectEqual(types.NoticeTone.@"error", failed.tone); try std.testing.expectEqualStrings("Command #9 failed.", failed.body);
const stopped = try backgroundCompletionNotice(alloc, .{ .id = 10, .state = .stopped, .exit_code = null }, language); defer alloc.free(stopped.body); try std.testing.expectEqual(types.NoticeTone.cancelled, stopped.tone); try std.testing.expectEqualStrings("Command #10 stopped.", stopped.body);
const dead = try backgroundCompletionNotice(alloc, .{ .id = 11, .state = .dead, .exit_code = null }, language); defer alloc.free(dead.body); try std.testing.expectEqual(types.NoticeTone.@"error", dead.tone); try std.testing.expectEqualStrings("Command #11 is no longer running.", dead.body);
const stale = try backgroundCompletionNotice(alloc, .{ .id = 12, .state = .stale, .exit_code = null }, language); defer alloc.free(stale.body); try std.testing.expectEqual(types.NoticeTone.@"error", stale.tone); try std.testing.expectEqualStrings("Command #12 is stale.", stale.body);
const running = try backgroundCompletionNotice(alloc, .{ .id = 13, .state = .running, .exit_code = null }, language); defer alloc.free(running.body); try std.testing.expectEqual(types.NoticeTone.neutral, running.tone); try std.testing.expectEqualStrings("Command #13 is running.", running.body);
inline for (.{ ready, exited, failed_code, failed, stopped, dead, stale, running }) |notice| { try std.testing.expectEqualStrings("background", notice.topic); try std.testing.expect(std.mem.find(u8, notice.body, "Background") == null); }}
test "readExternalTaskLogTail respects max_bytes and omits earlier content" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup();
const path = try tmpPath(alloc, tmp, "large.log"); defer alloc.free(path); try writeAbsoluteFile(path, "early-content\nmiddle-content\nlate-one\nlate-two\n");
const text = try readExternalTaskLogTail(alloc, path, 18, 10); defer alloc.free(text);
try std.testing.expect(std.mem.find(u8, text, "early-content") == null); try std.testing.expect(std.mem.find(u8, text, "middle-content") == null); try std.testing.expect(std.mem.find(u8, text, "late-two") != null);}
test "readExternalTaskLogTail respects max_lines and drops partial first line" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup();
const path = try tmpPath(alloc, tmp, "lines.log"); defer alloc.free(path); try writeAbsoluteFile(path, "alpha-should-drop\nbeta\ncharlie\ndelta\necho\n");
const text = try readExternalTaskLogTail(alloc, path, 21, 2); defer alloc.free(text);
const expected = try std.fmt.allocPrint(alloc, "[logs] {s}\ndelta\necho\n", .{path}); defer alloc.free(expected); try std.testing.expectEqualStrings(expected, text);}
test "readExternalTaskLogTail returns useful error for missing log file" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup();
const path = try tmpPath(alloc, tmp, "missing.log"); defer alloc.free(path); try std.testing.expectError( error.FileNotFound, readExternalTaskLogTail(alloc, path, 1024, 40), );}
test "readExternalTaskLogSummary includes head tail bytes and path" { const alloc = std.testing.allocator; var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup();
const path = try tmpPath(alloc, tmp, "long.log"); defer alloc.free(path); try writeAbsoluteFile(path, "head-one\nhead-two\nmiddle-one\nmiddle-two\ntail-one\ntail-two\n");
const text = try readExternalTaskLogSummary(alloc, path, 18, 18, 2); defer alloc.free(text);
try std.testing.expect(std.mem.find(u8, text, "[logs] ") != null); try std.testing.expect(std.mem.find(u8, text, "bytes=") != null); try std.testing.expect(std.mem.find(u8, text, "<head>") != null); try std.testing.expect(std.mem.find(u8, text, "head-one") != null); try std.testing.expect(std.mem.find(u8, text, "<tail>") != null); try std.testing.expect(std.mem.find(u8, text, "tail-two") != null);}