summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-29 10:48:56 -0300
committerGabriel Schneider <[email protected]>2026-10-29 12:01:27 -0300
commit4ffe5c93b3087f245f5b57a822ab0ecf41cc085c (patch)
treeede4d5de12fe169838f1f5993a9896bd32f45715 /src
parentcb2a6cd79e443d671f5255d262ea79b7e26552a5 (diff)
downloadpardes-4ffe5c93b3087f245f5b57a822ab0ecf41cc085c.tar.gz
pardes-4ffe5c93b3087f245f5b57a822ab0ecf41cc085c.zip
sessions register with the daemon: a terminal's session forked off its stub, Detach and --attach in place for terminals and windows, pty masters kept, Adopt
pardes in a terminal reaches (or starts) the daemon, opens /dev/tty and forks: the child is the session, in a session of its own (setsid), drawing on that terminal (tty.Term.fd, a raw vaxis Tty made from the fd); the parent stays as its stub, the job the shell waits on. Not the daemon spawning it from a passed fd, env and argv: the user's terminals each run in a 9ns user and mount namespace, which a session spawned by a per-user daemon would not share, and a fork costs one small process's page tables where the spawn cost an IPC and an exec. GUI windows and --detach sessions just register. tty: Detach (and a terminal's end: EOF, EIO, a hangup the stub passes on, taken on the signal thread) puts the terminal back, drops it and the stub's stdio, tells the stub (which ends, exit 0), and leaves the session running with nothing drawn (Host.watched), its messages on the clock and `size` its own. pardes --attach[=name] hands its terminal through the daemon; the session enters it as the first one, sized, queried and drawn whole, and that process is its stub until it leaves. A hangup never ends a kept session; TERM and INT do, telling the daemon so the shells go with it (one async-signal-safe send). gui: Detach closes the window (its swapchain or renderer) and keeps the device, atlas and pipelines; the loop sleeps on SDL's queue; pardes-gui --attach[=name] opens a window again. Closing a window still quits. --detach is a session started detached: the tty host with no terminal yet, the GUI with a hidden window closed at once. forkShell sends the daemon a dup of every master and the hosts tell it what they close, so a session killed outright leaves its shells running; the new Adopt word takes them in as terminal panes (the Tty word's pane, its spawn taking the pty, a 1x1 size then the pane's to make it redraw). The Attach word, which switched a session's own terminal to a detached session through the frames, goes, with its effect and request in the core. PARDES_DAEMON=off (the e2e harness's) runs a session as before. test/daemon.py: 50 detach/attach cycles at a level fd count with no stale socket, kill -9 and Adopt, and nothing left; --gui the same for a window. test/fs.py: a forked session's socket is found by its own pid, and a hangup leaves a kept session running. Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src')
-rw-r--r--src/9p_io.zig22
-rw-r--r--src/builtins.zig49
-rw-r--r--src/config.zig4
-rw-r--r--src/file_watch.zig2
-rw-r--r--src/gui/gui.zig487
-rw-r--r--src/host_io.zig37
-rw-r--r--src/macos.zig3
-rw-r--r--src/main.zig137
-rw-r--r--src/pardes.zig72
-rw-r--r--src/tty/tty.zig650
-rw-r--r--src/tutor.txt4
11 files changed, 728 insertions, 739 deletions
diff --git a/src/9p_io.zig b/src/9p_io.zig
index a089a7cf..2a0061fd 100644
--- a/src/9p_io.zig
+++ b/src/9p_io.zig
@@ -975,13 +975,14 @@ pub fn unlinkOwnSocket() void {
_ = libc.unlink(own_socket[0..n :0]);
}
-/// SIGTERM and SIGHUP with no handler of their own (a GUI's): the socket
-/// goes, then the signal's own death. A host that handles them itself (the
-/// terminal's Killed, the detached server's quit) removes it its own way.
+/// SIGTERM, SIGHUP and SIGINT with no handler of their own (a GUI's, a
+/// detached session's): the socket goes, then the signal's own death. A
+/// host that handles them itself (the terminal's Killed, SDL's quit)
+/// removes it its own way.
fn armSocketCleanup() void {
const sig = std.posix.SIG;
const on: std.posix.Sigaction = .{ .handler = .{ .handler = onFatalSignal }, .mask = std.posix.sigemptyset(), .flags = std.posix.SA.RESETHAND };
- for ([_]std.posix.SIG{ sig.TERM, sig.HUP }) |s| {
+ for ([_]std.posix.SIG{ sig.TERM, sig.HUP, sig.INT }) |s| {
var was: std.posix.Sigaction = undefined;
std.posix.sigaction(s, null, &was);
if (was.handler.handler == sig.DFL) std.posix.sigaction(s, &on, null);
@@ -995,6 +996,8 @@ pub var fatal_cleanup: ?*const fn () void = null;
fn onFatalSignal(s: std.posix.SIG) callconv(.c) void {
unlinkOwnSocket();
if (fatal_cleanup) |cleanup| cleanup();
+ // Its shells go with it, the daemon's dups let go.
+ @import("daemon.zig").hangUp();
// SA_RESETHAND put the default back: the same signal, now fatal.
_ = std.c.raise(s);
}
@@ -1204,6 +1207,17 @@ pub fn listen(io: std.Io, gpa: std.mem.Allocator, core: *pardes.Pardes, named: [
const alive = transport.isListening;
+/// Whether a live session listens under `name` already: a second
+/// `--detach=<name>` is refused before anything is made.
+pub fn taken(name: []const u8) bool {
+ if (comptime !supported) return false;
+ var dir_buf: [sun_path_len:0]u8 = undefined;
+ const dir = socketDir(&dir_buf) orelse return false;
+ var buf: [sun_path_len]u8 = undefined;
+ const p = socketPath(&buf, dir, name) orelse return false;
+ return statNoFollow(p) != null and alive(p);
+}
+
/// What is at a socket path, in cloud9's three answers (`post.Probe`).
/// Asked here with libc rather than through `cloud9.post.probe`, whose
/// raw Linux syscalls darwin cannot compile, but the classification is
diff --git a/src/builtins.zig b/src/builtins.zig
index 1f1e674e..3a66a316 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -737,51 +737,28 @@ pub const Restore = struct {
}
};
-/// Attach this terminal to a detached pardes session by name.
-pub const Attach = struct {
+/// Detach this pardes from its terminal or window, leaving the session
+/// running: `pardes --attach` (or `pardes-gui --attach`) takes it back.
+pub const Detach = struct {
pub const scope: Scope = .session;
- pub const takes_arg = true;
pub const enabled = pardes.can_attach;
pub fn run(c: Ctx) void {
- if (comptime enabled) ask(c) else unreachable;
- }
- fn ask(c: Ctx) void {
- const name = std.mem.trim(u8, c.arg orelse "", " \t\r\n");
- if (name.len > pardes.attach_name_max)
- return c.p.reportError(c.id, comptime word(@This()), error.NameTooLong);
- // A detached session has no terminal to move: bare, there is no
- // "the one session there" but itself; a name is said for what it is.
- if (c.p.opts.detached_session) {
- if (name.len == 0) return c.p.reportFailure(c.id, "wrong #args in control message \"Attach\": a detached session names the session");
- // A session is its socket, `pardes-detached-<name>.sock` beside
- // the 9P ones (detached/server.zig socketPath); not imported, as
- // the core links no frontend's code.
- const ninep_io = @import("9p_io.zig");
- var dir_buf: [ninep_io.sun_path_len:0]u8 = undefined;
- var path_buf: [ninep_io.sun_path_len + 64:0]u8 = undefined;
- const exists = if (ninep_io.socketDir(&dir_buf)) |dir|
- (if (std.fmt.bufPrintSentinel(&path_buf, "{s}/pardes-detached-{s}.sock", .{ dir, name }, 0)) |path| ninep_io.statNoFollow(path) != null else |_| false)
- else
- false;
- var said: [pardes.attach_name_max + 96]u8 = undefined;
- return c.p.reportFailure(c.id, if (exists)
- std.fmt.bufPrint(&said, "Attach: {s}: a detached session has no terminal to attach; Attach from a frontend", .{name}) catch "Attach: a detached session has no terminal to attach"
- else
- std.fmt.bufPrint(&said, "Attach: {s}: no such session", .{name}) catch "Attach: no such session");
- }
- c.p.emit(.{ .attach = .{ .pane = @intCast(c.id), .name = .from(name) } });
+ if (comptime enabled)
+ c.p.emit(.{ .detach = .{ .pane = @intCast(c.id) } })
+ else
+ unreachable;
}
};
-/// Detach this pardes from its terminal, leaving the session running.
-pub const Detach = struct {
+/// Take in the shells of a session that died holding them, each as a
+/// terminal pane here: the pardes daemon kept their terminals open.
+pub const Adopt = struct {
pub const scope: Scope = .session;
pub const enabled = pardes.can_attach;
pub fn run(c: Ctx) void {
- if (comptime enabled)
- c.p.emit(.{ .detach = .{ .pane = @intCast(c.id) } })
- else
- unreachable;
+ if (comptime !enabled) unreachable;
+ const adopt = c.p.host.vtable.adopt orelse return c.p.reportFailure(c.id, "Adopt: no pardes daemon is keeping shells for this session");
+ adopt(c.p.host.ctx, @intCast(c.id));
}
};
diff --git a/src/config.zig b/src/config.zig
index 988f634d..66b11c72 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -217,8 +217,8 @@ pub const leader_path = paths: {
table.set(.Unmount, null);
}
if (pardes.can_attach) {
- table.set(.Attach, "sa");
table.set(.Detach, "sD");
+ table.set(.Adopt, null);
}
if (builtins.Peek.enabled) {
table.set(.Peek, null);
@@ -2306,6 +2306,8 @@ test "docs/typ names only words, keys and default tags that exist" {
var dir = try std.Io.Dir.cwd().openDir(io, @import("doc_typ").dir, .{ .iterate = true });
defer dir.close(io);
var found: [3]std.ArrayList([]const u8) = @splat(.empty);
+ // The arena's: gone with this test, so no later test reads it.
+ defer doc_typ.other_build = "";
for ([_][]const u8{ "builtins-tty.json", "builtins-gui.json" }) |f| {
const text = dir.readFileAlloc(io, f, gpa, .limited(1 << 20)) catch continue;
doc_typ.other_build = try std.mem.concat(gpa, u8, &.{ doc_typ.other_build, text });
diff --git a/src/file_watch.zig b/src/file_watch.zig
index ab902e5b..e3fe9963 100644
--- a/src/file_watch.zig
+++ b/src/file_watch.zig
@@ -98,7 +98,7 @@ const wake_ident: usize = std.math.maxInt(usize);
///
/// `polled` is the only flag that survives the port. On linux it adds
/// IN_NONBLOCK, because a host that finds this descriptor ready in its own
-/// `poll(2)` (detached/server.zig) must be able to stop draining it, while a
+/// `poll(2)` must be able to stop draining it, while a
/// host that parks a thread in `wait` (tty.zig, gui.zig) wants the blocking
/// read. On macos neither host needs either flag: a kqueue is not inherited
/// across `fork(2)`, so there is no CLOEXEC to ask for, and whether a wait
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 01272b41..a1590b48 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -22,7 +22,7 @@ const c_heap = @import("c_heap");
const ninep_io = @import("../9p_io.zig");
-const detached_client = @import("../detached/client.zig");
+const daemon = @import("../daemon.zig");
const tracy = @import("../tracy.zig");
pub const c = @import("gui_c"); // SDL3 and font.h, translated by build.zig
@@ -1434,8 +1434,6 @@ const Gui = struct {
tagline_percent: u8,
tagline_width: u32,
tagline_height: u32,
- attached_layers: ?*const [pardes.MAX_PANES]pardes.Layer = null,
- attached_tag_layers: ?*const [pardes.MAX_TAG_LAYERS]pardes.Layer = null,
cell_w: u32,
cell_h: u32,
ascent: i32,
@@ -1533,6 +1531,14 @@ const Gui = struct {
applied_window_opacity: u8 = 100,
soft_renderer: ?*c.SDL_Renderer = null,
soft_texture: ?*c.SDL_Texture = null,
+ /// What a window is opened again with (reopenWindow): the flags (not
+ /// hidden), the present mode, its size when it was closed.
+ win_flags: c.SDL_WindowFlags = 0,
+ present_mode: c.SDL_GPUPresentMode = c.SDL_GPU_PRESENTMODE_VSYNC,
+ window_w: c_int = 1120,
+ window_h: c_int = 720,
+ /// The window runNative destroys at the end: the one open then, if any.
+ window_slot: ?*?*c.SDL_Window = null,
soft_tex_w: u32 = 0,
soft_tex_h: u32 = 0,
@@ -1895,16 +1901,10 @@ fn setTransitionFields(
pub const run = runNative;
-fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u8) !void {
+fn runNative(init: std.process.Init, opts_in: pardes.Options, headless: bool) !void {
const gpa = init.gpa;
const env = init.environ_map;
- if (env.get("PARDES_TEST_GRID") != null) {
- if (attach != null) {
- log.err("--attach needs a window; PARDES_TEST_GRID is headless", .{});
- return error.AttachNeedsWindow;
- }
- return runGrid(init, opts_in);
- }
+ if (env.get("PARDES_TEST_GRID") != null) return runGrid(init, opts_in);
const test_mode = env.get("PARDES_TEST") != null;
const capture_dir = env.get("PARDES_TEST_CAPTURE_DIR");
@@ -1950,6 +1950,9 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
// opacity would dim the text as well. SDL requires this flag at creation.
const surface_opacity = native_wayland;
if (surface_opacity) win_flags |= c.SDL_WINDOW_TRANSPARENT;
+ const reopen_flags = win_flags;
+ // `--detach`: a window never shown, closed once the session is up.
+ if (headless) win_flags |= c.SDL_WINDOW_HIDDEN;
// `--geometry=WxH[+X+Y]`, as X11 programs take it.
var want_w: c_int = 1120;
var want_h: c_int = 720;
@@ -1969,7 +1972,8 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
log.err("SDL_CreateWindow: {s}", .{c.SDL_GetError()});
return error.SdlInit;
};
- defer c.SDL_DestroyWindow(window);
+ var window_slot: ?*c.SDL_Window = window;
+ defer if (window_slot) |open| c.SDL_DestroyWindow(open);
if (want_at) |at| _ = c.SDL_SetWindowPosition(window, at[0], at[1]);
updateDisplayScale(window);
if (native_wayland) log.info("Wayland opacity: background-only transparent surface", .{});
@@ -2173,6 +2177,11 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.demo_next = if (env.get("PARDES_FRAMES_DEMO")) |name| (if (pardes.FrameStats.named(name) != null) @as(?usize, 0) else null) else null,
.surface_opacity = surface_opacity,
.soft_renderer = soft_renderer,
+ .win_flags = reopen_flags,
+ .present_mode = present_mode,
+ .window_w = want_w,
+ .window_h = want_h,
+ .window_slot = &window_slot,
};
// The pipelines, textures and buffers the Gui holds, whatever they were
// regrown to; the image ones are released below.
@@ -2221,10 +2230,48 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
// compositor moves it, as it does a title bar.
if (!test_mode and !c.SDL_SetWindowHitTest(window, hitTest, &g))
log.warn("SDL_SetWindowHitTest: {s}", .{c.SDL_GetError()});
- if (attach) |requested| return attachRequested(gpa, &g, requested);
- var attached: ?detached_client.Client = null;
- try localSession(init, &g, opts_in, test_mode, &attached);
- if (attached) |*client| return attachedLoop(gpa, &g, client);
+ try localSession(init, &g, opts_in, test_mode, headless);
+}
+
+/// Detach: the window closed (and with it its swapchain or renderer); the
+/// device, the atlas and the pipelines stay for the next one.
+fn closeWindow(g: *Gui) void {
+ _ = c.SDL_GetWindowSize(g.window, &g.window_w, &g.window_h);
+ _ = c.SDL_StopTextInput(g.window);
+ if (g.soft_renderer) |renderer| {
+ if (g.soft_texture) |texture| c.SDL_DestroyTexture(texture);
+ g.soft_texture = null;
+ g.soft_tex_w = 0;
+ g.soft_tex_h = 0;
+ c.SDL_DestroyRenderer(renderer);
+ g.soft_renderer = null;
+ } else c.SDL_ReleaseWindowFromGPUDevice(g.device, g.window);
+ c.SDL_DestroyWindow(g.window);
+ if (g.window_slot) |slot| slot.* = null;
+}
+
+/// `pardes-gui --attach`: a window again, as the first was made, at the
+/// size the last one had. False when the display will not give one.
+fn reopenWindow(g: *Gui) bool {
+ const window = c.SDL_CreateWindow("pardes", g.window_w, g.window_h, g.win_flags) orelse return false;
+ if (g.soft_present) {
+ g.soft_renderer = c.SDL_CreateRenderer(window, null) orelse {
+ c.SDL_DestroyWindow(window);
+ return false;
+ };
+ } else {
+ if (!c.SDL_ClaimWindowForGPUDevice(g.device, window)) {
+ c.SDL_DestroyWindow(window);
+ return false;
+ }
+ _ = c.SDL_SetGPUSwapchainParameters(g.device, window, c.SDL_GPU_SWAPCHAINCOMPOSITION_SDR, g.present_mode);
+ }
+ g.window = window;
+ if (g.window_slot) |slot| slot.* = window;
+ updateDisplayScale(window);
+ if (!g.capture) _ = c.SDL_SetWindowHitTest(window, hitTest, g);
+ _ = c.SDL_StartTextInput(window);
+ return true;
}
fn localSession(
@@ -2232,7 +2279,7 @@ fn localSession(
g: *Gui,
opts_in: pardes.Options,
test_mode: bool,
- attached: *?detached_client.Client,
+ headless: bool,
) !void {
const io = init.io;
const gpa = init.gpa;
@@ -2359,25 +2406,19 @@ fn localSession(
defer pardes.lsp.setStatusSink(null, null);
host_io.setExitWake(&queue, Queue.wakeForExit);
defer host_io.setExitWake(null, null);
+ if (headless) {
+ shell.closeTheWindow();
+ // Nothing else may wake the first wait.
+ daemon.watch(&queue, deliverNote);
+ }
while (!core.quit) {
pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
+ // A window asked for again, or an adopted shell, from the daemon's
+ // thread through the queue; started after the first frame.
+ daemon.watch(&queue, deliverNote);
if (core.quit) break; // a session that ended does not restore into one
- if (core.takeAttach()) |req| {
- const geom = windowCells(g);
- const outcome = detached_client.attempt(gpa, req.name, geom.cols, geom.rows);
- switch (outcome) {
- .greeted => |client| {
- attached.* = client;
- break;
- },
- else => {
- var mbuf: [256]u8 = undefined;
- core.setMessage(req.pane, attachFailure(&mbuf, outcome, req.name));
- },
- }
- }
if (core.takeRestore()) |rp| blk: {
const bytes = filesystem.readRestore(gpa, rp, core.settings.dump_dir.get()) catch |err| {
core.reportError(core.active, "Restore", err);
@@ -2426,198 +2467,6 @@ fn localSession(
}
}
-fn attachFailure(buf: []u8, outcome: detached_client.Attempt, requested: []const u8) []const u8 {
- return switch (outcome) {
- .greeted => unreachable,
- .no_session => if (requested.len != 0)
- std.fmt.bufPrint(buf, "Attach: no detached session called '{s}'", .{requested}) catch
- "Attach: no detached session under that name"
- else
- "Attach: nothing is detached (start one with `pardes --detach`)",
- .ambiguous => |n| std.fmt.bufPrint(buf, "Attach: {d} detached sessions; say which one", .{n}) catch
- "Attach: several detached sessions; say which one",
- .refused => |why| switch (why) {
- .version => "Attach: that session speaks a different wire version — it is another build of pardes",
- .full => "Attach: that session already has every frontend slot taken",
- .quitting => "Attach: that session is ending",
- },
- .silent => "Attach: that session took the connection and never greeted us",
- .lost => |err| std.fmt.bufPrint(buf, "Attach: lost the connection ({t})", .{err}) catch
- "Attach: lost the connection",
- };
-}
-
-fn attachRequested(gpa: std.mem.Allocator, g: *Gui, requested: []const u8) !void {
- const geom = windowCells(g);
- const outcome = detached_client.attempt(gpa, requested, geom.cols, geom.rows);
- switch (outcome) {
- .greeted => |greeted| {
- var client = greeted;
- return attachedLoop(gpa, g, &client);
- },
- else => {
- var mbuf: [256]u8 = undefined;
- log.err("{s}", .{attachFailure(&mbuf, outcome, requested)});
- return switch (outcome) {
- .no_session => error.NoSession,
- .ambiguous => error.AmbiguousSession,
- .refused => error.Refused,
- .silent => error.NoGreeting,
- .lost => |err| err,
- .greeted => unreachable,
- };
- },
- }
-}
-
-fn attachedResize(client: *detached_client.Client, g: *const Gui, cols: u16, rows: u16) !void {
- try client.send(.{ .event = .{ .resize = .{ .cols = cols, .rows = rows, .row_metrics = .{
- .body_w = @intCast(g.cell_w),
- .body_h = @intCast(g.cell_h),
- .tagline_w = @intCast(g.tagline_width),
- .tagline_h = @intCast(g.tagline_height),
- } } } });
-}
-
-fn attachedLoop(gpa: std.mem.Allocator, g: *Gui, client: *detached_client.Client) !void {
- defer client.detach();
- _ = c.SDL_StartTextInput(g.window);
-
- var in: Input = .{ .client = client };
- g.attached_layers = &client.body_layers;
- g.attached_tag_layers = &client.tag_layers;
- var dirty = false;
- var geom = windowCells(g);
- try attachedResize(client, g, geom.cols, geom.rows);
- while (true) {
- const link = client.wait(detached_client.poll_ms);
- while (true) {
- const msg = (try client.next()) orelse break;
- switch (msg) {
- .welcome => {},
- .refuse => |why| {
- log.err("session refused an already-greeted frontend: {t}", .{why});
- return error.Refused;
- },
- .frame => dirty = true,
- .quit => return,
- .detach => return,
- .set_clipboard => |text| putClipboard(gpa, text),
- .read_clipboard => if (takeClipboard()) |text| {
- defer c.SDL_free(text.ptr);
- in.post(.{ .paste = text });
- },
- .open_link => |url| look.openLink(url),
- .post => dirty = true,
- }
- }
- try link;
-
- var sev = std.mem.zeroes(c.SDL_Event);
- while (c.SDL_PollEvent(&sev)) dispatch(g, &in, &sev);
- pollGamepad(g, &in);
- if (in.lost) |err| return err;
- if (in.quit) return;
-
- const now = windowCells(g);
- if (now.cols != geom.cols or now.rows != geom.rows) {
- geom = now;
- try attachedResize(client, g, now.cols, now.rows);
- }
- // The session's chain, its files compiled there.
- g.post.sync(gpa, g.device, g.swapchain_format, client.post.list(), client.post_key, null);
- if (!dirty) {
- // As a local window does: a chain that moves on its own redraws
- // alone, once a refresh.
- if (g.post.animating(client.post.animation) and g.scene_tex != null and
- c.SDL_GetTicksNS() -| g.post.last_ns + std.time.ns_per_ms >= refreshNs(g)) redrawPost(g, gpa);
- continue;
- }
- dirty = false;
- paintAttached(g, gpa, client);
- }
-}
-
-fn paintAttached(g: *Gui, gpa: std.mem.Allocator, client: *detached_client.Client) void {
- var surface = attachedSurface(client);
- _ = renderFrame(
- g,
- gpa,
- null,
- &surface,
- false,
- ) catch |err| blk: {
- log.err("render: {t}", .{err});
- break :blk false;
- };
-}
-
-/// The session's frame as a surface: its cells, layers, regions and palette,
-/// so its chrome is drawn from them as a local one's is.
-fn attachedSurface(client: *const detached_client.Client) pardes.Surface {
- var surface: pardes.Surface = .{
- .cols = client.cols,
- .rows = client.rows,
- .cells = client.grid.items,
- .cursor = if (client.cursor) |cu| .{ .x = cu.x, .y = cu.y, .bar = cu.bar } else null,
- .pointer_shape = client.pointer_shape,
- .body_layers = client.body_layers,
- .tag_layers = client.tag_layers,
- .chrome = client.chrome,
- };
- const placed = client.regions.items[0..@min(client.regions.items.len, surface.regions.len)];
- @memcpy(surface.regions[0..placed.len], placed);
- surface.nregions = @intCast(placed.len);
- return surface;
-}
-
-test "an attached frontend draws the session's chrome from its frame alone" {
- const gpa = std.testing.allocator;
- const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
- defer core.deinit();
- // A gui-shaped core, whose tags and notices are layers.
- core.update(.{ .resize = .{ .cols = 80, .rows = 24, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 6, .tagline_h = 12 } } });
- _ = try core.newShell(1, "");
- try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
- core.settings.focus_tint = true;
- try std.testing.expect(core.executeBuiltinLine(0, "Msg a notice with a rule under it"));
- core.sync();
- // Past its slide into place, where its rule shows.
- for (0..30) |_| core.update(.tick);
- const s = try core.render(core.scratch.allocator());
-
- const wire = @import("../detached/wire.zig");
- var client: detached_client.Client = .{ .gpa = gpa };
- defer client.deinit();
- var welcome: [64]u8 = undefined;
- try client.in.appendSlice(gpa, try wire.encodeServer(&welcome, .{ .welcome = .{ .slot = 0, .cols = s.cols, .rows = s.rows } }));
- const out = try gpa.alloc(u8, wire.frameBound(s.cols, s.rows) + wire.layersBound(&s.body_layers, &s.tag_layers, s.regionList()));
- defer gpa.free(out);
- try client.in.appendSlice(gpa, try wire.encodeFrameLayers(out, s.cols, s.rows, null, s.pointer_shape, s.cells, &.{}, &s.body_layers, &s.tag_layers, s.regionList(), s.chrome));
- _ = try client.next();
- _ = try client.next();
- const attached = attachedSurface(&client);
-
- var g: Gui = undefined;
- g.cell_w = 10;
- g.cell_h = 20;
- g.tagline_width = 6;
- g.tagline_height = 12;
- g.decor = .empty;
- g.glide = .{};
- g.scroll_pane = null;
- g.scroll_lag = 0;
- defer g.decor.deinit(gpa);
- var groups = makeGroups(&.{}, false);
- try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
- const local = try gpa.dupe(CellInstance, g.decor.items);
- defer gpa.free(local);
- try std.testing.expect(local.len > 8);
- try std.testing.expect(groups.items[groups.notices].decor_count != 0);
- try buildDecor(&g, gpa, &attached, &groups, fixedCellLayout(&g), 800, 480, true);
- try std.testing.expectEqualSlices(u8, std.mem.sliceAsBytes(local), std.mem.sliceAsBytes(g.decor.items));
-}
-
fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const io = init.io;
const gpa = init.gpa;
@@ -2691,6 +2540,7 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
.inotify_fd = -1,
.watches = &watches,
.fs = fs,
+ .grid = true,
};
defer shell.shutdownPtys();
const host = shell.host();
@@ -3125,18 +2975,10 @@ test "the window's function and editing keys reach a terminal as its cursor keys
const Input = struct {
core: ?*pardes.Pardes = null,
- client: ?*detached_client.Client = null,
quit: bool = false,
- lost: ?anyerror = null,
fn post(in: *Input, ev: pardes.Event) void {
if (in.core) |core| return core.update(ev);
- const client = in.client orelse return;
- if (in.lost != null) return;
- client.send(.{ .event = ev }) catch |err| switch (err) {
- error.Overlong, error.WriteFailed => {},
- else => in.lost = err,
- };
}
fn close(in: *Input) void {
@@ -3526,18 +3368,6 @@ fn gridCellAtPixels(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32)
break;
}
};
- if (core == null) if (g.attached_layers) |layers| for (layers) |*layer| {
- if (layer.bodyHit(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |body_hit| {
- point.body_hit = body_hit;
- break;
- }
- };
- if (core == null) if (g.attached_tag_layers) |layers| for (layers) |*layer| {
- if (layer.tagHit(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
- point.tag_hit = hit;
- break;
- }
- };
return point;
}
@@ -3805,7 +3635,17 @@ fn pollGamepad(g: *Gui, in: *Input) void {
const Shell = struct {
core: *pardes.Pardes,
+ /// The window's, while one is open; null while detached (`parked` has
+ /// it) and in the headless test grid.
gui: ?*Gui = null,
+ parked: ?*Gui = null,
+ /// The headless test grid (runGrid): its own loop, no window ever.
+ grid: bool = false,
+ /// Shells a dead session left (Adopt), each waiting for the spawn of
+ /// the terminal pane made for it.
+ adoptions: [pardes.MAX_PANES]Adoption = undefined,
+ adoptions_len: usize = 0,
+ adopted: usize = 0,
io: std.Io,
gpa: std.mem.Allocator,
fs: ?*ninep_io.Listener = null,
@@ -3863,6 +3703,7 @@ const Shell = struct {
}
_ = libc.close(pt.fd);
pt.fd = -1;
+ daemon.closed(pt.pid);
const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
host_io.reapRetired(&pt.pid, &pt.kill_at, now);
if (pt.pid == 0) {
@@ -3917,7 +3758,83 @@ const Shell = struct {
}
fn host(s: *Shell) pardes.Host {
- return .{ .ctx = s, .vtable = if (s.gui == null) &grid_vtable else &vtable };
+ return .{ .ctx = s, .vtable = if (s.grid) &grid_vtable else &vtable };
+ }
+
+ /// Detach: the window closed, the session left running with no
+ /// window, for `pardes-gui --attach` to open one again.
+ fn detachWindow(ctx: ?*anyopaque) void {
+ const s = shellOf(ctx);
+ if (s.gui == null) return s.core.reportFailure(s.core.active, "Detach: no window is open");
+ if (!daemon.kept()) return s.core.reportFailure(s.core.active, "Detach: no pardes daemon keeps this session; closing its window ends it");
+ s.closeTheWindow();
+ }
+
+ fn closeTheWindow(s: *Shell) void {
+ const g = s.gui orelse return;
+ closeWindow(g);
+ s.parked = g;
+ s.gui = null;
+ s.presented = false;
+ s.surface = null;
+ s.core.unattended = true;
+ daemon.setState(true);
+ }
+
+ fn openTheWindow(s: *Shell) void {
+ const g = s.parked orelse return;
+ if (!reopenWindow(g)) {
+ log.err("--attach: no window: {s}", .{c.SDL_GetError()});
+ return daemon.setState(true);
+ }
+ s.gui = g;
+ s.parked = null;
+ s.core.unattended = false;
+ s.core.needs_frame = true;
+ resetScroll(g);
+ daemon.setState(false);
+ }
+
+ fn watched(ctx: ?*anyopaque) bool {
+ return shellOf(ctx).gui != null;
+ }
+
+ fn adopt(ctx: ?*anyopaque, pane: u8) void {
+ const s = shellOf(ctx);
+ if (!daemon.kept()) return s.core.reportFailure(pane, "Adopt: no pardes daemon is keeping shells for this session");
+ s.adopted = 0;
+ daemon.adopt();
+ }
+
+ /// One shell of a dead session (`pid` 0: the last of them was told):
+ /// a terminal pane made for it, as the Tty word makes one, whose spawn
+ /// takes this pty (spawnPane).
+ fn adoptShell(s: *Shell, pid: libc.pid_t, fd: c_int) void {
+ const core = s.core;
+ if (pid == 0) {
+ var buf: [96]u8 = undefined;
+ return core.setMessage(core.active, if (s.adopted == 0) "Adopt: no shell of a session that died is waiting" else std.fmt.bufPrint(&buf, "Adopt: {d} shell{s} taken in; what they showed is gone", .{ s.adopted, if (s.adopted == 1) "" else "s" }) catch "Adopt: shells taken in");
+ }
+ var newest: u32 = 0;
+ for (core.panes) |slot| if (slot) |pn| {
+ newest = @max(newest, pn.serial);
+ };
+ if (s.adoptions_len < s.adoptions.len) {
+ s.adoptions[s.adoptions_len] = .{ .pid = pid, .fd = fd, .pane = null };
+ s.adoptions_len += 1;
+ _ = core.executeBuiltinLine(core.active, "Tty");
+ for (core.panes, 0..) |slot, id| if (slot) |pn| if (pn.serial > newest and pn.isTerminal()) {
+ // Its shell is up already: nothing to greet with `ls`.
+ pn.greet = false;
+ s.adoptions[s.adoptions_len - 1].pane = @intCast(id);
+ s.adopted += 1;
+ return;
+ };
+ s.adoptions_len -= 1;
+ }
+ _ = libc.close(fd);
+ var buf: [96]u8 = undefined;
+ core.setMessage(core.active, std.fmt.bufPrint(&buf, "Adopt: no room for shell {d}; it ends with this session", .{pid}) catch "Adopt: no room for a shell");
}
const vtable: pardes.Host.VTable = .{
@@ -3926,6 +3843,9 @@ const Shell = struct {
.present = present,
.post_present = postPresent,
.poll_frame = pollFrame,
+ .watched = watched,
+ .detach = detachWindow,
+ .adopt = adopt,
.spawn = spawnPane,
.pty_write = ptyWrite,
.pty_resize = ptyResize,
@@ -3957,6 +3877,9 @@ const Shell = struct {
v.post_present = gridPostPresent;
v.set_clipboard = null;
v.read_clipboard = null;
+ v.watched = null;
+ v.detach = null;
+ v.adopt = null;
break :vt v;
};
@@ -4051,6 +3974,14 @@ const Shell = struct {
},
.files_changed => check_files = true,
.fs_ready => {},
+ .window => {
+ s.openTheWindow();
+ s.saw_event = true;
+ },
+ .adopted => |a| {
+ s.adoptShell(a.pid, a.fd);
+ s.saw_event = true;
+ },
};
if (check_files) s.shaders.recheck();
if (check_files and file_watch.reloadChanged(s.core, s.io, s.gpa, s.watches))
@@ -4214,7 +4145,7 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
}
s.paced_ns = if (paced) tick else null;
if (paced) g.pace_ns = tick;
- }
+ } else waitDetached(core, timeout_ms);
if (s.test_mode) {
const r = s.feed.pump(s.gpa, &in, s.gui) catch {
core.quit = true;
@@ -4229,6 +4160,26 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
if (s.gui) |g| pollGamepad(g, &in);
}
+/// Detached: no window, asleep until the queue's wake (an SDL user event:
+/// a pty's output, the daemon's window request), the core's next wake, or a
+/// quit (SDL makes SIGTERM and SIGINT one). With nobody to dismiss them,
+/// messages go on the clock.
+fn waitDetached(core: *pardes.Pardes, timeout_ms: u32) void {
+ pardes.Messages.expireUnattended(core);
+ var ms: c_int = if (timeout_ms != 0) @intCast(@min(timeout_ms, std.math.maxInt(c_int))) else -1;
+ for (core.panes) |slot| if (slot) |pane| if (pane.msg_len > 0) {
+ ms = if (ms < 0) 100 else @min(ms, 100);
+ break;
+ };
+ var sev = std.mem.zeroes(c.SDL_Event);
+ pardes.turn.rest();
+ var got = c.SDL_WaitEventTimeout(&sev, ms);
+ pardes.turn.wake();
+ while (got) : (got = c.SDL_PollEvent(&sev)) {
+ if (sev.type == c.SDL_EVENT_QUIT) core.quit = true;
+ }
+}
+
fn pollFrame(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
s.reconcilePtys();
@@ -4545,6 +4496,11 @@ fn gridPostPresent(ctx: ?*anyopaque) void {
fn spawnPane(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
const s = shellOf(ctx);
s.reap();
+ for (s.adoptions[0..s.adoptions_len], 0..) |a, i| if (a.pane == pane) {
+ std.mem.copyForwards(Adoption, s.adoptions[i .. s.adoptions_len - 1], s.adoptions[i + 1 .. s.adoptions_len]);
+ s.adoptions_len -= 1;
+ return takeShell(s, pane, a);
+ };
// The new shell starts before a running one goes: one that cannot
// start leaves the running one be (pty/ctl's exec).
const running = s.ptys[pane] != null;
@@ -4571,6 +4527,46 @@ fn spawnPane(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
};
}
+const Adoption = struct { pid: libc.pid_t, fd: c_int, pane: ?u8 };
+
+/// An adopted shell, running already, as pane `pane`'s: told the size twice
+/// (one it never had, then the pane's), which makes it redraw.
+fn takeShell(s: *Shell, pane: u8, a: Adoption) void {
+ s.closePty(pane);
+ s.gens[pane] +%= 1;
+ s.ptys[pane] = .{ .fd = a.fd, .pid = a.pid, .serial = s.core.panes[pane].?.serial, .cmd = .{} };
+ var exe_buf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ s.core.acknowledgeShell(pane, host_io.processExe(a.pid, &exe_buf) orelse "sh", host_io.marksPrompts(a.pid));
+ var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ if (host_io.shellCwd(a.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
+ const tiny: posix.winsize = .{ .row = 1, .col = 1, .xpixel = 0, .ypixel = 0 };
+ _ = posix.system.ioctl(a.fd, TIOCSWINSZ, @intFromPtr(&tiny));
+ if (s.core.panes[pane]) |pn| ptyResize(s, pane, @max(pn.cols, 1), @max(pn.rows, 1));
+ if (!s.threads_ok) return;
+ s.ptys[pane].?.reader = s.queue.startReader(.{ .handle = a.fd, .flags = .{ .nonblocking = false } }, pane, s.gens[pane]) catch |err| {
+ s.closePty(pane);
+ return s.core.reportError(pane, "terminal reader", err);
+ };
+}
+
+/// The daemon's thread: what it says, onto the queue (drainQueue).
+fn deliverNote(ctx: *anyopaque, note: daemon.Note) void {
+ const q: *Queue = @ptrCast(@alignCast(ctx));
+ switch (note) {
+ .attach => |a| {
+ // A terminal for a window session: the daemon refuses that kind
+ // before it is sent, so only an old one's would be here.
+ if (a.tty >= 0) _ = libc.close(a.tty);
+ if (a.stub >= 0) daemon.refuseStub(a.stub, "a window session takes no terminal");
+ if (a.tty < 0) q.push(.window);
+ },
+ .adopted => |a| {
+ for (a.pids[0..a.n], a.fds[0..a.n]) |pid, fd| q.push(.{ .adopted = .{ .pid = pid, .fd = fd } });
+ q.push(.{ .adopted = .{ .pid = 0, .fd = -1 } });
+ },
+ }
+}
+
fn ptyWrite(ctx: ?*anyopaque, pane: u8, bytes: []const u8) void {
const s = shellOf(ctx);
if (s.ptys[pane]) |pt| if (pt.fd >= 0) {
@@ -4704,6 +4700,7 @@ test "the headless grid host round-trips a yank back as a paste" {
.pipe_tasks = &pipe_tasks,
.inotify_fd = -1,
.watches = &watches,
+ .grid = true,
};
core.host = shell.host();
try std.testing.expect(core.host.vtable == &Shell.grid_vtable);
diff --git a/src/host_io.zig b/src/host_io.zig
index af284e84..96c790d7 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -24,7 +24,11 @@ pub const Host = struct {
/// client attached draws none (a /screen read draws its own), and
/// the frame owed is drawn when one attaches. Absent: always.
watched: ?*const fn (ctx: ?*anyopaque) bool = null,
+ /// Detach: the terminal or window let go, the session left running
+ /// for the daemon to attach again (daemon.zig).
detach: ?*const fn (ctx: ?*anyopaque) void = null,
+ /// Adopt: the shells a dead session left, asked of the daemon.
+ adopt: ?*const fn (ctx: ?*anyopaque, pane: u8) void = null,
spawn: ?*const fn (ctx: ?*anyopaque, pane: u8, cwd: []const u8) void = null,
pty_write: ?*const fn (ctx: ?*anyopaque, pane: u8, bytes: []const u8) void = null,
pty_resize: ?*const fn (ctx: ?*anyopaque, pane: u8, cols: u16, rows: u16) void = null,
@@ -143,6 +147,11 @@ pub const Inbox = struct {
handed: struct { seq: u32, ok: bool, words: []u8 },
files_changed,
fs_ready,
+ /// The daemon asks for the window again (`pardes-gui --attach`).
+ window,
+ /// A shell a dead session left, its pty's master (Adopt); pid 0 is
+ /// the last of them told.
+ adopted: struct { pid: libc.pid_t, fd: c_int },
pub fn deinit(m: Msg, gpa: std.mem.Allocator, lsp_allocator: std.mem.Allocator) void {
switch (m) {
@@ -155,7 +164,10 @@ pub const Inbox = struct {
},
.search => |b| b.deinit(gpa),
.handed => |h| gpa.free(h.words),
- .eof, .files_changed, .fs_ready => {},
+ .adopted => |a| if (a.fd >= 0) {
+ _ = libc.close(a.fd);
+ },
+ .eof, .files_changed, .fs_ready, .window => {},
}
}
};
@@ -2097,6 +2109,9 @@ pub fn forkShell(
};
}
ninep_io.setCloexec(master);
+ // The daemon keeps a dup: this session killed outright never hangs the
+ // shell up (daemon.zig).
+ @import("daemon.zig").pty(pid, master);
if (core) |c| c.acknowledgeShell(pane, std.mem.span(spawn.path), one_line == null and spawn.argv[1] != null);
return .{ .file = .{ .handle = master, .flags = .{ .nonblocking = false } }, .pid = pid };
}
@@ -2208,6 +2223,26 @@ const proc_vnodepathinfo = extern struct {
const PROC_PIDVNODEPATHINFO: c_int = 9;
extern "c" fn proc_pidinfo(pid: c_int, flavor: c_int, arg: u64, buffer: *anyopaque, buffersize: c_int) c_int;
+/// Whether an adopted shell marks its prompts: one pardes started with its
+/// prompt files (bash, zsh, fish), which a pane's runs wait on.
+pub fn marksPrompts(pid: libc.pid_t) bool {
+ var buf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ const exe = std.fs.path.basename(processExe(pid, &buf) orelse return false);
+ for ([_][]const u8{ "bash", "zsh", "fish" }) |shell| if (std.mem.eql(u8, exe, shell)) return true;
+ return false;
+}
+
+/// The program `pid` runs, where the system says (an adopted shell's, for
+/// its pane's Tty word); null elsewhere.
+pub fn processExe(pid: libc.pid_t, buf: []u8) ?[]const u8 {
+ if (comptime builtin.os.tag != .linux) return null;
+ var pbuf: [64]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&pbuf, "/proc/{d}/exe", .{pid}, 0) catch return null;
+ const n = libc.readlink(path, buf.ptr, buf.len);
+ if (n <= 0 or n >= buf.len) return null;
+ return buf[0..@intCast(n)];
+}
+
pub fn shellCwd(pid: libc.pid_t, buf: []u8) ?[]const u8 {
switch (builtin.os.tag) {
.linux => {
diff --git a/src/macos.zig b/src/macos.zig
index 8d372432..e07955a1 100644
--- a/src/macos.zig
+++ b/src/macos.zig
@@ -1105,7 +1105,8 @@ fn drainInbox(st: *State) bool {
.search => |b| st.core.update(.{ .search = b }),
// The SDL shell's: this one's file watches and 9P are its own.
// ponytail: no hand_over host entry on macOS yet, so none comes.
- .files_changed, .fs_ready, .handed => {},
+ // No daemon on macOS (daemon.supported): neither ever comes.
+ .files_changed, .fs_ready, .handed, .window, .adopted => {},
}
}
for (0..pardes.MAX_PANES) |pane| {
diff --git a/src/main.zig b/src/main.zig
index 4e6b49bb..803ff4da 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -2,6 +2,7 @@ const std = @import("std");
const builtin = @import("builtin");
const pardes = @import("pardes.zig");
const ninep_io = @import("9p_io.zig");
+const daemon = @import("daemon.zig");
const is_emscripten = builtin.os.tag == .emscripten;
@@ -84,22 +85,20 @@ const help_text =
\\ --9p-quic=<dial> also serve at quic!<numeric-ip>!<port> (-Dquic=true).
\\ --mount=<name>=<dial> mount a 9P session or Unix/TCP/QUIC endpoint under /n/<name>.
\\ Repeat for more mounts; os and self are reserved.
- \\ --detach run this session with NO terminal of its own,
- \\ serving frontends over a unix socket beside its
- \\ 9P socket. The core, the panes and the
- \\ undo history outlive every frontend that attaches
- \\ --detach=<name> ...named <name> rather than this process's pid, so
- \\ a frontend can say which session it wants. One
- \\ path component: no '/' and nothing empty
- \\ --attach become a frontend of the one detached session
- \\ that is running: draw its screen and send it
- \\ input, and nothing else — the session owns its
- \\ pane shells, its files and its watches. Works in
- \\ both the terminal and the SDL window build.
- \\ Several frontends may be attached at once and all
- \\ see the same screen
- \\ --attach=<name> ...of the session called <name>, which is what to
- \\ use when more than one is running
+ \\ --detach run this session with no terminal (no window)
+ \\ until one attaches; its panes, shells and files
+ \\ stay. Detach, or a terminal that closes, leaves
+ \\ any session so. One `pardes --daemon` per user
+ \\ keeps them (PARDES_DAEMON=off: none)
+ \\ --detach=<name> ...named <name> rather than this process's pid,
+ \\ as --9p names it. One path component: no '/'
+ \\ and nothing empty
+ \\ --attach show the one detached session here: this
+ \\ terminal for `pardes`, a window again for
+ \\ `pardes-gui`, each of its own kind. Returns when
+ \\ the session detaches or ends
+ \\ --attach=<name> ...the session called <name> (its --9p or
+ \\ --detach name, else its pid)
\\ --geometry=WxH[+X+Y] the window's size in points, and where it goes
\\ where the display lets a window say (X11)
\\ -h, --help show this help and exit
@@ -316,7 +315,7 @@ fn emscriptenMain(argc: c_int, argv: [*]?[*:0]u8) callconv(.c) c_int {
// no argv in the browser: options stay default, state comes from the dump, and
// there is no session to attach to — a browser tab has no unix socket.
fn webMain() !void {
- try @import("gui/gui.zig").run(.{}, .{}, null);
+ try @import("gui/gui.zig").run(.{}, .{}, false);
}
// init.gpa, what the tty, gui and detached shells allocate from, is their
@@ -335,6 +334,8 @@ fn nativeMain(std_init: std.process.Init) !void {
var mounts_len: usize = 0;
const arena = init.arena.allocator();
const args = try init.minimal.args.toSlice(arena);
+ // The per-user daemon a session started (daemon.zig): nothing else.
+ if (comptime daemon.supported) if (args.len == 2 and std.mem.eql(u8, args[1], "--daemon")) daemon.serve();
var session_only = true;
var new_session = false;
var explicit_tty = false;
@@ -713,30 +714,57 @@ fn nativeMain(std_init: std.process.Init) !void {
opts.config_dir = found.dir;
opts.store_path = storePath(init.io, arena, init.environ_map);
if (found.dir) |d| @import("crash.zig").setDir(d);
+ if (attach) |name| attachTo(init.io, name);
if (detach) |name| {
- const named = if (name.len != 0)
- name
- else
- try std.fmt.allocPrint(arena, "{d}", .{@as(u32, @intCast(std.c.getpid()))});
- // Said plainly, never a Zig error trace: a name another session's
+ // Said plainly, never a Zig error trace: a name a live session's
// socket holds already (a plain session is named by its pid too).
- return @import("detached/server.zig").run(init, opts, named) catch |err| {
- var words: [128]u8 = undefined;
+ if (name.len != 0 and ninep_io.taken(name)) {
var said: [512]u8 = undefined;
- const why = if (err == error.ListenFailed)
- "its socket is taken: another session (a plain one is named by its pid) holds that name; choose another"
- else
- pardes.Messages.errorWords(err, &words);
- std.Io.File.stderr().writeStreamingAll(init.io, std.fmt.bufPrint(&said, "pardes: --detach={s}: {s}\n", .{ named, why }) catch "pardes: --detach failed\n") catch {};
+ std.Io.File.stderr().writeStreamingAll(init.io, std.fmt.bufPrint(&said, "pardes: a session named {s} is already running\n", .{name}) catch "pardes: a session of that name is already running\n") catch {};
std.process.exit(1);
- };
+ }
+ if (opts.ninep_name.len == 0) opts.ninep_name = name;
+ // Nobody's size yet: one roomy enough for a script's panes; `size`
+ // sets another, and an attached terminal or window its own.
+ opts.cols = 160;
+ opts.rows = 50;
}
- if (attach != null and pardes.platform != .tty and pardes.platform != .gui) {
- try std.Io.File.stderr().writeStreamingAll(init.io, "pardes: --attach needs the tty or gui shell\n");
- std.process.exit(1);
+ const kind: daemon.Kind = if (pardes.platform == .gui) .gui else .tty;
+ var term: @import("tty/tty.zig").Term = if (detach != null) .none else .open;
+ if (daemon.wanted()) {
+ if (detach != null or pardes.platform == .gui) {
+ _ = daemon.register(null, kind, opts.ninep_name, detach != null);
+ } else if (pardes.platform == .tty) fork: {
+ // A terminal's session is forked off its stub, which stays the
+ // job the shell waits on: Detach (or the terminal's end) ends
+ // the job and leaves the session running (daemon.forkSession).
+ // The daemon is reached or started first, from this small
+ // process, and the terminal opened while it is this one's.
+ const conn = daemon.connect(true) orelse break :fork;
+ const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0));
+ if (fd < 0) {
+ daemon.startPending(true);
+ _ = std.c.close(conn);
+ break :fork;
+ }
+ // Started in the background, the job stops here until it is
+ // brought to the foreground, as one making its terminal raw does.
+ // std.posix's termios, not std.c's: glibc's is the bigger struct.
+ if (std.posix.tcgetattr(fd)) |tio| std.posix.tcsetattr(fd, .NOW, tio) catch {} else |_| {}
+ daemon.forkSession(conn) orelse {
+ daemon.startPending(true);
+ _ = std.c.close(fd);
+ _ = std.c.close(conn);
+ break :fork;
+ };
+ _ = daemon.register(conn, .tty, opts.ninep_name, false);
+ term = .{ .fd = fd };
+ }
}
+ defer daemon.quit();
+ errdefer daemon.tellStubExit(1);
switch (pardes.platform) {
- .tty => @import("tty/tty.zig").run(init, opts, attach) catch |err| switch (err) {
+ .tty => @import("tty/tty.zig").run(init, opts, term) catch |err| switch (err) {
// No controlling terminal (a detached pty, a daemon): said, not
// an error trace.
error.NoDevice => {
@@ -745,9 +773,45 @@ fn nativeMain(std_init: std.process.Init) !void {
},
else => return err,
},
- .gui => try @import("gui/gui.zig").run(init, opts, attach),
+ .gui => try @import("gui/gui.zig").run(init, opts, detach != null),
.web, .macos, .esp32p4 => unreachable,
}
+ daemon.tellStubExit(0);
+}
+
+/// `pardes --attach[=name]` in a terminal: this terminal handed (through
+/// the daemon) to the detached session of that name, or the only one, and
+/// this process its stub until the session leaves it. `pardes-gui
+/// --attach`: the session asked to open its window again, and done.
+fn attachTo(io: std.Io, name: []const u8) noreturn {
+ var words: [600]u8 = undefined;
+ const Say = struct {
+ fn no(o: std.Io, why: []const u8) noreturn {
+ var buf: [700]u8 = undefined;
+ std.Io.File.stderr().writeStreamingAll(o, std.fmt.bufPrint(&buf, "pardes: --attach: {s}\n", .{why}) catch "pardes: --attach failed\n") catch {};
+ std.process.exit(1);
+ }
+ };
+ if (comptime !daemon.supported) Say.no(io, "this system has no pardes daemon to attach through");
+ if (pardes.platform == .gui) switch (daemon.attach(.gui, name, &.{}, &words)) {
+ .ok => std.process.exit(0),
+ .no => |why| Say.no(io, why),
+ };
+ const fd = std.c.open("/dev/tty", .{ .ACCMODE = .RDWR, .CLOEXEC = true, .NOCTTY = true }, @as(std.c.mode_t, 0));
+ if (fd < 0) Say.no(io, "no terminal to attach: /dev/tty will not open");
+ if (std.posix.tcgetattr(fd)) |tio| std.posix.tcsetattr(fd, .NOW, tio) catch {} else |_| {}
+ var pipe: [2]std.c.fd_t = undefined;
+ if (std.c.pipe(&pipe) != 0) Say.no(io, "no pipe for the session to say when it leaves");
+ ninep_io.setCloexec(pipe[0]);
+ ninep_io.setCloexec(pipe[1]);
+ switch (daemon.attach(.tty, name, &.{ fd, pipe[1] }, &words)) {
+ .ok => |pid| {
+ _ = std.c.close(fd);
+ _ = std.c.close(pipe[1]);
+ daemon.stubWait(pid, false, pipe[0]);
+ },
+ .no => |why| Say.no(io, why),
+ }
}
fn parseCtrlKey(raw: []const u8) ?u21 {
@@ -774,8 +838,7 @@ test {
_ = @import("detached/wire.zig");
_ = @import("ShaderBuild.zig");
_ = @import("vaxis_input.zig");
- _ = @import("detached/server.zig");
- _ = @import("detached/client.zig");
+ _ = @import("daemon.zig");
_ = @import("9p_io.zig");
_ = @import("9p_io.zig").Client;
_ = @import("host_io.zig");
diff --git a/src/pardes.zig b/src/pardes.zig
index c7ae6704..2bee1f98 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -538,53 +538,8 @@ fn drainForSavePath(p: *Pardes, buf: []u8) ?[]const u8 {
return if (len) |n| buf[0..n] else null;
}
-fn drainForAttach(p: *Pardes) ?AttachRequest {
- while (p.nextEffect()) |effect| p.perform(effect);
- return p.takeAttach();
-}
-
-test "Attach asks for a session and tears nothing down" {
- if (comptime !can_attach) return;
- const gpa = std.testing.allocator;
- const p = try Pardes.init(gpa, .{ .tty_only = true });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
-
- // Bare means whichever session is there, and that is an EMPTY name rather
- // than an absent request: the frontend still has to go and look.
- try std.testing.expect(p.executeBuiltinLine(0, "Attach"));
- const bare = drainForAttach(p) orelse return error.NoAttachAsked;
- try std.testing.expectEqualStrings("", bare.name);
- try std.testing.expectEqual(@as(u8, 0), bare.pane);
-
- // ...and the named form carries its tail, the way `Theme <name>` does.
- try std.testing.expect(p.executeBuiltinLine(0, "Attach work"));
- const named = drainForAttach(p) orelse return error.NoAttachAsked;
- try std.testing.expectEqualStrings("work", named.name);
- try std.testing.expect(p.takeAttach() == null); // taken once, then gone
-
- // The word only ASKS. A core that tore itself down here could not be handed
- // back intact when the connect fails, and that is the entire guarantee.
- try std.testing.expect(!p.quit);
- try std.testing.expect(p.panes[0] != null);
-}
-
-test "Attach in a detached session: bare is wrong #args, a name no session has says so, and nothing is asked" {
- if (comptime !can_attach) return;
- const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .detached_session = true });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
- const pane = p.panes[0].?;
- try std.testing.expect(p.executeBuiltinLine(0, "Attach"));
- try std.testing.expect(drainForAttach(p) == null);
- try std.testing.expectStringStartsWith(pane.msg[0..pane.msg_len], "wrong #args");
- try std.testing.expect(p.executeBuiltinLine(0, "Attach zz-no-such-session-qq"));
- try std.testing.expect(drainForAttach(p) == null);
- try std.testing.expectEqualStrings("Attach: zz-no-such-session-qq: no such session", pane.msg[0..pane.msg_len]);
-}
-
-test "Detach asks the frontend to leave, and says so when there is nothing to leave" {
- if (comptime !can_attach) return; // compiled out where nothing polls `takeAttach` — see `can_attach`
+test "Detach asks the host to let its terminal go, and says so when there is nothing to leave" {
+ if (comptime !can_attach) return; // the word is compiled out elsewhere: see `can_attach`
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true });
defer p.deinit();
@@ -3753,10 +3708,6 @@ pub const Event = union(enum) {
tick,
};
-pub const attach_name_max = 256;
-
-pub const AttachRequest = struct { pane: u8, name: []const u8 };
-
pub const PendingWrite = struct { bytes: []u8, off: usize = 0 };
/// `command` is Kill's: SIGTERM to the terminal's foreground job, and never
@@ -3807,7 +3758,6 @@ pub const Effect = union(enum) {
/// Write the build-time theme ring below the per-user config directory.
/// The pane receives the completion/error message from the native host.
dump_themes: struct { pane: u8 },
- attach: struct { pane: u8, name: Buf(attach_name_max) },
detach: struct { pane: u8 },
quit,
@@ -4387,9 +4337,6 @@ pub const Options = struct {
/// window opens one as big as that, Handover.zig).
geometry: ?[]const u8 = null,
nested: bool = false,
- /// The core of a `--detach` session (detached/server.zig): it has no
- /// terminal of its own, so Attach there is refused with why.
- detached_session: bool = false,
startup_config: ?[]const u8 = null,
ninep_name: []const u8 = "",
ninep_tcp: ?[]const u8 = null,
@@ -4738,8 +4685,6 @@ pub const Pardes = struct {
/// shell consumes it via takeRestore each frame (restore contents stay host-fed)
restore_req: ?[]const u8 = null,
restore_buf: [1024]u8 = undefined,
- attach_req: ?AttachRequest = null,
- attach_buf: [attach_name_max]u8 = undefined,
surface: Surface = .{},
/// per-update scratch (paneCursorLines, selection text); reset each update
@@ -5088,14 +5033,6 @@ pub const Pardes = struct {
return r;
}
- /// the shell polls this each frame beside takeRestore: a pending Attach's
- /// session and reporting pane, or null
- pub fn takeAttach(p: *Pardes) ?AttachRequest {
- const a = p.attach_req;
- p.attach_req = null;
- return a;
- }
-
/// The workspace tag's height: one row while the setting keeps it, as
/// acme's row tag is, zero once a native shell takes its commands over.
/// Layout and hit testing read this rather than the constant, the way
@@ -5981,11 +5918,6 @@ pub const Pardes = struct {
},
.theme_file => |t| if (v.watch_theme) |f| f(p.host.ctx, t.generation, t.on),
.dump_themes => |d| if (v.dump_themes) |f| f(p.host.ctx, d.pane),
- .attach => |a| {
- const name = a.name.slice();
- @memcpy(p.attach_buf[0..name.len], name);
- p.attach_req = .{ .pane = a.pane, .name = p.attach_buf[0..name.len] };
- },
.detach => |d| if (v.detach) |f|
f(p.host.ctx)
else
diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index a358051e..37f66456 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -14,9 +14,7 @@ const file_watch = @import("../file_watch.zig");
const selection_pipe = @import("../selection_pipe.zig");
const ninep_io = @import("../9p_io.zig");
const panel_compositor = @import("panel_compositor.zig");
-const detached_client = @import("../detached/client.zig");
-const detached_server = @import("../detached/server.zig");
-const wire = @import("../detached/wire.zig");
+const daemon = @import("../daemon.zig");
const host_io = @import("../host_io.zig");
extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
@@ -78,7 +76,14 @@ fn kittyShmProbe(w: *std.Io.Writer) void {
pub const Command = struct {
pub var value: union(enum) {
nop,
+ /// The terminal's input ended: its end of file, a hangup. A session
+ /// a daemon keeps carries on detached; any other ends.
quit,
+ /// A terminal for this detached session, and its stub's pipe
+ /// (daemon.Note.attach).
+ attach: struct { tty: posix.fd_t, stub: posix.fd_t },
+ /// A shell a dead session left, its pty's master (daemon.Note.adopted).
+ adopted: struct { pid: posix.pid_t, fd: posix.fd_t },
/// A timed wait ran out: the core's next wake has come.
wake,
key_press: vaxis.Key,
@@ -1166,78 +1171,99 @@ fn nativePdfWheelTarget(core: *const pardes.Pardes, mouse: vaxis.Mouse) ?PdfWhee
return null;
}
-pub fn run(init: std.process.Init, opts: pardes.Options, attach: ?[]const u8) !void {
+/// Where a session's terminal comes from: /dev/tty, as a plain `pardes`
+/// opens it; one open already (a session forked off its stub,
+/// daemon.forkSession); or none, until one is attached (`--detach`).
+pub const Term = union(enum) { open, fd: posix.fd_t, none };
+
+pub fn run(init: std.process.Init, opts: pardes.Options, term: Term) !void {
const io = init.io;
const gpa = init.gpa;
- var attach_end: AttachEnd = .none;
- defer attach_end.report(io);
-
- var name_buf: [detached_server.path_max]u8 = undefined;
- var attach_name: []const u8 = &.{};
- if (attach) |requested| switch (detached_client.resolve(&name_buf, requested)) {
- .name => |resolved| attach_name = resolved,
- .none => {
- attach_end = if (requested.len != 0) .{ .no_session = requested } else .nothing_detached;
- return;
- },
- .ambiguous => |found| {
- attach_end = .{ .ambiguous = found };
- return;
- },
- };
-
var winch_set = posix.sigemptyset();
posix.sigaddset(&winch_set, posix.SIG.WINCH);
+ // Kept by a daemon, a hangup is the terminal's end, not the session's:
+ // winchWatch takes it, and the session carries on detached.
+ if (daemon.link >= 0) posix.sigaddset(&winch_set, posix.SIG.HUP);
posix.sigprocmask(posix.SIG.BLOCK, &winch_set, null);
var tty_buf: [0x10000]u8 = undefined;
- var tty = try vaxis.Tty.init(io, &tty_buf);
- defer tty.deinit(); // restore cooked termios LAST, after vx flushed its resets
- var vx = try vaxis.init(io, gpa, init.environ_map, .{ .system_clipboard_allocator = gpa });
- defer vx.deinit(gpa, tty.writer());
- try vx.enterAltScreen(tty.writer());
- defer vx.exitAltScreen(tty.writer()) catch {};
- try vx.setMouseMode(tty.writer(), true);
- try vx.setBracketedPaste(tty.writer(), true);
- Killed.arm(tty.fd.handle, tty.termios);
- defer Killed.disarm();
-
- if (attach != null) {
- attach_end = attachSession(init, attach_name, &tty, &vx);
- return;
+ var screen: Screen = .{ .io = io, .gpa = gpa, .env = init.environ_map, .buf = &tty_buf };
+ switch (term) {
+ .open => try screen.enter(try vaxis.Tty.init(io, &tty_buf)),
+ .fd => |fd| try screen.enter(try Screen.ttyOn(io, &tty_buf, fd)),
+ .none => {},
}
+ defer screen.leave();
var kitty_handles = std.AutoHashMap(pardes.ImageCacheKey, vaxis.Image).init(gpa);
defer {
- clearNativeImages(&kitty_handles, &vx, &tty);
+ if (screen.on) clearNativeImages(&kitty_handles, &screen.vx, &screen.tty);
kitty_handles.deinit();
}
var paste_buf: std.Io.Writer.Allocating = .init(gpa);
defer paste_buf.deinit();
- var loop: Loop = .init(io, &tty, &vx);
+ var loop: Loop = .init(io, &screen.tty, &screen.vx);
var input_cache: vaxis.GraphemeCache = .{};
- var attached: ?detached_client.Client = null;
- defer if (attached != null) {
- stopInput(&loop);
- drainAttachedQueue(&loop, gpa);
- };
- try localSession(init, opts, &tty, &vx, &loop, &input_cache, &kitty_handles, &paste_buf, &attached);
- if (attached) |*client| {
- defer client.detach();
- var a: Attach = .{
- .gpa = gpa,
- .client = client,
- .loop = &loop,
- .vx = &vx,
- .tty = &tty,
- .paste_buf = &paste_buf,
- };
- attach_end = attachLoop(&a);
- }
+ try localSession(init, opts, &screen, &loop, &input_cache, &kitty_handles, &paste_buf);
}
+/// Whether a terminal is there to ask its size (winchWatch): none while
+/// detached, when the descriptor it had may be another's.
+var terminal_on = std.atomic.Value(bool).init(false);
+
+/// The terminal a session draws on, while it has one: entered (raw, the
+/// alternate screen, mouse and paste reports) and left (all of it put back,
+/// the terminal closed) at the session's start and end, and at a detach and
+/// a reattach in between (daemon.zig).
+const Screen = struct {
+ io: std.Io,
+ gpa: std.mem.Allocator,
+ env: *std.process.Environ.Map,
+ buf: []u8,
+ tty: vaxis.Tty = undefined,
+ vx: vaxis.Vaxis = undefined,
+ on: bool = false,
+
+ /// `fd` made raw, as vaxis.Tty.init makes /dev/tty: the terminal of a
+ /// forked session is no controlling terminal of its, which /dev/tty is.
+ fn ttyOn(io: std.Io, buf: []u8, fd: posix.fd_t) !vaxis.Tty {
+ if (comptime builtin.is_test) unreachable; // vaxis.Tty is its TestTty
+ const termios = try vaxis.Tty.makeRaw(fd);
+ const file: std.Io.File = .{ .handle = fd, .flags = .{ .nonblocking = false } };
+ return .{ .io = io, .fd = file, .termios = termios, .tty_writer = file.writerStreaming(io, buf) };
+ }
+
+ fn enter(sc: *Screen, tty: vaxis.Tty) !void {
+ sc.tty = tty;
+ errdefer sc.tty.deinit();
+ sc.vx = try vaxis.init(sc.io, sc.gpa, sc.env, .{ .system_clipboard_allocator = sc.gpa });
+ errdefer sc.vx.deinit(sc.gpa, sc.tty.writer());
+ try sc.vx.enterAltScreen(sc.tty.writer());
+ try sc.vx.setMouseMode(sc.tty.writer(), true);
+ try sc.vx.setBracketedPaste(sc.tty.writer(), true);
+ if (comptime !builtin.is_test) {
+ Killed.arm(sc.tty.fd.handle, sc.tty.termios);
+ // What a panic puts back (vaxis.recover).
+ vaxis.tty.global_tty = sc.tty;
+ }
+ sc.on = true;
+ terminal_on.store(true, .release);
+ }
+
+ fn leave(sc: *Screen) void {
+ if (!sc.on) return;
+ sc.on = false;
+ terminal_on.store(false, .release);
+ Killed.disarm();
+ sc.vx.exitAltScreen(sc.tty.writer()) catch {};
+ sc.vx.deinit(sc.gpa, sc.tty.writer());
+ if (comptime !builtin.is_test) vaxis.tty.global_tty = null;
+ sc.tty.deinit(); // restore cooked termios LAST, after vx flushed its resets
+ }
+};
+
/// SIGTERM or SIGHUP: the terminal put back as a clean exit leaves it --
/// the main screen, no mouse, paste or keyboard modes, the cursor shown,
/// cooked termios -- and then the signal's own death. A nested editor
@@ -1247,19 +1273,20 @@ const Killed = struct {
var fd: posix.fd_t = -1;
var cooked: posix.termios = undefined;
const reset = "\x1b[<u\x1b[?1000l\x1b[?1002l\x1b[?1003l\x1b[?1006l\x1b[?1004l\x1b[?2004l\x1b[0m\x1b[?25h\x1b[?1049l";
- const signals = [_]posix.SIG{ .TERM, .HUP };
-
fn arm(tty_fd: posix.fd_t, termios: posix.termios) void {
cooked = termios;
fd = tty_fd;
const on: posix.Sigaction = .{ .handler = .{ .handler = handle }, .mask = posix.sigemptyset(), .flags = posix.SA.RESETHAND };
- for (signals) |sig| posix.sigaction(sig, &on, null);
+ posix.sigaction(.TERM, &on, null);
+ // A hangup a daemon keeps the session through is winchWatch's.
+ if (daemon.link < 0) posix.sigaction(.HUP, &on, null);
}
+ /// The terminal gone (put back, or detached): a TERM still takes the
+ /// socket, the prompt files and the shells with it, and leaves the
+ /// terminal alone.
fn disarm() void {
fd = -1;
- const default: posix.Sigaction = .{ .handler = .{ .handler = posix.SIG.DFL }, .mask = posix.sigemptyset(), .flags = 0 };
- for (signals) |sig| posix.sigaction(sig, &default, null);
}
fn handle(sig: posix.SIG) callconv(.c) void {
@@ -1268,9 +1295,10 @@ const Killed = struct {
_ = std.c.tcsetattr(fd, .FLUSH, &cooked);
}
// The 9P socket and private prompt files go too: a killed editor
- // leaves none behind.
+ // leaves none behind. Its shells too, the daemon's dups let go.
ninep_io.unlinkOwnSocket();
host_io.Shell.unlinkOwnedRcs();
+ daemon.hangUp();
// SA_RESETHAND put the default back: the same signal, now fatal.
_ = std.c.raise(sig);
}
@@ -1279,16 +1307,16 @@ const Killed = struct {
fn localSession(
init: std.process.Init,
opts: pardes.Options,
- tty: *vaxis.Tty,
- vx: *vaxis.Vaxis,
+ screen: *Screen,
loop: *Loop,
input_cache: *vaxis.GraphemeCache,
kitty_handles: *std.AutoHashMap(pardes.ImageCacheKey, vaxis.Image),
paste_buf: *std.Io.Writer.Allocating,
- attached: *?detached_client.Client,
) !void {
const io = init.io;
const gpa = init.gpa;
+ const vx = &screen.vx;
+ const tty = &screen.tty;
const allocs = pardes.memory.init(gpa);
defer pardes.memory.deinit();
@@ -1335,6 +1363,8 @@ fn localSession(
.loop = loop,
.vx = vx,
.tty = tty,
+ .screen = screen,
+ .input_cache = input_cache,
.kitty = kitty_handles,
.frame = &frame_arena,
.paste_buf = paste_buf,
@@ -1351,12 +1381,9 @@ fn localSession(
for (&sh.ptys) |*slot| if (slot.*) |*pt| {
pt.reader.cancel(io) catch {};
_ = libc.close(pt.file.handle);
- if (attached.* != null) {
- _ = libc.kill(pt.pid, posix.SIG.KILL);
- _ = libc.waitpid(pt.pid, null, 0);
- }
slot.* = null;
};
+ for (sh.adoptions[0..sh.adoptions_len]) |a| _ = libc.close(a.fd);
if (sh.lsp_task) |*t| {
t.future.cancel(io);
sh.lsp_task = null;
@@ -1383,20 +1410,29 @@ fn localSession(
response.deinit(gpa);
},
.search_rows => |b| b.deinit(gpa),
+ .attach => |a| {
+ _ = libc.close(a.tty);
+ _ = libc.close(a.stub);
+ },
+ .adopted => |a| _ = libc.close(a.fd),
else => {},
};
}
const host = sh.host();
core.host = host;
+ // Nobody to see it, and nobody to size it: `size` sets it (ctl.zig).
+ core.unattended = !screen.on;
while (core.nextEffect()) |effect| core.perform(effect);
- try startInput(loop, input_cache);
- defer if (attached.* == null) stopInput(loop);
+ if (screen.on) try startInput(loop, input_cache);
+ defer stopInput(loop);
(try std.Thread.spawn(.{}, winchWatch, .{ loop, vx, tty })).detach();
(try std.Thread.spawn(.{}, wakeWatch, .{ io, loop })).detach();
if (fs) |f| try f.watch(loop, wakeFs);
- try vx.queryTerminalSend(tty.writer());
+ if (screen.on) try vx.queryTerminalSend(tty.writer());
+ // Detached from the start, nothing else may wake the first wait.
+ if (!screen.on) daemon.watch(loop, deliverNote);
sh.threads_ok = true;
for (&sh.ptys, 0..) |*slot, id| if (slot.*) |*pt| {
@@ -1413,9 +1449,13 @@ fn localSession(
if (kittyShmName(&name_buf, n)) |name| _ = libc.shm_unlink(name) else |_| {}
}
}
- frames: while (!core.quit) {
+ while (!core.quit) {
pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
+ // A terminal (`pardes --attach`) or an adopted shell, handed on by
+ // the daemon's thread to this loop; started after the first frame,
+ // off a startup's way.
+ daemon.watch(loop, deliverNote);
if (core.takeRestore()) |rp| blk: {
const bytes = filesystem.readRestore(gpa, rp, core.settings.dump_dir.get()) catch |err| {
core.reportError(core.active, "Restore", err);
@@ -1435,6 +1475,7 @@ fn localSession(
for (&sh.ptys) |*slot| if (slot.*) |*pt| {
pt.reader.cancel(io) catch {};
_ = libc.close(pt.file.handle);
+ daemon.closed(pt.pid);
host_io.retireShell(pt.pid);
slot.* = null;
};
@@ -1447,28 +1488,16 @@ fn localSession(
.{ .text = 0 },
);
_ = file_watch.applyThemeEffect(core, gpa, sh.inotify_fd, &sh.watches, 0, false, false);
- clearNativeImages(kitty_handles, vx, tty);
- nc.native_images = vx.caps.kitty_graphics;
+ if (screen.on) clearNativeImages(kitty_handles, vx, tty);
+ nc.native_images = screen.on and vx.caps.kitty_graphics;
+ nc.unattended = !screen.on;
if (fs) |f| f.reset(nc);
core.deinit();
core = nc;
sh.core = nc;
- if (comptime pardes.pdf_enabled) {
+ if (comptime pardes.pdf_enabled) if (screen.on) {
updateCoreTerminalSize(core, vx.screen.width, vx.screen.height, vx.screen.width_pix, vx.screen.height_pix);
- }
- }
- if (core.takeAttach()) |req| {
- var attempt = detached_client.attempt(gpa, req.name, core.screen_w, core.screen_h);
- switch (attempt) {
- .greeted => |client| {
- attached.* = client;
- break :frames;
- },
- else => {
- var mbuf: [256]u8 = undefined;
- core.setMessage(req.pane, attemptEnd(&attempt, req.name).row(&mbuf));
- },
- }
+ };
}
}
if (fs) |f| {
@@ -1488,11 +1517,25 @@ fn clearNativeImages(
kitty_handles.clearRetainingCapacity();
}
-fn drainAttachedQueue(loop: *Loop, gpa: std.mem.Allocator) void {
- while (loop.tryEvent() catch null) |ev| switch (ev) {
- .paste => |b| gpa.free(@constCast(b)),
- else => {},
- };
+const Adoption = struct { pid: posix.pid_t, fd: posix.fd_t, pane: ?u8 };
+
+/// The daemon's thread: what it says, onto the loop's queue.
+fn deliverNote(ctx: *anyopaque, note: daemon.Note) void {
+ const loop: *Loop = @ptrCast(@alignCast(ctx));
+ switch (note) {
+ .attach => |a| if (a.tty < 0) {
+ if (a.stub >= 0) daemon.refuseStub(a.stub, "a terminal session takes a terminal");
+ } else loop.postEvent(.{ .attach = .{ .tty = a.tty, .stub = a.stub } }) catch {
+ _ = libc.close(a.tty);
+ _ = libc.close(a.stub);
+ },
+ .adopted => |a| {
+ for (a.pids[0..a.n], a.fds[0..a.n]) |pid, fd| loop.postEvent(.{ .adopted = .{ .pid = pid, .fd = fd } }) catch {
+ _ = libc.close(fd);
+ };
+ loop.postEvent(.{ .adopted = .{ .pid = 0, .fd = -1 } }) catch {};
+ },
+ }
}
const Shell = struct {
@@ -1504,10 +1547,18 @@ const Shell = struct {
loop: *Loop,
vx: *vaxis.Vaxis,
tty: *vaxis.Tty,
+ /// The terminal, while there is one (Screen.on); null in tests.
+ screen: ?*Screen = null,
+ input_cache: ?*vaxis.GraphemeCache = null,
kitty: *std.AutoHashMap(pardes.ImageCacheKey, vaxis.Image),
frame: *std.heap.ArenaAllocator,
paste_buf: *std.Io.Writer.Allocating,
inotify_fd: c_int,
+ /// Shells a dead session left (Adopt), each waiting for the spawn of
+ /// the terminal pane made for it.
+ adoptions: [pardes.MAX_PANES]Adoption = undefined,
+ adoptions_len: usize = 0,
+ adopted: usize = 0,
fs: ?*ninep_io.Listener = null,
ptys: [pardes.MAX_PANES]?Pty = @splat(null),
gens: [pardes.MAX_PANES]u32 = @splat(0),
@@ -1557,6 +1608,9 @@ const Shell = struct {
.present = present,
.post_present = postPresent,
.poll_frame = pollFrame,
+ .watched = watched,
+ .detach = detach,
+ .adopt = adopt,
.spawn = spawn,
.pty_write = ptyWrite,
.pty_resize = ptyResize,
@@ -1583,6 +1637,112 @@ const Shell = struct {
return s.test_clock orelse @intCast(std.Io.Clock.awake.now(s.io).nanoseconds);
}
+ fn attached(s: *const Shell) bool {
+ const screen = s.screen orelse return true;
+ return screen.on;
+ }
+
+ /// Drawn only while a terminal shows it.
+ fn watched(ctx: ?*anyopaque) bool {
+ return of(ctx).attached();
+ }
+
+ /// Detach: the terminal put back and let go, the stub told (it ends,
+ /// and the shell has its terminal again), the session left running.
+ fn detach(ctx: ?*anyopaque) void {
+ const s = of(ctx);
+ if (!s.attached()) return s.core.reportFailure(s.core.active, "Detach: no terminal is attached");
+ if (!daemon.kept()) return s.core.reportFailure(s.core.active, "Detach: no pardes daemon keeps this session (it is its terminal's job)");
+ s.leaveTerminal();
+ }
+
+ fn leaveTerminal(s: *Shell) void {
+ const screen = s.screen orelse return;
+ stopInput(s.loop);
+ clearNativeImages(s.kitty, s.vx, s.tty);
+ screen.leave();
+ s.core.native_images = false;
+ s.core.unattended = true;
+ // The stub's stdin, stdout and stderr were its terminal too.
+ const null_fd = libc.open("/dev/null", .{ .ACCMODE = .RDWR, .CLOEXEC = true }, @as(libc.mode_t, 0));
+ if (null_fd >= 0) {
+ for (0..3) |i| _ = libc.dup2(null_fd, @intCast(i));
+ if (null_fd > 2) _ = libc.close(null_fd);
+ }
+ daemon.tellStubDetached();
+ daemon.setState(true);
+ }
+
+ /// `pardes --attach`'s terminal, for this detached session: entered as
+ /// the first one was, sized, asked what it can do, and drawn whole.
+ fn attachTerminal(s: *Shell, fd: posix.fd_t, stub: posix.fd_t) void {
+ const screen = s.screen orelse return;
+ if (screen.on) {
+ _ = libc.close(fd);
+ return daemon.refuseStub(stub, "that session has a terminal already");
+ }
+ const tty = Screen.ttyOn(s.io, screen.buf, fd) catch {
+ _ = libc.close(fd);
+ daemon.setState(true);
+ return daemon.refuseStub(stub, "that terminal would not go raw");
+ };
+ screen.enter(tty) catch {
+ daemon.setState(true);
+ return daemon.refuseStub(stub, "that terminal would not take the screen");
+ };
+ daemon.stub = stub;
+ FrameAck.waiting.store(false, .release);
+ FrameAck.off.store(false, .release);
+ kitty_shm.store(false, .release);
+ s.caps_pending = true;
+ s.core.unattended = false;
+ startInput(s.loop, s.input_cache.?) catch {};
+ s.vx.queryTerminalSend(s.tty.writer()) catch {};
+ s.core.needs_frame = true;
+ daemon.setState(false);
+ }
+
+ /// Adopt: the daemon is asked for the shells of sessions that died
+ /// holding them; each comes back (`adopted`) as a terminal pane here.
+ fn adopt(ctx: ?*anyopaque, pane: u8) void {
+ const s = of(ctx);
+ if (!daemon.kept()) return s.core.reportFailure(pane, "Adopt: no pardes daemon is keeping shells for this session");
+ s.adopted = 0;
+ daemon.adopt();
+ }
+
+ /// One shell of a dead session (`pid` 0: the last of them was told).
+ fn adoptShell(s: *Shell, pid: posix.pid_t, fd: posix.fd_t) void {
+ const core = s.core;
+ if (pid == 0) {
+ var buf: [96]u8 = undefined;
+ return core.setMessage(core.active, if (s.adopted == 0) "Adopt: no shell of a session that died is waiting" else std.fmt.bufPrint(&buf, "Adopt: {d} shell{s} taken in; what they showed is gone", .{ s.adopted, if (s.adopted == 1) "" else "s" }) catch "Adopt: shells taken in");
+ }
+ var newest: u32 = 0;
+ for (core.panes) |slot| if (slot) |pn| {
+ newest = @max(newest, pn.serial);
+ };
+ if (s.adoptions_len < s.adoptions.len) {
+ // A terminal pane, as the Tty word makes one; its spawn takes
+ // this pty instead of forking a shell (`spawn`).
+ s.adoptions[s.adoptions_len] = .{ .pid = pid, .fd = fd, .pane = null };
+ s.adoptions_len += 1;
+ _ = core.executeBuiltinLine(core.active, "Tty");
+ for (core.panes, 0..) |slot, id| if (slot) |pn| if (pn.serial > newest and pn.isTerminal()) {
+ // Its shell is up already: nothing to greet with `ls`.
+ pn.greet = false;
+ s.adoptions[s.adoptions_len - 1].pane = @intCast(id);
+ s.adopted += 1;
+ return;
+ };
+ s.adoptions_len -= 1;
+ }
+ // No room for it: its master goes, and the shell with this session.
+ _ = libc.close(fd);
+ var buf: [96]u8 = undefined;
+ core.setMessage(core.active, std.fmt.bufPrint(&buf, "Adopt: no room for shell {d}; it ends with this session", .{pid}) catch "Adopt: no room for a shell");
+ }
+
fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
const s = of(ctx);
// The wait is the 9P connections' turn with the core. A timeout (the
@@ -1593,6 +1753,14 @@ const Shell = struct {
// ends the wait at once and its frame is drawn then; the ticks after
// it run from it.
var wait = timeout_ms;
+ // Detached, nobody's key dismisses a message: they go on the clock.
+ if (!s.attached()) {
+ pardes.Messages.expireUnattended(s.core);
+ for (s.core.panes) |slot| if (slot) |pane| if (pane.msg_len > 0) {
+ wait = if (wait == 0) 100 else @min(wait, 100);
+ break;
+ };
+ }
const paced = s.test_clock == null and s.core.continuous();
var tick: u64 = 0;
if (paced) {
@@ -1685,15 +1853,23 @@ const Shell = struct {
virtual.* = @max(virtual.*, s.wake_to);
},
.quit => {
+ // The terminal went: a session the daemon keeps carries on
+ // without it, to be attached again.
+ if (daemon.kept()) {
+ if (s.attached()) s.leaveTerminal();
+ return true;
+ }
core.quit = true;
return true;
},
+ .attach => |a| s.attachTerminal(a.tty, a.stub),
+ .adopted => |a| s.adoptShell(a.pid, a.fd),
.focus_in => core.update(.{ .focus = true }),
.focus_out => {
core.update(.pointer_leave);
core.update(.{ .focus = false });
},
- .winsize => |ws| {
+ .winsize => |ws| if (s.attached()) {
s.vx.resize(s.gpa, s.tty.writer(), ws) catch {};
if (comptime pardes.pdf_enabled)
updateCoreTerminalSize(core, ws.cols, ws.rows, ws.x_pixel, ws.y_pixel)
@@ -1820,7 +1996,7 @@ const Shell = struct {
if (host_io.ttyCwd(pt.pid, pt.file.handle, s.core.settings.shell.effective.get(), &lbuf)) |cwd| s.core.setCwd(id, cwd);
};
- if (s.caps_pending and s.vx.queries_done.load(.unordered)) {
+ if (s.caps_pending and s.attached() and s.vx.queries_done.load(.unordered)) {
s.caps_pending = false;
s.vx.enableDetectedFeatures(s.tty.writer()) catch {};
s.core.native_images = s.vx.caps.kitty_graphics;
@@ -1965,6 +2141,11 @@ const Shell = struct {
fn spawn(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
const s = of(ctx);
+ for (s.adoptions[0..s.adoptions_len], 0..) |a, i| if (a.pane == pane) {
+ std.mem.copyForwards(Adoption, s.adoptions[i .. s.adoptions_len - 1], s.adoptions[i + 1 .. s.adoptions_len]);
+ s.adoptions_len -= 1;
+ return s.takeShell(pane, a);
+ };
// The new shell starts before a running one goes: one that cannot
// start leaves the running one be (pty/ctl's exec).
const running = s.ptys[pane] != null;
@@ -1988,6 +2169,25 @@ const Shell = struct {
}
}
+ /// An adopted shell, running already, as pane `pane`'s: told the size
+ /// twice (a size it never had, then the pane's), which makes it redraw.
+ fn takeShell(s: *Shell, pane: u8, a: Adoption) void {
+ closePty(s, pane);
+ s.gens[pane] +%= 1;
+ const file: std.Io.File = .{ .handle = a.fd, .flags = .{ .nonblocking = false } };
+ s.ptys[pane] = .{ .file = file, .pid = a.pid, .reader = .{ .any_future = null, .result = {} }, .cmd = .{} };
+ var exe_buf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ s.core.acknowledgeShell(pane, host_io.processExe(a.pid, &exe_buf) orelse "sh", host_io.marksPrompts(a.pid));
+ var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
+ if (host_io.shellCwd(a.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
+ const tiny: posix.winsize = .{ .row = 1, .col = 1, .xpixel = 0, .ypixel = 0 };
+ _ = posix.system.ioctl(a.fd, TIOCSWINSZ, @intFromPtr(&tiny));
+ if (s.core.panes[pane]) |pn| ptyResize(s, pane, @max(pn.cols, 1), @max(pn.rows, 1));
+ if (s.threads_ok) if (s.ptys[pane]) |*pt| {
+ pt.reader = s.io.concurrent(readPty, .{ s.io, s.gpa, pt.file, @as(usize, pane), s.gens[pane], s.loop }) catch pt.reader;
+ };
+ }
+
fn ptyWrite(ctx: ?*anyopaque, pane: u8, bytes: []const u8) void {
const s = of(ctx);
if (s.ptys[pane]) |pt| _ = host_io.writeFd(pt.file.handle, bytes);
@@ -2018,6 +2218,7 @@ const Shell = struct {
s.gens[pane] +%= 1;
pt.reader.cancel(s.io) catch {};
_ = libc.close(pt.file.handle);
+ daemon.closed(pt.pid);
host_io.retireShell(pt.pid);
}
@@ -2078,11 +2279,14 @@ const Shell = struct {
fn setClipboard(ctx: ?*anyopaque, text: []const u8) void {
const s = of(ctx);
+ // Detached, the session keeps it (a 9P read, a paste here).
+ if (!s.attached()) return s.core.fallback.setClipboard(text);
copyToClipboard(s.vx, s.tty, s.gpa, text);
}
fn readClipboard(ctx: ?*anyopaque) void {
const s = of(ctx);
+ if (!s.attached()) return s.core.update(.{ .paste = s.core.fallback.clipboard.items });
requestClipboard(s.vx, s.tty);
}
@@ -2262,19 +2466,20 @@ fn watchFiles(io: std.Io, fd: c_int, loop: *Loop) anyerror!void {
}
fn winchWatch(loop: *Loop, vx: *vaxis.Vaxis, tty: *vaxis.Tty) void {
- winchWatchUntil(loop, vx, tty, null);
-}
-
-/// A SIGWINCH watcher that ends: `stop` set, then a SIGWINCH sent to its
-/// thread, wakes its sigwait and it returns, so whoever owns `loop` can join
-/// it before the loop goes (attachSession's loop is on its stack).
-fn winchWatchUntil(loop: *Loop, vx: *vaxis.Vaxis, tty: *vaxis.Tty, stop: ?*const std.atomic.Value(bool)) void {
var set = posix.sigemptyset();
posix.sigaddset(&set, posix.SIG.WINCH);
+ if (daemon.link >= 0) posix.sigaddset(&set, posix.SIG.HUP);
while (true) {
var sig: c_int = 0;
if (libc.sigwait(&set, &sig) != 0) continue;
- if (stop) |flag| if (flag.load(.acquire)) return;
+ // The terminal hung up (its stub passes the hangup on): as its
+ // input's end.
+ if (sig == @backingInt(posix.SIG.HUP)) {
+ loop.postEvent(.quit) catch {};
+ continue;
+ }
+ // Detached, the descriptor the terminal had may be another's now.
+ if (!terminal_on.load(.acquire)) continue;
if (vx.state.in_band_resize) continue; // terminal reports via CSI 48
const ws = tty.getWinsize() catch continue;
loop.postEvent(.{ .winsize = ws }) catch {};
@@ -2869,243 +3074,6 @@ fn vaxisColor(c: pardes.Color) vaxis.Color {
};
}
-const AttachEnd = union(enum) {
- none,
- no_session: []const u8,
- nothing_detached,
- ambiguous: usize,
- refused: wire.Refusal,
- lost: anyerror,
- rejected,
- silent,
- detached: []const u8,
-
- fn report(e: AttachEnd, io: std.Io) void {
- var buf: [512]u8 = undefined;
- var ok = false;
- const text: []const u8 = switch (e) {
- .none => return,
- .detached => |name| blk: {
- ok = true;
- break :blk if (name.len != 0) std.fmt.bufPrint(
- &buf,
- "pardes: detached from '{s}', which is still running — come back with `pardes --attach={s}`\n",
- .{ name, name },
- ) catch "pardes: detached; that session is still running\n" else "pardes: detached; that session is still running — come back with `pardes --attach`\n";
- },
- .no_session => |name| std.fmt.bufPrint(
- &buf,
- "pardes: no detached session called '{s}' (start one with `pardes --detach={s}`)\n",
- .{ name, name },
- ) catch "pardes: no detached session under that name\n",
- .nothing_detached => "pardes: no detached session is running (start one with `pardes --detach`)\n",
- .ambiguous => |n| std.fmt.bufPrint(
- &buf,
- "pardes: {d} detached sessions are running; say which with --attach=<name>\n",
- .{n},
- ) catch "pardes: several detached sessions are running; say which with --attach=<name>\n",
- .refused => |why| switch (why) {
- .version => "pardes: that session speaks a different wire version — it is another build of pardes\n",
- .full => "pardes: that session already has every frontend slot taken\n",
- .quitting => "pardes: that session is ending\n",
- },
- .lost => |err| std.fmt.bufPrint(&buf, "pardes: detached session lost: {t}\n", .{err}) catch
- "pardes: detached session lost\n",
- .rejected => "pardes: that session hung up on the connect — every frontend slot is taken (32), or it is shutting down. `PARDES_LOG=1` on the session names which\n",
- .silent => "pardes: that session accepted the connection and then never greeted it — it is wedged inside its own loop, or something else is listening at that path. `PARDES_LOG=1` on the session says which\n",
- };
- const out = if (ok) std.Io.File.stdout() else std.Io.File.stderr();
- out.writeStreamingAll(io, text) catch {};
- if (!ok) std.process.exit(1);
- }
-
- fn row(e: AttachEnd, buf: []u8) []const u8 {
- return switch (e) {
- .none => "attach: that session ended",
- .no_session => |name| std.fmt.bufPrint(buf, "attach: no session '{s}'", .{name}) catch
- "attach: no session under that name",
- .nothing_detached => "attach: no detached session is running",
- .ambiguous => |n| std.fmt.bufPrint(buf, "attach: {d} sessions running, name one", .{n}) catch
- "attach: several sessions running, name one",
- .refused => |why| switch (why) {
- .version => "attach: that session is another build of pardes",
- .full => "attach: that session has every frontend slot taken",
- .quitting => "attach: that session is ending",
- },
- .lost => |err| std.fmt.bufPrint(buf, "attach: {t}", .{err}) catch "attach: link lost",
- .rejected => "attach: that session hung up on the connect",
- .silent => "attach: that session accepted and never greeted",
- .detached => "attach: detached from that session",
- };
- }
-};
-
-const Attach = struct {
- gpa: std.mem.Allocator,
- client: *detached_client.Client,
- loop: *Loop,
- vx: *vaxis.Vaxis,
- tty: *vaxis.Tty,
- paste_buf: *std.Io.Writer.Allocating,
- session: []const u8 = &.{},
- caps_pending: bool = true,
- in_paste: bool = false,
- dirty: bool = false,
-
- fn send(a: *Attach, ev: pardes.Event) ?AttachEnd {
- a.client.send(.{ .event = ev }) catch |err| switch (err) {
- error.Overlong, error.WriteFailed => return null,
- else => return .{ .lost = err },
- };
- return null;
- }
-
- fn handle(a: *Attach, msg: wire.ServerMsg) ?AttachEnd {
- switch (msg) {
- .welcome => {},
- .refuse => |why| return .{ .refused = why },
- .frame => a.dirty = true,
- .quit => return .none,
- .detach => return .{ .detached = a.session },
- .set_clipboard => |text| copyToClipboard(a.vx, a.tty, a.gpa, text),
- .read_clipboard => requestClipboard(a.vx, a.tty),
- .open_link => |url| look.openLink(url),
- // A terminal has no post chain to draw through.
- .post => {},
- }
- return null;
- }
-
- fn apply(a: *Attach, event: @TypeOf(Command.value)) ?AttachEnd {
- switch (event) {
- .nop, .wake, .fs_ready, .lsp_done, .lsp_status, .pipe_done, .search_rows, .pty_read, .pty_eof, .files_changed => {},
- .quit => return .none,
- .focus_in => return a.send(.{ .focus = true }),
- .focus_out => {
- if (a.send(.pointer_leave)) |end| return end;
- return a.send(.{ .focus = false });
- },
- .winsize => |ws| {
- a.vx.resize(a.gpa, a.tty.writer(), ws) catch {};
- a.dirty = true;
- a.client.resize(ws.cols, ws.rows) catch |err| return .{ .lost = err };
- },
- .key_press => |key| if (a.in_paste) {
- const bytes = pasteBytes(key);
- const room = max_paste_bytes -| a.paste_buf.written().len;
- a.paste_buf.writer.writeAll(bytes[0..@min(bytes.len, room)]) catch {};
- } else return a.send(vaxis_input.keyEvent(key)),
- .mouse => |m| if (mouseEvent(m)) |ev| return a.send(ev),
- .paste => |bytes| {
- defer a.gpa.free(@constCast(bytes));
- return a.send(.{ .paste = bytes });
- },
- .paste_start => {
- a.in_paste = true;
- a.paste_buf.clearRetainingCapacity();
- },
- .paste_end => {
- a.in_paste = false;
- defer a.paste_buf.clearRetainingCapacity();
- const pasted = a.paste_buf.written();
- if (pasted.len > 0) return a.send(.{ .paste = pasted });
- },
- }
- return null;
- }
-
- fn enableCaps(a: *Attach) void {
- if (!a.caps_pending or !a.vx.queries_done.load(.unordered)) return;
- a.caps_pending = false;
- a.vx.enableDetectedFeatures(a.tty.writer()) catch {};
- a.vx.queueRefresh();
- a.dirty = true;
- }
-
- fn paint(a: *Attach) void {
- a.dirty = false;
- const win = a.vx.window();
- paintCells(win, a.client.grid.items, a.client.cols, a.client.rows);
- if (a.client.cursor) |cur| paintCursor(win, cur.x, cur.y, cur.bar);
- a.vx.render(a.tty.writer()) catch {};
- }
-};
-
-fn attemptEnd(a: *const detached_client.Attempt, requested: []const u8) AttachEnd {
- return switch (a.*) {
- .greeted => .none,
- .no_session => if (requested.len != 0) .{ .no_session = requested } else .nothing_detached,
- .ambiguous => |found| .{ .ambiguous = found },
- .refused => |why| .{ .refused = why },
- .silent => .silent,
- .lost => |err| if (err == error.Closed) .rejected else .{ .lost = err },
- };
-}
-
-fn attachLoop(a: *Attach) AttachEnd {
- while (true) {
- const link = a.client.wait(detached_client.poll_ms);
- while (true) {
- const msg = (a.client.next() catch |err| return .{ .lost = err }) orelse break;
- if (a.handle(msg)) |end| return end;
- }
- link catch |err| return .{ .lost = err };
- var batch: usize = 0;
- while (a.in_paste or batch < 64) {
- const ev = (a.loop.tryEvent() catch |err| return .{ .lost = err }) orelse break;
- batch += 1;
- if (a.apply(ev)) |end| return end;
- }
- a.enableCaps();
- if (a.dirty) a.paint();
- }
-}
-
-fn attachSession(init: std.process.Init, name: []const u8, tty: *vaxis.Tty, vx: *vaxis.Vaxis) AttachEnd {
- const io = init.io;
- const gpa = init.gpa;
-
- const ws = tty.getWinsize() catch |err| return .{ .lost = err };
- if (ws.cols == 0 or ws.rows == 0) return .{ .lost = error.NoWinsize };
- vx.resize(gpa, tty.writer(), ws) catch |err| return .{ .lost = err };
-
- var attempt = detached_client.attempt(gpa, name, ws.cols, ws.rows);
- var client = switch (attempt) {
- .greeted => |c| c,
- else => return attemptEnd(&attempt, name),
- };
- defer client.detach();
-
- var loop: Loop = .init(io, tty, vx);
- var input_cache: vaxis.GraphemeCache = .{};
- var paste_buf: std.Io.Writer.Allocating = .init(gpa);
- defer paste_buf.deinit();
-
- var a: Attach = .{
- .gpa = gpa,
- .client = &client,
- .loop = &loop,
- .vx = vx,
- .tty = tty,
- .paste_buf = &paste_buf,
- .session = name,
- };
- defer drainAttachedQueue(&loop, gpa);
-
- startInput(&loop, &input_cache) catch |err| return .{ .lost = err };
- defer stopInput(&loop);
- var winch_stop: std.atomic.Value(bool) = .init(false);
- const winch = std.Thread.spawn(.{}, winchWatchUntil, .{ &loop, vx, tty, &winch_stop }) catch |err| return .{ .lost = err };
- defer {
- winch_stop.store(true, .release);
- _ = libc.pthread_kill(winch.getHandle(), posix.SIG.WINCH);
- winch.join();
- }
- vx.queryTerminalSend(tty.writer()) catch {};
-
- return attachLoop(&a);
-}
-
test "a jump leaves a trail of a few cells behind the cursor that fades in 120 ms" {
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
diff --git a/src/tutor.txt b/src/tutor.txt
index 3f153ebd..5cfb245b 100644
--- a/src/tutor.txt
+++ b/src/tutor.txt
@@ -144,7 +144,7 @@
run at start.
2. In a shell, pardes --detach=work starts a session with no screen;
pardes --attach=work shows it; `Detach` (SPC s D) leaves it
- running.
+ running, as a terminal that closes does.
-> Guide: Sessions, Config
@@ -292,7 +292,7 @@ typed
SPC y yank to the clipboard SPC p paste from it
SPC w window mode: h/j/k/l, Enter; d Del, c Collapse
SPC j j `Last` SPC j o / SPC j i back / forward
- SPC s a `Attach` SPC s D `Detach`
+ SPC s D `Detach`
SPC t ... the toggles SPC l ... the language
SPC h t this tutor