Build server-backed psyTerm with multiplexing and themed UI

Move terminal sessions, tabs, panes, and state into a persistent headless
server with local socket and SSH clients. Launch GUIs through a managed
single-threaded zygote while keeping rendering responsive.

Add animated cursors, themed chrome, teal pane focus outlines, uniform
tabs, and middle-truncated names. Support program/CWD titles, manual
renaming, home-directory abbreviation, and automatic pane/tab removal
when shells exit.

Document the process architecture, controls, and third-party cursor
sources. Validated with 57 tests, strict Clippy, and live Wayland checks.
This commit is contained in:
2026-11-17 01:08:35 -08:00
parent de1d5776b6
commit d7e9be973c
18 changed files with 5257 additions and 410 deletions
+198
View File
@@ -0,0 +1,198 @@
//! psyTerm chrome using the shared Sybil palette from the user's applications.
//!
//! Color sources:
//! - Huayra `src/styles.css`, active `data-theme="sybil"` theme.
//! - Sybil `web/src/index.css`, root color tokens.
//! - Attractor `chrome/browser/resources/attractor/theme.css`, surface tokens.
use std::rc::Rc;
use gpui::{
App, Div, ElementId, MouseButton, SharedString, Stateful, Window, div, prelude::*, px, rgb,
};
use crate::label::middle_label;
pub const APP_BACKGROUND: u32 = 0x06060f;
pub const PANEL_BACKGROUND: u32 = 0x080817;
pub const TERMINAL_BACKGROUND: u32 = 0x080917;
pub const CONTROL_BACKGROUND: u32 = 0x131122;
pub const HOVER_BACKGROUND: u32 = 0x1c1830;
pub const ACTIVE_BACKGROUND: u32 = 0x231c3b;
pub const BORDER: u32 = 0x282145;
pub const TEXT: u32 = 0xf3f1f8;
pub const MUTED: u32 = 0xa29fbc;
pub const ACCENT: u32 = 0x9858f9;
pub const CYAN: u32 = 0x4bdbf1;
// Huayra's Sybil green: hsl(163 72% 45%).
pub const PANE_FOCUS: u32 = 0x20c597;
pub const PANE_MUTED: u32 = 0x527f73;
pub const DANGER: u32 = 0xf26977;
pub const CONTENT_INSET: f32 = 8.;
pub const HEADER_HEIGHT: f32 = 44.;
pub struct ChromeTab {
pub id: u64,
pub label: SharedString,
pub active: bool,
}
/// An app-owned titlebar. Callbacks issue server commands; no tab state lives here.
/// The close callback should detach this GUI, leaving server sessions alive.
pub fn header(
connection: SharedString,
tabs: Vec<ChromeTab>,
on_tab: impl Fn(u64, &mut Window, &mut App) + 'static,
on_new: impl Fn(&mut Window, &mut App) + 'static,
on_close: impl Fn(&mut Window, &mut App) + 'static,
) -> Div {
let on_tab = Rc::new(on_tab);
let mut tab_strip = div()
.flex()
.items_center()
.gap(px(4.))
.flex_1()
.min_w_0()
.h_full()
.overflow_hidden();
for tab in tabs {
let on_tab = on_tab.clone();
let active = tab.active;
let id = tab.id;
tab_strip = tab_strip.child(
div()
.id(ElementId::Name(format!("tab-{id}").into()))
.flex()
.items_center()
.gap(px(7.))
.h(px(29.))
.flex_basis(px(200.))
.flex_shrink()
.min_w_0()
.max_w(px(200.))
.px(px(10.))
.border_1()
.border_color(rgb(if active { BORDER } else { PANEL_BACKGROUND }))
.bg(rgb(if active {
ACTIVE_BACKGROUND
} else {
PANEL_BACKGROUND
}))
.text_color(rgb(if active { TEXT } else { MUTED }))
.text_size(px(11.))
.cursor_pointer()
.hover(|style| style.bg(rgb(HOVER_BACKGROUND)).text_color(rgb(TEXT)))
.on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
.on_click(move |_, window, cx| {
cx.stop_propagation();
on_tab(id, window, cx);
})
.child(
div()
.w(px(3.))
.flex_shrink_0()
.h(px(12.))
.bg(rgb(if active { ACCENT } else { BORDER })),
)
.child(
div()
.flex_1()
.min_w_0()
.h_full()
.overflow_hidden()
.child(middle_label(tab.label)),
),
);
}
div()
.flex()
.flex_col()
.flex_shrink_0()
.h(px(HEADER_HEIGHT))
.w_full()
.bg(rgb(PANEL_BACKGROUND))
.border_b_1()
.border_color(rgb(BORDER))
.font_family(".SystemUIFont")
.text_color(rgb(TEXT))
.child(
div()
.flex()
.items_center()
.gap(px(10.))
.px(px(12.))
.flex_1()
.min_h_0()
.on_mouse_down(MouseButton::Left, |_, window, _| window.start_window_move())
.child(tab_strip)
.child(
div()
.flex()
.items_center()
.flex_shrink_0()
.gap(px(5.))
.max_w(px(170.))
.text_size(px(10.))
.text_color(rgb(MUTED))
.child(div().size(px(4.)).rounded_full().bg(rgb(CYAN)))
.child(div().text_ellipsis().child(connection)),
)
.child(control("new-tab", "+", false, on_new))
.child(control("detach-window", "×", true, on_close)),
)
}
fn control(
id: &'static str,
label: &'static str,
danger: bool,
on_click: impl Fn(&mut Window, &mut App) + 'static,
) -> Stateful<Div> {
div()
.id(id)
.flex()
.items_center()
.justify_center()
.flex_shrink_0()
.size(px(27.))
.text_size(px(18.))
.text_color(rgb(MUTED))
.cursor_pointer()
.hover(move |style| {
style
.bg(rgb(if danger {
CONTROL_BACKGROUND
} else {
HOVER_BACKGROUND
}))
.text_color(rgb(if danger { DANGER } else { TEXT }))
})
.on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
.on_click(move |_, window, cx| {
cx.stop_propagation();
on_click(window, cx);
})
.child(label)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn header_constructs_each_control_without_duplicate_hover_styles() {
// GPUI rejects installing a hover style twice before the first window
// frame. Exercise the complete header, including its danger control.
let _ = header(
"Local".into(),
vec![ChromeTab {
id: 1,
label: "Shell".into(),
active: true,
}],
|_, _, _| {},
|_, _| {},
|_, _| {},
);
}
}
+289
View File
@@ -0,0 +1,289 @@
//! Display-only client transport. No terminal parser, PTY, or shell lives here.
use crate::protocol::{self, ClientMessage, ServerMessage, Snapshot};
use anyhow::{Context, Result, bail};
use std::{
collections::VecDeque,
io::{Read, Write},
net::Shutdown,
os::unix::net::UnixStream,
path::Path,
process::{Child, Command, Stdio},
sync::{Arc, Mutex, mpsc},
thread,
};
#[derive(Default)]
pub struct Update {
pub snapshot: Option<Arc<Snapshot>>,
pub clipboard: VecDeque<String>,
pub error: Option<String>,
}
pub struct Updates {
signal: async_channel::Receiver<()>,
pending: Arc<Mutex<Update>>,
}
impl Updates {
pub async fn recv(&self) -> Option<Update> {
self.signal.recv().await.ok()?;
Some(std::mem::take(&mut *self.pending.lock().unwrap()))
}
}
#[derive(Clone)]
pub struct Client(Arc<Connection>);
struct Connection {
commands: mpsc::Sender<ClientMessage>,
socket: Option<UnixStream>,
ssh: Mutex<Option<Child>>,
}
impl Drop for Connection {
fn drop(&mut self) {
// Detach closes this transport, never a server-owned PTY.
if let Some(socket) = &self.socket {
let _ = socket.shutdown(Shutdown::Both);
}
if let Some(mut child) = self.ssh.lock().unwrap().take() {
let _ = child.kill();
let _ = child.wait();
}
}
}
impl Client {
pub fn connect(socket: &Path, remote: Option<&str>) -> Result<(Self, Updates)> {
let (reader, writer, socket, ssh): (Box<dyn Read + Send>, Box<dyn Write + Send>, _, _) =
if let Some(remote) = remote {
if remote.is_empty() || remote.starts_with('-') || remote.contains(['\n', '\r']) {
bail!("invalid SSH destination");
}
let executable =
std::env::var("PSYTERM_REMOTE_BIN").unwrap_or_else(|_| "psyterm".into());
let remote_command = format!("exec {} --bridge", shell_quote(&executable));
let mut child = Command::new("ssh")
.args([
"-T",
"-o",
"BatchMode=yes",
"-o",
"ConnectTimeout=10",
"--",
remote,
&remote_command,
])
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::inherit())
.spawn()
.context("start SSH terminal transport")?;
let reader = Box::new(child.stdout.take().unwrap()) as Box<dyn Read + Send>;
let writer = Box::new(child.stdin.take().unwrap()) as Box<dyn Write + Send>;
(reader, writer, None, Some(child))
} else {
let stream = UnixStream::connect(socket).context("connect to psyTerm server")?;
crate::launcher::verify_peer(&stream)?;
(
Box::new(stream.try_clone()?) as Box<dyn Read + Send>,
Box::new(stream.try_clone()?) as Box<dyn Write + Send>,
Some(stream),
None,
)
};
let (commands, receive) = mpsc::channel();
let (signal, notifications) = async_channel::bounded(1);
let pending = Arc::new(Mutex::new(Update::default()));
let connection = Self(Arc::new(Connection {
commands,
socket,
ssh: Mutex::new(ssh),
}));
let errors = pending.clone();
let notify = signal.clone();
thread::Builder::new()
.name("psyterm-client-writer".into())
.spawn(move || {
let mut writer = writer;
while let Ok(message) = receive.recv() {
if let Err(error) = protocol::write_message(&mut writer, &message) {
errors.lock().unwrap().error = Some(format!("Connection lost: {error:#}"));
let _ = notify.try_send(());
break;
}
}
})?;
let incoming = pending.clone();
thread::Builder::new()
.name("psyterm-client-reader".into())
.spawn(move || {
let mut reader = reader;
let mut greeted = false;
loop {
let message = protocol::read_message::<ServerMessage>(&mut reader);
let mut update = incoming.lock().unwrap();
match message {
Ok(ServerMessage::Hello { version, .. })
if version == protocol::VERSION =>
{
greeted = true
}
Ok(ServerMessage::Hello { .. }) => {
update.error =
Some("Server protocol version differs from this GUI".into());
let _ = signal.try_send(());
break;
}
Ok(ServerMessage::Snapshot(snapshot)) if greeted => {
if let Err(error) = validate_snapshot(&snapshot) {
update.error = Some(error.to_string());
let _ = signal.try_send(());
break;
}
// A slow window never accumulates a queue of obsolete frames.
update.snapshot = Some(Arc::new(snapshot));
}
Ok(ServerMessage::Clipboard(text)) if greeted => {
if update.clipboard.len() < 16 {
update.clipboard.push_back(text);
}
}
Ok(ServerMessage::Error(error)) => update.error = Some(error),
Ok(ServerMessage::Closing) => {
update.error =
Some("Server stopped. Shell sessions have ended.".into());
let _ = signal.try_send(());
break;
}
Ok(ServerMessage::Pong) => {}
Ok(_) => {
update.error = Some("Server sent data before its handshake".into());
}
Err(error) => {
update.error = Some(format!(
"Disconnected — sessions remain on the server. {error:#}"
));
let _ = signal.try_send(());
break;
}
}
drop(update);
let _ = signal.try_send(());
}
})?;
connection.send(ClientMessage::Hello {
version: protocol::VERSION,
})?;
connection.send(ClientMessage::Attach)?;
Ok((
connection,
Updates {
signal: notifications,
pending,
},
))
}
pub fn send(&self, message: ClientMessage) -> Result<()> {
self.0
.commands
.send(message)
.context("server transport is closed")
}
pub fn input(&self, pane: u64, bytes: Vec<u8>) -> Result<()> {
for chunk in bytes.chunks(64 * 1024) {
self.send(ClientMessage::Input {
pane,
bytes: chunk.to_vec(),
})?;
}
Ok(())
}
}
fn shell_quote(value: &str) -> String {
format!("'{}'", value.replace('\'', "'\\''"))
}
fn validate_snapshot(snapshot: &Snapshot) -> Result<()> {
if snapshot.tabs.len() > 256 || snapshot.panes.len() > 64 {
bail!("Server layout exceeds client limits");
}
for pane in &snapshot.panes {
let count = usize::from(pane.columns) * usize::from(pane.lines);
if pane.columns < 2
|| pane.lines == 0
|| count > 1_000_000
|| pane.cells.len() != count
|| pane.selected.len() != count
|| pane.colors.len() > alacritty_terminal::term::color::COUNT
{
bail!("Server sent an invalid terminal grid");
}
}
Ok(())
}
/// SSH starts this command on the remote host. Only framed protocol bytes use stdout.
pub fn bridge(socket: &Path) -> Result<()> {
crate::launcher::ensure_server(socket)?;
let stream = UnixStream::connect(socket)?;
let mut output = stream.try_clone()?;
let copy_input = thread::spawn(move || {
let result = copy_and_flush(&mut std::io::stdin().lock(), &mut output);
let _ = output.shutdown(Shutdown::Write);
result
});
let mut input = stream;
copy_and_flush(&mut input, &mut std::io::stdout().lock())?;
// Don't wait indefinitely for stdin after a remote server disconnects.
drop(copy_input);
Ok(())
}
// stdout is line-buffered even over SSH. Flush each binary chunk; waiting for a
// newline or EOF can withhold a frame tail and deadlock an otherwise idle GUI.
fn copy_and_flush(reader: &mut impl Read, writer: &mut impl Write) -> std::io::Result<()> {
let mut buffer = [0u8; 64 * 1024];
loop {
let count = match reader.read(&mut buffer) {
Ok(0) => return Ok(()),
Ok(count) => count,
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => continue,
Err(error) => return Err(error),
};
writer.write_all(&buffer[..count])?;
writer.flush()?;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn binary_bridge_flushes_without_newlines() {
struct Output {
bytes: Vec<u8>,
flushes: usize,
}
impl Write for Output {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.bytes.extend_from_slice(bytes);
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
self.flushes += 1;
Ok(())
}
}
let mut output = Output {
bytes: Vec::new(),
flushes: 0,
};
copy_and_flush(&mut b"binary-without-newlines".as_slice(), &mut output).unwrap();
assert_eq!(output.bytes, b"binary-without-newlines");
assert!(output.flushes > 0);
}
#[test]
fn remote_binary_paths_are_shell_quoted() {
assert_eq!(shell_quote("/tmp/a'b; x"), "'/tmp/a'\\''b; x'");
}
}
+2 -2
View File
@@ -9,8 +9,8 @@ use alacritty_terminal::{
};
use gpui::Hsla;
pub const BACKGROUND: u32 = 0x181a1f;
pub const FOREGROUND: u32 = 0xd8dee9;
pub const BACKGROUND: u32 = 0x080917;
pub const FOREGROUND: u32 = 0xf3f1f8;
const ANSI: [u32; 16] = [
0x282c34, 0xe06c75, 0x98c379, 0xe5c07b, 0x61afef, 0xc678dd, 0x56b6c2, 0xabb2bf, 0x5c6370,
+446
View File
@@ -0,0 +1,446 @@
//! Neovide's four-corner spring motion with buzzlocker's cubic fade blink.
//!
//! Motion derives from Neovide (MIT, copyright 2023 Neovide Contributors).
//! See THIRD_PARTY_NOTICES.md and licenses/neovide-MIT.txt for source attribution.
//! The blink is adapted from buzzlocker's render.c / animation.c at its author's
//! request. Keep its asymmetric fade-out / immediate-on behavior.
use std::time::{Duration, Instant};
use alacritty_terminal::vte::ansi::CursorShape;
use gpui::{Bounds, Hsla, PathBuilder, Pixels, Point, Window, point, px};
const LONG_MOVE: f32 = 0.150;
const SHORT_MOVE: f32 = 0.040;
const BLINK_HOLD: f32 = 0.5;
const BLINK_FADE: f32 = 0.5;
const STANDARD_CORNERS: [[f32; 2]; 4] = [[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]];
/// The spring equations are retained from Neovide's animation_utils.rs.
#[derive(Clone, Copy, Default)]
struct CriticallyDampedSpringAnimation {
position: f32,
velocity: f32,
}
impl CriticallyDampedSpringAnimation {
fn update(&mut self, dt: f32, animation_length: f32) -> bool {
if animation_length <= dt {
self.reset();
return false;
}
if self.position == 0.0 {
return false;
}
// Analytical solution for a critically damped harmonic oscillator.
// Omega reaches the destination with 2% tolerance in animation_length.
let zeta = 1.0;
let omega = 4.0 / (zeta * animation_length);
let a = self.position;
let b = self.position * omega + self.velocity;
let c = (-omega * dt).exp();
self.position = (a + b * dt) * c;
self.velocity = c * (-a * omega - b * dt * omega + b);
if self.position.abs() < 0.01 {
self.reset();
false
} else {
true
}
}
fn reset(&mut self) {
self.position = 0.0;
self.velocity = 0.0;
}
}
#[derive(Clone, Copy, Default)]
struct Corner {
position: [f32; 2],
destination: [f32; 2],
x: CriticallyDampedSpringAnimation,
y: CriticallyDampedSpringAnimation,
animation_length: f32,
}
impl Corner {
fn snap(&mut self, destination: [f32; 2]) {
self.destination = destination;
self.position = destination;
self.x.reset();
self.y.reset();
}
fn update(&mut self, dt: f32) -> bool {
let mut moving = self.x.update(dt, self.animation_length);
moving |= self.y.update(dt, self.animation_length);
self.position = [
self.destination[0] - self.x.position,
self.destination[1] - self.y.position,
];
moving
}
}
#[derive(Clone, Copy)]
struct Target {
bounds: Bounds<Pixels>,
shape: CursorShape,
color: Hsla,
}
#[derive(Default)]
pub struct CursorAnimator {
corners: [Corner; 4],
target: Option<Target>,
last_frame: Option<Instant>,
last_activity: Option<Instant>,
was_focused: bool,
}
struct Frame {
points: [Point<Pixels>; 4],
opacity: f32,
outline: bool,
next: Option<Duration>,
}
impl CursorAnimator {
pub fn new() -> Self {
Self::default()
}
/// Cursor bounds are in window coordinates and cover a full terminal cell
/// (two cells for a wide block cursor). Pass the desired fill alpha in color;
/// an overlay renderer can use a translucent color to leave text readable.
pub fn set_target(
&mut self,
bounds: Bounds<Pixels>,
shape: CursorShape,
color: Hsla,
now: Instant,
) {
let next = Target {
bounds,
shape,
color,
};
let changed = self
.target
.is_none_or(|old| old.bounds != bounds || old.shape != shape);
if !changed {
self.target = Some(next);
return;
}
// Advance the old destination before redirecting, preserving its spring
// velocity. Reset the clock here so a move after an idle blink hold does
// not get interpreted as a huge animation time step and snap instantly.
if self.was_focused {
self.advance_motion(now);
}
let destinations = destinations(next);
if self.target.is_none() || !self.was_focused || shape == CursorShape::Hidden {
for (corner, destination) in self.corners.iter_mut().zip(destinations) {
corner.snap(destination);
}
} else {
self.jump(next, destinations);
}
self.target = Some(next);
self.last_frame = Some(now);
self.activity(now);
}
/// Call on keyboard input, including keys that don't move the cursor.
pub fn activity(&mut self, now: Instant) {
self.last_activity = Some(now);
}
/// Paint the cursor, returning when another frame is required.
///
/// `Some(Duration::ZERO)` means use GPUI's next animation frame. A positive
/// delay is the remaining solid blink hold and can use an executor timer.
/// `None` means the hidden/unfocused cursor needs no animation wakeup.
/// Focus changes still need to notify the view to paint the new appearance.
pub fn paint(&mut self, now: Instant, focused: bool, window: &mut Window) -> Option<Duration> {
let frame = self.frame(now, focused);
let target = self.target?;
if frame.opacity <= 0.0 {
return frame.next;
}
let mut color = target.color;
// Hollow cursors stay fully visible even if the focused overlay uses a
// translucent fill. Their one-pixel perimeter does not obscure text.
color.a = if frame.outline && !focused {
1.0
} else {
color.a * frame.opacity
};
let mut path = if frame.outline {
PathBuilder::stroke(px((f32::from(target.bounds.size.width) / 8.).max(1.)))
} else {
PathBuilder::fill()
};
path.add_polygon(&frame.points, true);
match path.build() {
Ok(path) => window.paint_path(path, color),
Err(error) => log::debug!("cursor path: {error}"),
}
frame.next
}
fn jump(&mut self, target: Target, destinations: [[f32; 2]; 4]) {
let mut alignments = [0.; 4];
let width = f32::from(target.bounds.size.width).max(1.);
let height = f32::from(target.bounds.size.height).max(1.);
let relative = relative_corners(target.shape);
for (index, corner) in self.corners.iter().enumerate() {
let travel = normalized([
destinations[index][0] - corner.destination[0],
destinations[index][1] - corner.destination[1],
]);
let direction = normalized(relative[index]);
alignments[index] = travel[0] * direction[0] + travel[1] * direction[1];
}
let min = alignments.iter().copied().fold(f32::INFINITY, f32::min);
let max = alignments.iter().copied().fold(f32::NEG_INFINITY, f32::max);
for (index, corner) in self.corners.iter_mut().enumerate() {
let destination = destinations[index];
let jump = [
(destination[0] - corner.destination[0]) / width,
(destination[1] - corner.destination[1]) / height,
];
let alignment = (alignments[index] - min) / (max - min);
let alignment = if alignment.is_finite() {
alignment.clamp(0., 1.)
} else {
1.
};
corner.animation_length = if jump[0].abs() <= 2.001 && jump[1].abs() <= 0.001 {
LONG_MOVE.min(SHORT_MOVE)
} else {
// Neovide's default trail_size=1: leading corner duration=0.
LONG_MOVE + (0. - LONG_MOVE) * alignment
};
corner.x.position = destination[0] - corner.position[0];
corner.y.position = destination[1] - corner.position[1];
corner.destination = destination;
}
}
fn advance_motion(&mut self, now: Instant) -> bool {
let dt = self
.last_frame
.map_or(0., |last| now.saturating_duration_since(last).as_secs_f32());
self.last_frame = Some(now);
self.corners
.iter_mut()
.fold(false, |moving, corner| corner.update(dt) | moving)
}
fn frame(&mut self, now: Instant, focused: bool) -> Frame {
let Some(target) = self.target else {
return hidden_frame();
};
if target.shape == CursorShape::Hidden {
self.was_focused = focused;
self.last_frame = Some(now);
return hidden_frame();
}
if focused != self.was_focused {
for (corner, destination) in self.corners.iter_mut().zip(destinations(target)) {
corner.snap(destination);
}
self.activity(now);
}
self.was_focused = focused;
self.last_frame.get_or_insert(now);
if !focused {
// Blurred windows show an unanimated full-cell outline, even if the
// foreground application requested a beam or underline cursor.
let mut full_cell = target;
full_cell.shape = CursorShape::Block;
for (corner, destination) in self.corners.iter_mut().zip(destinations(target)) {
corner.snap(destination);
}
self.last_frame = Some(now);
return Frame {
points: destinations(full_cell).map(|p| point(px(p[0]), px(p[1]))),
opacity: 1.,
outline: true,
next: None,
};
}
let moving = self.advance_motion(now);
let elapsed = now
.saturating_duration_since(self.last_activity.unwrap_or(now))
.as_secs_f32();
let (opacity, blink_next) = blink(elapsed);
let fract = [
f32::from(target.bounds.origin.x).fract(),
f32::from(target.bounds.origin.y).fract(),
];
Frame {
// Preserve Neovide's subpixel-origin snapping for crisp stationary
// edges while the four spring positions deform independently.
points: self.corners.map(|corner| {
point(
px((corner.position[0] - fract[0]).round() + fract[0]),
px((corner.position[1] - fract[1]).round() + fract[1]),
)
}),
opacity,
outline: target.shape == CursorShape::HollowBlock,
next: Some(if moving { Duration::ZERO } else { blink_next }),
}
}
}
fn hidden_frame() -> Frame {
Frame {
points: [point(px(0.), px(0.)); 4],
opacity: 0.,
outline: false,
next: None,
}
}
fn relative_corners(shape: CursorShape) -> [[f32; 2]; 4] {
STANDARD_CORNERS.map(|[x, y]| match shape {
CursorShape::Beam => [(x + 0.5) / 8. - 0.5, y],
CursorShape::Underline => [x, -((-y + 0.5) / 8. - 0.5)],
_ => [x, y],
})
}
fn destinations(target: Target) -> [[f32; 2]; 4] {
let width = f32::from(target.bounds.size.width);
let height = f32::from(target.bounds.size.height);
let center = [
f32::from(target.bounds.origin.x) + width / 2.,
f32::from(target.bounds.origin.y) + height / 2.,
];
relative_corners(target.shape).map(|[x, y]| [center[0] + x * width, center[1] + y * height])
}
fn normalized([x, y]: [f32; 2]) -> [f32; 2] {
let length = x.hypot(y);
if length == 0. {
[0., 0.]
} else {
[x / length, y / length]
}
}
/// buzzlocker uses cubic ease-out for OUT and a constant 1 for IN.
fn blink(elapsed: f32) -> (f32, Duration) {
if elapsed < BLINK_HOLD {
return (1., Duration::from_secs_f32(BLINK_HOLD - elapsed));
}
let phase = (elapsed - BLINK_HOLD) % (BLINK_FADE + BLINK_HOLD);
if phase < BLINK_FADE {
let p = phase / BLINK_FADE;
((1. - p).powi(3), Duration::ZERO)
} else {
(1., Duration::from_secs_f32(BLINK_FADE + BLINK_HOLD - phase))
}
}
#[cfg(test)]
mod tests {
use super::*;
use gpui::{rgb, size};
fn bounds(x: f32, y: f32) -> Bounds<Pixels> {
Bounds::new(point(px(x), px(y)), size(px(10.), px(20.)))
}
fn target(cursor: &mut CursorAnimator, x: f32, y: f32, shape: CursorShape, now: Instant) {
cursor.set_target(bounds(x, y), shape, rgb(0xffffff).into(), now);
}
#[test]
fn blink_matches_buzzlocker_hold_cubic_fade_and_immediate_on() {
assert_eq!(blink(0.).0, 1.);
assert_eq!(blink(0.49).0, 1.);
assert_eq!(blink(0.5).0, 1.);
assert!((blink(0.75).0 - 0.125).abs() < 0.0001);
assert!(blink(0.999).0 < 0.0001);
assert_eq!(blink(1.).0, 1.);
assert_eq!(blink(1.25).0, 1.);
assert!((blink(1.75).0 - 0.125).abs() < 0.0001);
assert_eq!(blink(0.25).1, Duration::from_millis(250));
}
#[test]
fn leading_corners_snap_while_trailing_corners_deform() {
let now = Instant::now();
let mut cursor = CursorAnimator::new();
target(&mut cursor, 0., 0., CursorShape::Block, now);
cursor.frame(now, true);
target(&mut cursor, 100., 0., CursorShape::Block, now);
let frame = cursor.frame(now + Duration::from_millis(16), true);
assert_eq!(frame.points[1].x, px(110.));
assert!(frame.points[0].x > px(0.) && frame.points[0].x < px(100.));
assert_eq!(frame.next, Some(Duration::ZERO));
for index in 2..100 {
cursor.frame(now + Duration::from_millis(index * 16), true);
}
assert_eq!(cursor.corners[0].position[0], 100.);
}
#[test]
fn typing_uses_short_move_duration_and_resets_blink() {
let now = Instant::now();
let mut cursor = CursorAnimator::new();
target(&mut cursor, 0., 0., CursorShape::Block, now);
cursor.frame(now, true);
let later = now + Duration::from_millis(750);
assert!(cursor.frame(later, true).opacity < 0.2);
target(&mut cursor, 10., 0., CursorShape::Block, later);
assert_eq!(cursor.frame(later, true).opacity, 1.);
assert!(
cursor
.corners
.iter()
.all(|corner| corner.animation_length == SHORT_MOVE)
);
let mid = cursor.frame(later + Duration::from_millis(8), true);
assert!(mid.points[0].x < px(10.));
}
#[test]
fn blur_snaps_to_full_cell_outline_and_stops_animation() {
let now = Instant::now();
let mut cursor = CursorAnimator::new();
target(&mut cursor, 0., 0., CursorShape::Beam, now);
cursor.frame(now, true);
target(&mut cursor, 100., 40., CursorShape::Beam, now);
let frame = cursor.frame(now + Duration::from_millis(16), false);
assert!(frame.outline);
assert_eq!(frame.opacity, 1.);
assert_eq!(frame.next, None);
assert_eq!(frame.points[0], point(px(100.), px(40.)));
assert_eq!(frame.points[2], point(px(110.), px(60.)));
let later = cursor.frame(now + Duration::from_secs(4), false);
assert_eq!(later.points, frame.points);
assert_eq!(later.opacity, frame.opacity);
let refocused = cursor.frame(now + Duration::from_secs(5), true);
assert!(!refocused.outline);
assert_eq!(refocused.opacity, 1.);
}
#[test]
fn hidden_cursor_never_draws_or_schedules_frames() {
let now = Instant::now();
let mut cursor = CursorAnimator::new();
target(&mut cursor, 0., 0., CursorShape::Hidden, now);
let frame = cursor.frame(now, true);
assert_eq!(frame.opacity, 0.);
assert_eq!(frame.next, None);
}
}
+155
View File
@@ -0,0 +1,155 @@
//! Single-line chrome labels that keep both ends visible when space is tight.
use gpui::{
ContentMask, IntoElement, Pixels, ShapedLine, SharedString, TextStyle, Window, canvas, point,
prelude::*, px,
};
use unicode_segmentation::UnicodeSegmentation;
/// Fill the parent's allocated label area, inheriting its font, size and color.
pub fn middle_label(text: SharedString) -> impl IntoElement {
canvas(
move |bounds, window, _| {
let style = window.text_style();
let height = style.line_height_in_pixels(window.rem_size());
let line = fit_line(text, bounds.size.width, &style, window);
(line, height)
},
|bounds, (line, height), window, cx| {
if let Some(line) = line {
let origin = bounds.origin + point(px(0.), (bounds.size.height - height) / 2.);
window.with_content_mask(Some(ContentMask { bounds }), |window| {
let _ = line.paint(origin, height, window, cx);
});
}
},
)
.size_full()
}
fn shape(text: SharedString, style: &TextStyle, window: &Window) -> ShapedLine {
let size = style.font_size.to_pixels(window.rem_size());
let run = style.to_run(text.len());
window.text_system().shape_line(text, size, &[run], None)
}
fn fit_line(
text: SharedString,
available: Pixels,
style: &TextStyle,
window: &Window,
) -> Option<ShapedLine> {
if available <= px(0.) || text.is_empty() {
return None;
}
let full = shape(text.clone(), style, window);
if full.width <= available {
return Some(full);
}
let ellipsis = shape("…".into(), style, window);
if ellipsis.width > available {
return None;
}
let boundaries: Vec<_> = text
.grapheme_indices(true)
.map(|(index, _)| index)
.chain(std::iter::once(text.len()))
.collect();
// Use the existing full-line glyph positions to estimate the retained
// pieces. Sorting once avoids repeatedly scanning every glyph per cut.
let mut glyphs: Vec<_> = full
.runs
.iter()
.flat_map(|run| run.glyphs.iter())
.map(|glyph| (glyph.index, f32::from(glyph.position.x)))
.collect();
glyphs.sort_by_key(|&(index, _)| index);
let total = f32::from(full.width);
let mut previous = 0.;
let positions: Vec<_> = boundaries
.iter()
.map(|&boundary| {
let glyph = glyphs.partition_point(|&(index, _)| index < boundary);
let x = glyphs.get(glyph).map_or(total, |&(_, x)| x);
// Bidirectional runs can have nonmonotonic glyph positions. Treat
// these as estimates; the final shortened line is always measured.
previous = x.clamp(previous, total);
previous
})
.collect();
let mut budget = f32::from(available - ellipsis.width);
// Usually only one shortened line is shaped. Contextual shaping can alter
// edge widths; allow two bounded corrections rather than shaping each cut.
for _ in 0..3 {
let (prefix, suffix) = middle_split(&positions, budget);
let shortened = format!(
"{}…{}",
&text[..boundaries[prefix]],
&text[boundaries[suffix]..]
);
let line = shape(shortened.into(), style, window);
if line.width <= available {
return Some(line);
}
budget -= f32::from(line.width - available).max(budget * 0.1).max(1.);
if budget <= 0. {
break;
}
}
Some(ellipsis)
}
/// Choose whole graphemes from both ends, balancing their measured widths.
/// At least one grapheme remains omitted between the two retained pieces.
fn middle_split(positions: &[f32], budget: f32) -> (usize, usize) {
let last = positions.len().saturating_sub(1);
let mut prefix = 0;
let mut suffix = last;
let total = positions[last];
while prefix + 1 < suffix {
let left = positions[prefix];
let right = total - positions[suffix];
let can_left = positions[prefix + 1] + right <= budget;
let can_right = left + total - positions[suffix - 1] <= budget;
if can_left && (left < right || !can_right) {
prefix += 1;
} else if can_right {
suffix -= 1;
} else {
break;
}
}
(prefix, suffix)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn cuts_keep_both_ends_within_the_measured_budget() {
let positions = [0., 4., 10., 14., 18., 23., 30., 35.];
let (left, right) = middle_split(&positions, 20.);
assert!(left > 0 && right < positions.len() - 1 && left < right);
assert!(positions[left] + positions.last().unwrap() - positions[right] <= 20.);
assert_eq!(middle_split(&positions, 0.), (0, positions.len() - 1));
}
#[test]
fn cuts_preserve_combining_characters_and_emoji_sequences() {
let text = "~é/e\u{301}/👩🏽‍💻/終点";
let boundaries: Vec<_> = text
.grapheme_indices(true)
.map(|(index, _)| index)
.chain(std::iter::once(text.len()))
.collect();
let positions: Vec<_> = (0..boundaries.len()).map(|i| i as f32).collect();
for width in 0..boundaries.len() {
let (left, right) = middle_split(&positions, width as f32);
let prefix = &text[..boundaries[left]];
let suffix = &text[boundaries[right]..];
assert_eq!(prefix.graphemes(true).count(), left);
assert_eq!(suffix.graphemes(true).count(), boundaries.len() - 1 - right);
}
}
}
+754
View File
@@ -0,0 +1,754 @@
//! Local daemon startup and the server-owned, single-threaded GUI zygote.
//!
//! GPUI, fonts, Wayland, Vulkan, and executors are initialized only in forked GUI
//! children. Forking a process after any of those start threads is unsupported.
use std::{
fs::{self, DirBuilder, File, OpenOptions},
io,
os::{
fd::AsRawFd,
unix::{
ffi::{OsStrExt, OsStringExt},
fs::{DirBuilderExt, FileTypeExt, MetadataExt, OpenOptionsExt, PermissionsExt},
net::{UnixListener, UnixStream},
process::CommandExt,
},
},
path::{Path, PathBuf},
process::{Child, Command, Stdio},
thread,
time::{Duration, Instant},
};
use anyhow::{Context, Result, bail};
use serde::{Deserialize, Serialize};
use crate::protocol::{self, ClientMessage, ServerMessage};
const START_TIMEOUT: Duration = Duration::from_secs(10);
const REQUEST_TIMEOUT: Duration = Duration::from_secs(5);
pub fn default_socket() -> Result<PathBuf> {
let root = if let Some(runtime) = std::env::var_os("XDG_RUNTIME_DIR") {
let runtime = PathBuf::from(runtime);
verify_private_directory(&runtime)?;
runtime.join("psyterm")
} else {
std::env::temp_dir().join(format!("psyterm-{}", uid()))
};
ensure_private_directory(&root)?;
Ok(root.join("server.sock"))
}
/// Start exactly one daemon. The daemon has its own lifetime lock; this lock is
/// held only while racing launchers agree on which process starts it.
pub fn ensure_server(socket: &Path) -> Result<()> {
ensure_socket_parent(socket)?;
if probe_server(socket)? {
return Ok(());
}
let startup_lock = private_file(&suffixed(socket, ".startup.lock"))?;
// SAFETY: flock operates on our live file descriptor and has no pointers.
if unsafe { libc::flock(startup_lock.as_raw_fd(), libc::LOCK_EX) } != 0 {
return Err(io::Error::last_os_error()).context("lock server startup");
}
if probe_server(socket)? {
return Ok(());
}
let log_path = suffixed(socket, ".log");
let mut child = spawn_role("--server", socket, &log_path)?;
let deadline = Instant::now() + START_TIMEOUT;
loop {
if probe_server(socket)? {
return Ok(());
}
if let Some(status) = child.try_wait()? {
bail!(
"psyTerm server exited ({status}); see {}",
log_path.display()
);
}
if Instant::now() >= deadline {
// This process is ours and never became available to clients.
let _ = child.kill();
let _ = child.wait();
bail!(
"psyTerm server startup timed out; see {}",
log_path.display()
);
}
thread::sleep(Duration::from_millis(15));
}
}
/// Send a command without attaching a GUI or creating a terminal session.
pub fn control(socket: &Path, command: ClientMessage) -> Result<ServerMessage> {
let stream = UnixStream::connect(socket)
.with_context(|| format!("connect to psyTerm server at {}", socket.display()))?;
let legacy_shutdown = matches!(command, ClientMessage::Shutdown);
let result = control_stream(stream, command, REQUEST_TIMEOUT);
if legacy_shutdown
&& protocol::VERSION > 1
&& result
.as_ref()
.is_err_and(|error| error.to_string().contains("protocol"))
{
// Version 1 shares the Hello/Shutdown/Closing wire prefix. Permit only
// an explicit shutdown through that prefix, never old grid decoding.
let stream = UnixStream::connect(socket)?;
return control_stream_version(stream, ClientMessage::Shutdown, REQUEST_TIMEOUT, 1);
}
result
}
fn probe_server(socket: &Path) -> Result<bool> {
match UnixStream::connect(socket) {
Ok(stream) => {
match control_stream(stream, ClientMessage::Ping, Duration::from_millis(500))? {
ServerMessage::Pong => Ok(true),
_ => bail!("psyTerm server did not acknowledge startup probe"),
}
}
Err(error)
if matches!(
error.kind(),
io::ErrorKind::NotFound | io::ErrorKind::ConnectionRefused
) =>
{
Ok(false)
}
Err(error) => Err(error).with_context(|| format!("probe {}", socket.display())),
}
}
fn control_stream(
stream: UnixStream,
command: ClientMessage,
timeout: Duration,
) -> Result<ServerMessage> {
control_stream_version(stream, command, timeout, protocol::VERSION)
}
fn control_stream_version(
mut stream: UnixStream,
command: ClientMessage,
timeout: Duration,
expected_version: u32,
) -> Result<ServerMessage> {
verify_peer(&stream)?;
stream.set_read_timeout(Some(timeout))?;
stream.set_write_timeout(Some(timeout))?;
protocol::write_message(
&mut stream,
&ClientMessage::Hello {
version: expected_version,
},
)?;
match protocol::read_message::<ServerMessage>(&mut stream)? {
ServerMessage::Hello { version, .. } if version == expected_version => {}
ServerMessage::Hello { version, .. } => bail!(
"server protocol {version} does not match client protocol {}",
expected_version
),
ServerMessage::Error(error) => bail!(
"{error}. If the server predates this build, end its sessions with psyterm --shutdown and relaunch"
),
_ => bail!("server did not send a protocol greeting"),
}
protocol::write_message(&mut stream, &command)?;
loop {
let message: ServerMessage = protocol::read_message(&mut stream)?;
match message {
ServerMessage::Pong | ServerMessage::Closing => return Ok(message),
ServerMessage::Error(error) => bail!("{error}"),
_ => {}
}
}
}
/// Owned by the terminal server. Its GUI children are independent clients and
/// keep running when this helper is stopped; stopping the helper never kills them.
pub struct Zygote {
server_socket: PathBuf,
socket: PathBuf,
child: Child,
ready: bool,
executable: PathBuf,
executable_identity: ExecutableIdentity,
}
impl Zygote {
pub fn start(server_socket: &Path) -> Result<Self> {
ensure_socket_parent(server_socket)?;
let socket = suffixed(server_socket, ".zygote.sock");
let log_path = suffixed(server_socket, ".zygote.log");
let executable = executable_path()?;
let executable_identity = ExecutableIdentity::read(&executable)?;
let child = spawn_role_from(&executable, "--zygote", &socket, &log_path)?;
let mut zygote = Self {
server_socket: server_socket.to_owned(),
socket,
child,
ready: false,
executable,
executable_identity,
};
let deadline = Instant::now() + START_TIMEOUT;
loop {
if let Ok(LaunchResponse::Ready { pid }) = zygote.request(&LaunchRequest::Ping) {
if pid != zygote.child.id() {
bail!(
"a different GUI zygote is already listening at {}",
zygote.socket.display()
);
}
zygote.ready = true;
return Ok(zygote);
}
if let Some(status) = zygote.child.try_wait()? {
bail!(
"psyTerm zygote exited ({status}); see {}",
log_path.display()
);
}
if Instant::now() >= deadline {
bail!(
"psyTerm zygote startup timed out; see {}",
log_path.display()
);
}
thread::sleep(Duration::from_millis(15));
}
}
pub fn open_window(&mut self, remote: Option<String>) -> Result<()> {
let executable = executable_path()?;
let identity = ExecutableIdentity::read(&executable)?;
let helper_exited = self.child.try_wait()?.is_some();
if helper_exited || executable != self.executable || identity != self.executable_identity {
log::info!("Refreshing GUI zygote after executable replacement or helper exit");
self.stop();
// Assignment drops the stopped helper only after a replacement is
// ready. If startup fails, a later launch can retry this stopped one.
*self = Self::start(&self.server_socket)?;
}
match self.request(&LaunchRequest::Launch {
server_socket: self.server_socket.clone(),
remote,
})? {
LaunchResponse::Launched { pid } => {
log::info!("Forked psyTerm GUI {pid} from zygote {}", self.child.id());
Ok(())
}
LaunchResponse::Error(error) => bail!("{error}"),
_ => bail!("unexpected GUI zygote reply"),
}
}
fn request(&self, request: &LaunchRequest) -> Result<LaunchResponse> {
let mut stream = UnixStream::connect(&self.socket)?;
verify_peer(&stream)?;
stream.set_read_timeout(Some(REQUEST_TIMEOUT))?;
stream.set_write_timeout(Some(REQUEST_TIMEOUT))?;
protocol::write_message(&mut stream, request)?;
protocol::read_message(&mut stream)
}
fn stop(&mut self) {
if matches!(self.child.try_wait(), Ok(Some(_))) {
return;
}
if self.ready {
let _ = self.request(&LaunchRequest::Shutdown);
}
let deadline = Instant::now() + Duration::from_millis(500);
while Instant::now() < deadline {
if matches!(self.child.try_wait(), Ok(Some(_))) {
return;
}
thread::sleep(Duration::from_millis(10));
}
let _ = self.child.kill();
let _ = self.child.wait();
self.ready = false;
}
}
impl Drop for Zygote {
fn drop(&mut self) {
self.stop();
}
}
#[derive(Debug, PartialEq, Eq)]
struct ExecutableIdentity {
device: u64,
inode: u64,
bytes: u64,
modified: std::time::SystemTime,
}
impl ExecutableIdentity {
fn read(path: &Path) -> Result<Self> {
let metadata =
fs::metadata(path).with_context(|| format!("inspect executable {}", path.display()))?;
if !metadata.is_file() {
bail!("{} is not an executable file", path.display());
}
Ok(Self {
device: metadata.dev(),
inode: metadata.ino(),
bytes: metadata.len(),
modified: metadata.modified()?,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
enum LaunchRequest {
Ping,
Launch {
server_socket: PathBuf,
remote: Option<String>,
},
Shutdown,
}
#[derive(Debug, Serialize, Deserialize)]
enum LaunchResponse {
Ready { pid: u32 },
Launched { pid: u32 },
Error(String),
Stopped,
}
pub fn run_zygote(socket: &Path) -> Result<()> {
ensure_single_threaded()?;
// SAFETY: the fixed NUL-terminated name fits Linux's 16-byte comm field.
unsafe {
libc::prctl(libc::PR_SET_NAME, c"psyterm-zygote".as_ptr());
}
ensure_socket_parent(socket)?;
remove_stale_socket(socket)?;
let listener = UnixListener::bind(socket).context("bind GUI zygote socket")?;
fs::set_permissions(socket, fs::Permissions::from_mode(0o600))?;
let _socket_guard = SocketGuard::new(socket)?;
set_child_reaping(true)?;
log::info!("Single-threaded GUI zygote {} ready", std::process::id());
loop {
let (mut stream, _) = match listener.accept() {
Ok(connection) => connection,
Err(error) if error.kind() == io::ErrorKind::Interrupted => continue,
Err(error) => return Err(error).context("accept GUI launch request"),
};
if let Err(error) = verify_peer(&stream) {
log::warn!("Rejected GUI launch peer: {error}");
continue;
}
stream.set_read_timeout(Some(REQUEST_TIMEOUT))?;
stream.set_write_timeout(Some(REQUEST_TIMEOUT))?;
let request = match protocol::read_message::<LaunchRequest>(&mut stream) {
Ok(request) => request,
Err(error) => {
log::debug!("Incomplete GUI launch request: {error}");
continue;
}
};
match request {
LaunchRequest::Ping => protocol::write_message(
&mut stream,
&LaunchResponse::Ready {
pid: std::process::id(),
},
)?,
LaunchRequest::Shutdown => {
protocol::write_message(&mut stream, &LaunchResponse::Stopped)?;
return Ok(());
}
LaunchRequest::Launch {
server_socket,
remote,
} => {
if let Err(error) = ensure_single_threaded() {
protocol::write_message(
&mut stream,
&LaunchResponse::Error(error.to_string()),
)?;
continue;
}
// SAFETY: this process is single-threaded (checked above) and
// has never initialized GPUI/Wayland/Vulkan or an executor. All
// Rust allocator/logger locks can only have belonged to this
// thread and are unlocked here. The child closes inherited IPC
// descriptors, resets SIGCHLD, and owns its fresh GUI runtime.
let pid = unsafe { libc::fork() };
if pid == -1 {
protocol::write_message(
&mut stream,
&LaunchResponse::Error(io::Error::last_os_error().to_string()),
)?;
continue;
}
if pid == 0 {
// SAFETY: this only labels our forked GUI process for tools.
unsafe {
libc::prctl(libc::PR_SET_NAME, c"psyterm-gui".as_ptr());
}
drop(stream);
drop(listener);
let result = set_child_reaping(false)
.and_then(|()| crate::run_gui(server_socket, remote));
let code = if let Err(error) = result {
log::error!("GUI startup failed: {error:#}");
1
} else {
0
};
// SAFETY: this fork child must not run parent scope cleanup
// (particularly the shared listening socket's unlink guard).
unsafe { libc::_exit(code) };
}
protocol::write_message(
&mut stream,
&LaunchResponse::Launched { pid: pid as u32 },
)?;
}
}
}
}
fn set_child_reaping(auto_reap: bool) -> Result<()> {
// SAFETY: sigaction is initialized before use, uses SIG_DFL (no callback),
// and points only to stack storage for the duration of these calls.
unsafe {
let mut action: libc::sigaction = std::mem::zeroed();
action.sa_sigaction = libc::SIG_DFL;
libc::sigemptyset(&mut action.sa_mask);
action.sa_flags = if auto_reap {
libc::SA_NOCLDWAIT | libc::SA_RESTART
} else {
0
};
if libc::sigaction(libc::SIGCHLD, &action, std::ptr::null_mut()) == -1 {
return Err(io::Error::last_os_error()).context("configure child reaping");
}
}
Ok(())
}
fn ensure_single_threaded() -> Result<()> {
let count = fs::read_dir("/proc/self/task")
.context("verify zygote thread count")?
.count();
if count != 1 {
bail!("refusing to fork GUI zygote with {count} threads; initialize GPUI only after fork");
}
Ok(())
}
fn spawn_role(role: &str, socket: &Path, log_path: &Path) -> Result<Child> {
spawn_role_from(&executable_path()?, role, socket, log_path)
}
fn spawn_role_from(executable: &Path, role: &str, socket: &Path, log_path: &Path) -> Result<Child> {
let log = private_file(log_path)?;
let mut command = Command::new(executable);
command
.arg(role)
.arg("--socket")
.arg(socket)
.stdin(Stdio::null())
.stdout(Stdio::from(log.try_clone()?))
.stderr(Stdio::from(log));
let managed_helper = role == "--zygote";
let parent_pid = std::process::id() as libc::pid_t;
// SAFETY: the closure calls only libc syscalls and performs no allocation or
// synchronization between Command's fork and exec. A zygote follows its
// server's lifetime; the server itself intentionally outlives its launcher.
unsafe {
command.pre_exec(move || {
if libc::setsid() == -1 {
return Err(io::Error::last_os_error());
}
if managed_helper {
if libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGTERM) == -1 {
return Err(io::Error::last_os_error());
}
if libc::getppid() != parent_pid {
libc::_exit(1);
}
}
Ok(())
});
}
command
.spawn()
.with_context(|| format!("launch psyTerm {role}"))
}
/// Linux marks `/proc/self/exe` with " (deleted)" after atomic replacement.
/// Resolve the new installed path without rewriting a real filename that happens
/// to end with those characters. Server logic remains loaded until shutdown;
/// only newly forked GUI code is refreshed by `Zygote::open_window`.
fn executable_path() -> Result<PathBuf> {
resolve_executable_path(std::env::current_exe()?)
}
fn resolve_executable_path(path: PathBuf) -> Result<PathBuf> {
match fs::symlink_metadata(&path) {
Ok(_) => {
if path.is_file() {
return Ok(path);
}
bail!("{} is not an executable file", path.display());
}
Err(error) if error.kind() == io::ErrorKind::NotFound => {}
Err(error) => return Err(error).context("inspect current executable path"),
}
if let Some(original) = path.as_os_str().as_bytes().strip_suffix(b" (deleted)") {
let original = PathBuf::from(std::ffi::OsString::from_vec(original.to_vec()));
if original.is_file() {
return Ok(original);
}
}
bail!(
"psyTerm executable {} no longer exists; restart the server from its installed location",
path.display()
)
}
fn uid() -> u32 {
// SAFETY: geteuid has no arguments or side effects.
unsafe { libc::geteuid() }
}
fn suffixed(path: &Path, suffix: &str) -> PathBuf {
let mut name = path.as_os_str().to_owned();
name.push(suffix);
PathBuf::from(name)
}
fn ensure_socket_parent(socket: &Path) -> Result<()> {
let parent = socket
.parent()
.filter(|parent| !parent.as_os_str().is_empty())
.context("socket path must include a private parent directory")?;
ensure_private_directory(parent)
}
fn ensure_private_directory(path: &Path) -> Result<()> {
match DirBuilder::new().mode(0o700).create(path) {
Ok(()) => {}
Err(error) if error.kind() == io::ErrorKind::AlreadyExists => {}
Err(error) => return Err(error).with_context(|| format!("create {}", path.display())),
}
verify_private_directory(path)
}
fn verify_private_directory(path: &Path) -> Result<()> {
let metadata =
fs::symlink_metadata(path).with_context(|| format!("inspect {}", path.display()))?;
if !metadata.is_dir() || metadata.uid() != uid() || metadata.mode() & 0o077 != 0 {
bail!(
"{} must be a real directory owned by your UID with mode 0700",
path.display()
);
}
Ok(())
}
fn private_file(path: &Path) -> Result<File> {
let file = OpenOptions::new()
.read(true)
.append(true)
.create(true)
.mode(0o600)
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
.open(path)
.with_context(|| format!("open {}", path.display()))?;
let metadata = file.metadata()?;
if !metadata.is_file()
|| metadata.uid() != uid()
|| metadata.mode() & 0o077 != 0
|| metadata.nlink() != 1
{
bail!(
"{} must be a private regular file owned by your UID",
path.display()
);
}
Ok(file)
}
fn remove_stale_socket(path: &Path) -> Result<()> {
match UnixStream::connect(path) {
Ok(_) => bail!("GUI zygote is already listening at {}", path.display()),
Err(error)
if matches!(
error.kind(),
io::ErrorKind::NotFound | io::ErrorKind::ConnectionRefused
) => {}
Err(error) => return Err(error).context("inspect previous zygote listener"),
}
match fs::symlink_metadata(path) {
Ok(metadata) => {
if !metadata.file_type().is_socket() || metadata.uid() != uid() {
bail!(
"refusing to remove non-owned/non-socket path {}",
path.display()
);
}
fs::remove_file(path).context("remove stale zygote socket")?;
}
Err(error) if error.kind() == io::ErrorKind::NotFound => {}
Err(error) => return Err(error).context("inspect stale zygote socket"),
}
Ok(())
}
pub(crate) fn verify_peer(stream: &UnixStream) -> Result<()> {
let mut credentials: libc::ucred = unsafe { std::mem::zeroed() };
let mut size = std::mem::size_of::<libc::ucred>() as libc::socklen_t;
// SAFETY: credentials and size are valid initialized buffers of the stated
// lengths; getsockopt writes only the SO_PEERCRED structure.
let result = unsafe {
libc::getsockopt(
stream.as_raw_fd(),
libc::SOL_SOCKET,
libc::SO_PEERCRED,
(&mut credentials as *mut libc::ucred).cast(),
&mut size,
)
};
if result == -1 {
return Err(io::Error::last_os_error()).context("read socket peer credentials");
}
if credentials.uid != uid() {
bail!("socket peer belongs to another UID");
}
Ok(())
}
struct SocketGuard {
path: PathBuf,
device: u64,
inode: u64,
}
impl SocketGuard {
fn new(path: &Path) -> Result<Self> {
let metadata = fs::symlink_metadata(path)?;
Ok(Self {
path: path.to_owned(),
device: metadata.dev(),
inode: metadata.ino(),
})
}
}
impl Drop for SocketGuard {
fn drop(&mut self) {
if let Ok(metadata) = fs::symlink_metadata(&self.path)
&& metadata.dev() == self.device
&& metadata.ino() == self.inode
{
let _ = fs::remove_file(&self.path);
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn test_dir() -> PathBuf {
let path = std::env::temp_dir().join(format!(
"psyterm-launcher-test-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
ensure_private_directory(&path).unwrap();
path
}
#[test]
fn private_paths_reject_symlinks_and_shared_directories() {
let root = test_dir();
let private = root.join("private");
ensure_private_directory(&private).unwrap();
let alias = root.join("alias");
std::os::unix::fs::symlink(&private, &alias).unwrap();
assert!(ensure_private_directory(&alias).is_err());
fs::set_permissions(&private, fs::Permissions::from_mode(0o755)).unwrap();
assert!(verify_private_directory(&private).is_err());
let file = root.join("log");
private_file(&file).unwrap();
let alias_file = root.join("alias-file");
std::os::unix::fs::symlink(&file, &alias_file).unwrap();
assert!(private_file(&alias_file).is_err());
fs::remove_dir_all(root).unwrap();
}
#[test]
fn stale_socket_cleanup_never_removes_regular_files() {
let root = test_dir();
let path = root.join("zygote.sock");
fs::write(&path, b"keep me").unwrap();
assert!(remove_stale_socket(&path).is_err());
assert_eq!(fs::read(&path).unwrap(), b"keep me");
fs::remove_file(&path).unwrap();
let listener = UnixListener::bind(&path).unwrap();
assert!(remove_stale_socket(&path).is_err());
drop(listener);
remove_stale_socket(&path).unwrap();
assert!(!path.exists());
fs::remove_dir_all(root).unwrap();
}
#[test]
fn launch_request_round_trip_preserves_remote_without_shell_parsing() {
let request = LaunchRequest::Launch {
server_socket: PathBuf::from("/private/psyterm.sock"),
remote: Some("work-host".into()),
};
let mut bytes = Vec::new();
protocol::write_message(&mut bytes, &request).unwrap();
let decoded: LaunchRequest = protocol::read_message(&mut bytes.as_slice()).unwrap();
assert!(
matches!(decoded, LaunchRequest::Launch { remote: Some(host), .. } if host == "work-host")
);
}
#[test]
fn unix_peer_credentials_match_current_user() {
let (left, _right) = UnixStream::pair().unwrap();
verify_peer(&left).unwrap();
}
#[test]
fn deleted_executable_suffix_resolves_only_when_original_name_is_absent() {
let root = test_dir();
let original = root.join("psyterm");
let deleted = root.join("psyterm (deleted)");
fs::write(&original, b"new executable").unwrap();
assert_eq!(resolve_executable_path(deleted.clone()).unwrap(), original);
fs::write(&deleted, b"real literal filename").unwrap();
assert_eq!(resolve_executable_path(deleted.clone()).unwrap(), deleted);
assert!(resolve_executable_path(root.join("missing")).is_err());
fs::remove_dir_all(root).unwrap();
}
#[test]
fn replacement_executable_changes_identity_even_with_same_contents() {
let root = test_dir();
let original = root.join("psyterm");
fs::write(&original, b"binary").unwrap();
let before = ExecutableIdentity::read(&original).unwrap();
let replacement = root.join("psyterm-new");
fs::write(&replacement, b"binary").unwrap();
fs::rename(replacement, &original).unwrap();
assert_ne!(ExecutableIdentity::read(&original).unwrap(), before);
fs::remove_dir_all(root).unwrap();
}
}
+121 -7
View File
@@ -1,15 +1,126 @@
mod chrome;
mod client;
mod colors;
mod cursor;
mod fonts;
mod input;
mod label;
mod launcher;
mod pane_name;
mod protocol;
mod render;
mod server;
mod session;
mod terminal;
use anyhow::{Result, bail};
use gpui::{prelude::*, *};
use std::path::PathBuf;
fn main() -> anyhow::Result<()> {
fn main() -> Result<()> {
env_logger::init();
let (session, events) = session::Session::new()?;
let mut role = "launch";
let mut socket = None;
let mut remote = None;
let mut args = std::env::args().skip(1);
while let Some(arg) = args.next() {
match arg.as_str() {
"--server" => role = "server",
"--zygote" => role = "zygote",
"--gui" => role = "gui",
"--bridge" => role = "bridge",
"--shutdown" => role = "shutdown",
"--list" => role = "list",
"--socket" => {
socket = Some(PathBuf::from(
args.next()
.ok_or_else(|| anyhow::anyhow!("--socket needs a path"))?,
))
}
"--remote" => {
remote = Some(
args.next()
.ok_or_else(|| anyhow::anyhow!("--remote needs an SSH destination"))?,
)
}
"--help" | "-h" => {
println!(
"psyTerm — server-owned terminals with a GPUI front end\n\n psyterm Open a window via the local server's zygote\n psyterm --remote user@host Connect a local GUI to a server over SSH\n psyterm --list List server-owned tabs and panes\n psyterm --shutdown Stop the local server and its shell sessions\n psyterm --socket PATH Use a separate local server\n psyterm --gui Direct GUI launch (diagnostics; bypass zygote)\n psyterm --server Run the server in the foreground\n psyterm --bridge Binary stdin/stdout transport used by SSH\n\nClosing a window detaches; tabs and shells keep running.\nSSH requires key/agent authentication and psyterm in the remote PATH.\nPSYTERM_REMOTE_BIN overrides the remote executable path.\n"
);
return Ok(());
}
_ => bail!("unknown argument: {arg}; see --help"),
}
}
let socket = socket.map(Ok).unwrap_or_else(launcher::default_socket)?;
match role {
"server" => {
let zygote_socket = socket.clone();
let mut zygote: Option<launcher::Zygote> = None;
server::run(&socket, move |remote| {
if zygote.is_none() {
zygote = Some(launcher::Zygote::start(&zygote_socket)?);
}
zygote.as_mut().unwrap().open_window(remote)
})
}
"zygote" => launcher::run_zygote(&socket),
"gui" => {
launcher::ensure_server(&socket)?;
run_gui(socket, remote)
}
"bridge" => client::bridge(&socket),
"shutdown" => {
launcher::control(&socket, protocol::ClientMessage::Shutdown)?;
Ok(())
}
"list" => list_sessions(&socket),
_ => {
launcher::ensure_server(&socket)?;
launcher::control(
&socket,
protocol::ClientMessage::OpenWindow { target: remote },
)?;
Ok(())
}
}
}
fn list_sessions(socket: &std::path::Path) -> Result<()> {
let mut stream = std::os::unix::net::UnixStream::connect(socket)?;
stream.set_read_timeout(Some(std::time::Duration::from_secs(5)))?;
protocol::write_message(
&mut stream,
&protocol::ClientMessage::Hello {
version: protocol::VERSION,
},
)?;
let hello: protocol::ServerMessage = protocol::read_message(&mut stream)?;
println!("{hello:?}");
protocol::write_message(&mut stream, &protocol::ClientMessage::List)?;
loop {
match protocol::read_message(&mut stream)? {
protocol::ServerMessage::Snapshot(snapshot) => {
for tab in snapshot.tabs {
println!("tab {} {} panes {:?}", tab.id, tab.title, tab.panes);
}
break;
}
protocol::ServerMessage::Error(error) => bail!("{error}"),
_ => {}
}
}
Ok(())
}
/// Called directly in a fresh fork of the single-threaded zygote. All GPUI,
/// graphics, font discovery and client I/O initialization happens after fork.
pub(crate) fn run_gui(socket: PathBuf, remote: Option<String>) -> Result<()> {
let (client, updates) = client::Client::connect(&socket, remote.as_deref())?;
let connection: SharedString = remote
.map(|host| format!("SSH · {host}"))
.unwrap_or_else(|| "Local".into())
.into();
Application::new().run(move |cx: &mut App| {
cx.on_window_closed(|cx| {
if cx.windows().is_empty() {
@@ -17,20 +128,23 @@ fn main() -> anyhow::Result<()> {
}
})
.detach();
let bounds = Bounds::centered(None, size(px(960.), px(640.)), cx);
let bounds = Bounds::centered(None, size(px(1000.), px(680.)), cx);
cx.open_window(
WindowOptions {
window_bounds: Some(WindowBounds::Windowed(bounds)),
titlebar: Some(TitlebarOptions {
title: Some("Terminal".into()),
title: Some("psyTerm".into()),
..Default::default()
}),
app_id: Some("dev.buzzert.terminal".into()),
window_decorations: Some(WindowDecorations::Client),
app_id: Some("dev.buzzert.psyterm".into()),
..Default::default()
},
move |window, cx| cx.new(|cx| terminal::TerminalView::new(session, events, window, cx)),
move |window, cx| {
cx.new(|cx| terminal::Workspace::new(client, updates, connection, window, cx))
},
)
.expect("could not open terminal window");
.expect("could not open psyTerm window");
cx.activate(true);
});
Ok(())
+656
View File
@@ -0,0 +1,656 @@
//! Single-line pane-name editing. UTF-8 offsets stay internal; platform input
//! methods use UTF-16 ranges. Editing never sends bytes to the terminal process.
use std::ops::Range;
const MAX_CHARACTERS: usize = 512;
#[derive(Debug, Clone)]
pub struct NameEditor {
pub text: String,
anchor: usize,
cursor: usize,
marked: Option<Range<usize>>,
}
impl NameEditor {
/// Starting with the entire current name selected makes typing replace it.
pub fn new(text: &str) -> Self {
let text = clean_text(text)
.chars()
.take(MAX_CHARACTERS)
.collect::<String>();
let cursor = text.len();
Self {
text,
anchor: 0,
cursor,
marked: None,
}
}
/// Selection and cursor offsets used by GPUI's shaped line are UTF-8 bytes.
pub fn selection(&self) -> Range<usize> {
self.anchor.min(self.cursor)..self.anchor.max(self.cursor)
}
pub fn cursor(&self) -> usize {
self.cursor
}
pub fn reversed(&self) -> bool {
self.cursor < self.anchor
}
pub fn selection_utf16(&self) -> Range<usize> {
self.to_utf16(self.selection())
}
pub fn marked_utf16(&self) -> Option<Range<usize>> {
self.marked.clone().map(|range| self.to_utf16(range))
}
pub fn text_for_range(&self, range: Range<usize>) -> (String, Range<usize>) {
let bytes = self.range_from_utf16(range);
(self.text[bytes.clone()].to_owned(), self.to_utf16(bytes))
}
pub fn byte_offset_for_utf16(&self, offset: usize) -> usize {
utf16_to_byte(&self.text, offset, false)
}
pub fn utf16_offset_for_byte(&self, offset: usize) -> usize {
self.text[..floor_boundary(&self.text, offset)]
.encode_utf16()
.count()
}
pub fn select_all(&mut self) {
self.anchor = 0;
self.cursor = self.text.len();
self.marked = None;
}
pub fn set_cursor(&mut self, byte: usize, extend: bool) {
self.cursor = floor_boundary(&self.text, byte);
if !extend {
self.anchor = self.cursor;
}
self.marked = None;
}
pub fn left(&mut self, extend: bool) {
let position = if !extend && self.anchor != self.cursor {
self.selection().start
} else {
self.text[..self.cursor]
.char_indices()
.next_back()
.map_or(0, |(i, _)| i)
};
self.set_cursor(position, extend);
}
pub fn right(&mut self, extend: bool) {
let position = if !extend && self.anchor != self.cursor {
self.selection().end
} else {
self.text[self.cursor..]
.chars()
.next()
.map_or(self.text.len(), |c| self.cursor + c.len_utf8())
};
self.set_cursor(position, extend);
}
pub fn home(&mut self, extend: bool) {
self.set_cursor(0, extend);
}
pub fn end(&mut self, extend: bool) {
self.set_cursor(self.text.len(), extend);
}
pub fn backspace(&mut self) {
if self.anchor == self.cursor {
self.left(true);
}
self.replace(None, "");
}
pub fn delete(&mut self) {
if self.anchor == self.cursor {
self.right(true);
}
self.replace(None, "");
}
pub fn unmark(&mut self) {
self.marked = None;
}
pub fn replace(&mut self, range_utf16: Option<Range<usize>>, text: &str) {
self.replace_inner(range_utf16, text);
self.marked = None;
}
pub fn replace_and_mark(
&mut self,
range_utf16: Option<Range<usize>>,
text: &str,
selected_utf16: Option<Range<usize>>,
) {
let inserted = self.replace_inner(range_utf16, text);
if inserted.is_empty() {
self.marked = None;
} else {
self.marked = Some(inserted.clone());
}
if let Some(selected) = selected_utf16 {
let text = &self.text[inserted.clone()];
let start = utf16_to_byte(text, selected.start, false);
let end = utf16_to_byte(text, selected.end, true);
self.anchor = inserted.start + start;
self.cursor = inserted.start + end;
}
}
fn replace_inner(&mut self, range_utf16: Option<Range<usize>>, text: &str) -> Range<usize> {
let range = range_utf16
.map(|range| self.range_from_utf16(range))
.or_else(|| self.marked.clone())
.unwrap_or_else(|| self.selection());
let kept =
self.text[..range.start].chars().count() + self.text[range.end..].chars().count();
let replacement: String = clean_text(text)
.chars()
.take(MAX_CHARACTERS.saturating_sub(kept))
.collect();
let inserted = range.start..range.start + replacement.len();
self.text.replace_range(range, &replacement);
self.anchor = inserted.end;
self.cursor = inserted.end;
inserted
}
fn to_utf16(&self, range: Range<usize>) -> Range<usize> {
self.utf16_offset_for_byte(range.start)..self.utf16_offset_for_byte(range.end)
}
fn range_from_utf16(&self, range: Range<usize>) -> Range<usize> {
let start = range.start.min(range.end);
let end = range.start.max(range.end);
if start == end {
let at = utf16_to_byte(&self.text, start, false);
at..at
} else {
utf16_to_byte(&self.text, start, false)..utf16_to_byte(&self.text, end, true)
}
}
}
fn clean_text(text: &str) -> String {
text.chars()
.filter_map(|c| match c {
'\r' | '\n' | '\t' => Some(' '),
c if c.is_control() => None,
c => Some(c),
})
.collect()
}
fn floor_boundary(text: &str, index: usize) -> usize {
let mut index = index.min(text.len());
while !text.is_char_boundary(index) {
index -= 1;
}
index
}
fn utf16_to_byte(text: &str, requested: usize, ceil: bool) -> usize {
let mut offset = 0;
for (index, character) in text.char_indices() {
if requested == offset {
return index;
}
let next = offset + character.len_utf16();
if requested < next {
return if ceil {
index + character.len_utf8()
} else {
index
};
}
offset = next;
}
text.len()
}
use crate::chrome;
use gpui::{
App, Bounds, Context, CursorStyle, ElementInputHandler, EntityInputHandler, FocusHandle,
Focusable, KeyDownEvent, MouseButton, MouseDownEvent, MouseMoveEvent, Pixels, Point, Render,
ShapedLine, TextRun, UTF16Selection, UnderlineStyle, Window, canvas, div, fill, font, point,
prelude::*, px, rgb, size,
};
const FIELD_HEIGHT: f32 = 24.;
const TEXT_SIZE: f32 = 12.;
const FIELD_PADDING: f32 = 6.;
type Finish = Box<dyn Fn(Option<String>, &mut Window, &mut App)>;
/// A focused inline editor that keeps all name editing separate from PTY input.
pub struct RenameField {
editor: NameEditor,
focus_handle: FocusHandle,
on_finish: Finish,
last_bounds: Bounds<Pixels>,
last_layout: Option<ShapedLine>,
scroll: Pixels,
selecting: bool,
}
impl RenameField {
pub fn new(
initial: String,
on_finish: impl Fn(Option<String>, &mut Window, &mut App) + 'static,
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
let focus_handle = cx.focus_handle();
window.focus(&focus_handle);
Self {
editor: NameEditor::new(&initial),
focus_handle,
on_finish: Box::new(on_finish),
last_bounds: Bounds::default(),
last_layout: None,
scroll: px(0.),
selecting: false,
}
}
pub fn focus(&self, window: &mut Window) {
window.focus(&self.focus_handle);
}
fn key_down(&mut self, event: &KeyDownEvent, window: &mut Window, cx: &mut Context<Self>) {
// Parent terminal key handlers must never see keys typed into this field.
cx.stop_propagation();
let key = &event.keystroke;
let command = key.modifiers.control || key.modifiers.platform;
match key.key.as_str() {
"enter" => {
// Enter first accepts active IME composition; a subsequent Enter saves.
if self.editor.marked_utf16().is_some() {
self.editor.unmark();
} else {
(self.on_finish)(Some(self.editor.text.clone()), window, cx);
return;
}
}
"escape" => {
(self.on_finish)(None, window, cx);
return;
}
"left" => self.editor.left(key.modifiers.shift),
"right" => self.editor.right(key.modifiers.shift),
"home" => self.editor.home(key.modifiers.shift),
"end" => self.editor.end(key.modifiers.shift),
"backspace" => self.editor.backspace(),
"delete" => self.editor.delete(),
_ if command && !key.modifiers.alt => match key.key.to_ascii_lowercase().as_str() {
"a" => self.editor.select_all(),
"c" | "x" => {
let selected = self.editor.selection();
if !selected.is_empty() {
cx.write_to_clipboard(gpui::ClipboardItem::new_string(
self.editor.text[selected].to_owned(),
));
if key.key.eq_ignore_ascii_case("x") {
self.editor.replace(None, "");
}
}
}
"v" => {
if let Some(text) = cx.read_from_clipboard().and_then(|item| item.text()) {
self.editor.replace(None, &text);
}
}
_ => {}
},
_ if !command && !key.modifiers.alt => {
if let Some(text) = &key.key_char {
self.editor.replace(None, text);
}
}
_ => {}
}
cx.notify();
}
fn index_for_point(&self, position: Point<Pixels>) -> usize {
if self.editor.text.is_empty() {
return 0;
}
self.last_layout.as_ref().map_or(0, |line| {
line.closest_index_for_x(
position.x - self.last_bounds.left() - px(FIELD_PADDING) + self.scroll,
)
})
}
fn mouse_down(&mut self, event: &MouseDownEvent, window: &mut Window, cx: &mut Context<Self>) {
cx.stop_propagation();
self.focus(window);
if event.click_count > 1 {
self.editor.select_all();
} else {
self.editor
.set_cursor(self.index_for_point(event.position), event.modifiers.shift);
}
self.selecting = true;
cx.notify();
}
fn mouse_move(&mut self, event: &MouseMoveEvent, _: &mut Window, cx: &mut Context<Self>) {
if self.selecting && event.dragging() {
cx.stop_propagation();
self.editor
.set_cursor(self.index_for_point(event.position), true);
cx.notify();
}
}
fn prepare(&mut self, bounds: Bounds<Pixels>, window: &mut Window) {
self.last_bounds = bounds;
let placeholder = self.editor.text.is_empty();
let text = if placeholder {
"Automatic name".to_owned()
} else {
self.editor.text.clone()
};
let mut runs = Vec::new();
let default = TextRun {
len: text.len(),
font: font(".SystemUIFont"),
color: rgb(if placeholder {
chrome::MUTED
} else {
chrome::TEXT
})
.into(),
background_color: None,
underline: None,
strikethrough: None,
};
if let Some(marked) = &self.editor.marked {
for (range, underline) in [
(0..marked.start, false),
(marked.clone(), true),
(marked.end..text.len(), false),
] {
if range.is_empty() {
continue;
}
runs.push(TextRun {
len: range.len(),
underline: underline.then_some(UnderlineStyle {
thickness: px(1.),
color: None,
wavy: false,
}),
..default.clone()
});
}
} else {
runs.push(default);
}
let line = window
.text_system()
.shape_line(text.into(), px(TEXT_SIZE), &runs, None);
let caret = if placeholder {
px(0.)
} else {
line.x_for_index(self.editor.cursor())
};
let width = (bounds.size.width - px(FIELD_PADDING * 2. + 1.)).max(px(1.));
if caret - self.scroll > width {
self.scroll = caret - width;
} else if caret < self.scroll {
self.scroll = caret;
}
if placeholder {
self.scroll = px(0.);
}
self.last_layout = Some(line);
}
}
impl Focusable for RenameField {
fn focus_handle(&self, _: &App) -> FocusHandle {
self.focus_handle.clone()
}
}
impl Render for RenameField {
fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
let prepare = cx.entity();
let paint = cx.entity();
div()
.w_full()
.min_w_0()
.h(px(FIELD_HEIGHT))
.bg(rgb(chrome::CONTROL_BACKGROUND))
.border_1()
.border_color(rgb(chrome::ACCENT))
.overflow_hidden()
.cursor(CursorStyle::IBeam)
.track_focus(&self.focus_handle)
.on_key_down(cx.listener(Self::key_down))
.on_mouse_down(MouseButton::Left, cx.listener(Self::mouse_down))
.on_mouse_move(cx.listener(Self::mouse_move))
.on_mouse_up(
MouseButton::Left,
cx.listener(|field, _, _, cx| {
field.selecting = false;
cx.stop_propagation();
}),
)
.on_mouse_up_out(
MouseButton::Left,
cx.listener(|field, _, _, _| field.selecting = false),
)
.on_scroll_wheel(|_, _, cx| cx.stop_propagation())
.child(
canvas(
move |bounds, window, cx| {
prepare.update(cx, |field, _| field.prepare(bounds, window))
},
move |bounds, (), window, cx| {
let field = paint.read(cx);
let focus = field.focus_handle.clone();
let line = field.last_layout.clone();
let selected = field.editor.selection();
let caret = field.editor.cursor();
let origin =
bounds.origin + point(px(FIELD_PADDING) - field.scroll, px(0.));
let empty = field.editor.text.is_empty();
window.handle_input(
&focus,
ElementInputHandler::new(bounds, paint.clone()),
cx,
);
if let Some(line) = line {
window.with_content_mask(
Some(gpui::ContentMask { bounds }),
|window| {
if !selected.is_empty() {
let start = line.x_for_index(selected.start);
let end = line.x_for_index(selected.end);
window.paint_quad(fill(
Bounds::new(
origin + point(start, px(2.)),
size(end - start, bounds.size.height - px(4.)),
),
rgb(chrome::BORDER),
));
}
let _ = line.paint(origin, bounds.size.height, window, cx);
if focus.is_focused(window) {
let x = if empty {
px(0.)
} else {
line.x_for_index(caret)
};
window.paint_quad(fill(
Bounds::new(
origin + point(x, px(4.)),
size(px(1.), bounds.size.height - px(8.)),
),
rgb(chrome::TEXT),
));
}
},
);
}
},
)
.size_full(),
)
}
}
impl EntityInputHandler for RenameField {
fn text_for_range(
&mut self,
range: Range<usize>,
actual: &mut Option<Range<usize>>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<String> {
let (text, range) = self.editor.text_for_range(range);
*actual = Some(range);
Some(text)
}
fn selected_text_range(
&mut self,
_: bool,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<UTF16Selection> {
Some(UTF16Selection {
range: self.editor.selection_utf16(),
reversed: self.editor.reversed(),
})
}
fn marked_text_range(&self, _: &mut Window, _: &mut Context<Self>) -> Option<Range<usize>> {
self.editor.marked_utf16()
}
fn unmark_text(&mut self, _: &mut Window, cx: &mut Context<Self>) {
self.editor.unmark();
cx.notify();
}
fn replace_text_in_range(
&mut self,
range: Option<Range<usize>>,
text: &str,
_: &mut Window,
cx: &mut Context<Self>,
) {
self.editor.replace(range, text);
cx.notify();
}
fn replace_and_mark_text_in_range(
&mut self,
range: Option<Range<usize>>,
text: &str,
selected: Option<Range<usize>>,
_: &mut Window,
cx: &mut Context<Self>,
) {
self.editor.replace_and_mark(range, text, selected);
cx.notify();
}
fn bounds_for_range(
&mut self,
range: Range<usize>,
_: Bounds<Pixels>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<Bounds<Pixels>> {
let line = self.last_layout.as_ref()?;
let start = line.x_for_index(self.editor.byte_offset_for_utf16(range.start));
let end = line.x_for_index(self.editor.byte_offset_for_utf16(range.end));
Some(Bounds::new(
self.last_bounds.origin + point(px(FIELD_PADDING) - self.scroll + start, px(0.)),
size((end - start).max(px(1.)), self.last_bounds.size.height),
))
}
fn character_index_for_point(
&mut self,
position: Point<Pixels>,
_: &mut Window,
_: &mut Context<Self>,
) -> Option<usize> {
Some(
self.editor
.utf16_offset_for_byte(self.index_for_point(position)),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn editing_replaces_selection_and_moves_by_unicode_scalars() {
let mut editor = NameEditor::new("old name");
editor.replace(None, "A🦀界");
editor.left(false);
editor.backspace();
assert_eq!(editor.text, "A界");
assert_eq!(editor.cursor(), 1);
editor.delete();
assert_eq!(editor.text, "A");
editor.home(false);
editor.backspace();
assert_eq!(editor.text, "A");
editor.right(true);
assert_eq!(editor.selection(), 0..1);
editor.replace(None, "work");
assert_eq!(editor.text, "work");
}
#[test]
fn platform_utf16_ranges_do_not_split_surrogate_pairs_or_utf8() {
let mut editor = NameEditor::new("A🦀界Z");
assert_eq!(editor.selection_utf16(), 0..5);
assert_eq!(editor.text_for_range(2..3), ("🦀".into(), 1..3));
editor.replace(Some(1..3), "λ");
assert_eq!(editor.text, "Aλ界Z");
assert_eq!(editor.selection_utf16(), 2..2);
editor.set_cursor(2, false); // inside the two-byte lambda
assert_eq!(editor.cursor(), 1);
}
#[test]
fn composition_replaces_previous_marked_text_and_commits_once() {
let mut editor = NameEditor::new("old");
editor.replace_and_mark(None, "に", Some(1..1));
assert_eq!(editor.marked_utf16(), Some(0..1));
editor.replace_and_mark(None, "日本", Some(2..2));
assert_eq!(editor.text, "日本");
assert_eq!(editor.marked_utf16(), Some(0..2));
editor.replace(None, "日本語");
assert_eq!(editor.text, "日本語");
assert_eq!(editor.marked_utf16(), None);
}
#[test]
fn clearing_restores_empty_name_and_single_line_paste_is_bounded() {
let mut editor = NameEditor::new("old");
editor.replace(None, "a\nb\t\x1bc");
assert_eq!(editor.text, "a b c");
editor.select_all();
editor.replace(None, &"界".repeat(800));
assert_eq!(editor.text.chars().count(), MAX_CHARACTERS);
editor.select_all();
editor.backspace();
assert_eq!(editor.text, "");
}
#[test]
fn reversed_selection_collapses_to_expected_edge() {
let mut editor = NameEditor::new("hello");
editor.end(false);
editor.left(true);
editor.left(true);
assert!(editor.reversed());
assert_eq!(editor.selection(), 3..5);
editor.left(false);
assert_eq!(editor.cursor(), 3);
editor.home(false);
editor.right(true);
editor.right(false);
assert_eq!(editor.cursor(), 1);
}
}
+319
View File
@@ -0,0 +1,319 @@
//! Versioned terminal-server protocol, shared by local and SSH transports.
//! The GUI receives rendered grid state; only the server owns a VTE parser.
use std::io::{Read, Write};
use alacritty_terminal::{
term::cell::Cell,
vte::ansi::{CursorShape, Rgb},
};
use anyhow::{Context, Result, bail};
use bincode::Options;
use serde::{Deserialize, Serialize, de::DeserializeOwned};
pub const VERSION: u32 = 2;
pub const MAX_MESSAGE_BYTES: usize = 16 * 1024 * 1024;
pub type PaneId = u64;
pub type TabId = u64;
#[derive(Debug, Clone, Serialize, Deserialize)]
// Keep variants append-only: the shutdown command can retire an older server.
pub enum ClientMessage {
Hello {
version: u32,
},
Attach,
Input {
pane: PaneId,
bytes: Vec<u8>,
},
Resize {
pane: PaneId,
columns: u16,
lines: u16,
cell_width: u16,
cell_height: u16,
},
Scroll {
pane: PaneId,
kind: ScrollKind,
},
Selection {
pane: PaneId,
selection: SelectionCommand,
},
Copy {
pane: PaneId,
},
NewTab {
cwd: Option<String>,
},
Split {
pane: PaneId,
cwd: Option<String>,
},
FocusTab {
tab: TabId,
},
FocusPane {
pane: PaneId,
},
ClosePane {
pane: PaneId,
},
OpenWindow {
target: Option<String>,
},
Detach,
Shutdown,
Ping,
/// Read current layout without attaching or creating a shell.
List,
/// A blank/absent name returns to program-title/CWD naming.
RenamePane {
pane: PaneId,
name: Option<String>,
},
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum ScrollKind {
Delta(i32),
PageUp,
PageDown,
Top,
Bottom,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum SelectionKind {
Simple,
Word,
Line,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum SelectionSide {
Left,
Right,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum SelectionCommand {
Start {
column: u16,
row: u16,
side: SelectionSide,
kind: SelectionKind,
},
Update {
column: u16,
row: u16,
side: SelectionSide,
},
Clear,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
// Hello and Closing also retain their v1 wire representation during upgrades.
pub enum ServerMessage {
Hello { version: u32, server_pid: u32 },
Snapshot(Snapshot),
Clipboard(String),
Error(String),
Pong,
Closing,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Snapshot {
pub revision: u64,
pub tabs: Vec<TabInfo>,
pub active_tab: TabId,
/// Only panes in the active tab are transferred. Every pane remains live on the server.
pub panes: Vec<PaneSnapshot>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TabInfo {
pub id: TabId,
pub title: String,
pub panes: Vec<PaneId>,
pub active_pane: PaneId,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PaneSnapshot {
pub id: PaneId,
/// Effective display name: manual override, program title, then CWD.
pub title: String,
pub manual_title: Option<String>,
pub cwd: String,
pub columns: u16,
pub lines: u16,
pub cell_width: u16,
pub cell_height: u16,
pub cells: Vec<Cell>,
pub selected: Vec<bool>,
pub colors: Vec<Option<Rgb>>,
pub cursor: Cursor,
pub display_offset: u32,
pub mode: u32,
pub exited: bool,
}
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub struct Cursor {
pub column: u16,
/// Viewport-relative row; negative or past the viewport when scrolled away.
pub row: i32,
pub shape: CursorKind,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CursorKind {
Block,
Underline,
Beam,
HollowBlock,
Hidden,
}
impl From<CursorShape> for CursorKind {
fn from(shape: CursorShape) -> Self {
match shape {
CursorShape::Block => Self::Block,
CursorShape::Underline => Self::Underline,
CursorShape::Beam => Self::Beam,
CursorShape::HollowBlock => Self::HollowBlock,
CursorShape::Hidden => Self::Hidden,
}
}
}
impl From<CursorKind> for CursorShape {
fn from(shape: CursorKind) -> Self {
match shape {
CursorKind::Block => Self::Block,
CursorKind::Underline => Self::Underline,
CursorKind::Beam => Self::Beam,
CursorKind::HollowBlock => Self::HollowBlock,
CursorKind::Hidden => Self::Hidden,
}
}
}
/// Little-endian u32 byte length followed by bounded bincode 1.3 payload.
pub fn write_message(writer: &mut impl Write, message: &impl Serialize) -> Result<()> {
let bytes = bincode::DefaultOptions::new()
.with_fixint_encoding()
.with_limit(MAX_MESSAGE_BYTES as u64)
.serialize(message)
.context("encode protocol message")?;
if bytes.len() > MAX_MESSAGE_BYTES {
bail!("protocol message is too large");
}
writer.write_all(&(bytes.len() as u32).to_le_bytes())?;
writer.write_all(&bytes)?;
writer.flush()?;
Ok(())
}
pub fn read_message<T: DeserializeOwned>(reader: &mut impl Read) -> Result<T> {
let mut length = [0; 4];
reader
.read_exact(&mut length)
.context("read protocol frame length")?;
let length = u32::from_le_bytes(length) as usize;
if length == 0 || length > MAX_MESSAGE_BYTES {
bail!("invalid protocol frame length: {length}");
}
let mut bytes = vec![0; length];
reader
.read_exact(&mut bytes)
.context("read protocol frame")?;
bincode::DefaultOptions::new()
.with_fixint_encoding()
.with_limit(MAX_MESSAGE_BYTES as u64)
.reject_trailing_bytes()
.deserialize(&bytes)
.context("decode protocol message")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn legacy_shutdown_handshake_retains_its_wire_representation() {
fn frame(message: &impl Serialize) -> Vec<u8> {
let mut bytes = Vec::new();
write_message(&mut bytes, message).unwrap();
bytes
}
// These literal frames are from protocol v1. The upgrade path only
// exchanges Hello, Shutdown and Closing, never versioned snapshots.
let client_hello = [8, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0];
let shutdown = [4, 0, 0, 0, 14, 0, 0, 0];
let server_hello = [12, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0x78, 0x56, 0x34, 0x12];
let closing = [4, 0, 0, 0, 5, 0, 0, 0];
assert_eq!(frame(&ClientMessage::Hello { version: 1 }), client_hello);
assert_eq!(frame(&ClientMessage::Shutdown), shutdown);
assert_eq!(
frame(&ServerMessage::Hello {
version: 1,
server_pid: 0x1234_5678,
}),
server_hello
);
assert_eq!(frame(&ServerMessage::Closing), closing);
assert!(matches!(
read_message::<ClientMessage>(&mut client_hello.as_slice()).unwrap(),
ClientMessage::Hello { version: 1 }
));
assert!(matches!(
read_message::<ClientMessage>(&mut shutdown.as_slice()).unwrap(),
ClientMessage::Shutdown
));
assert!(matches!(
read_message::<ServerMessage>(&mut server_hello.as_slice()).unwrap(),
ServerMessage::Hello {
version: 1,
server_pid: 0x1234_5678,
}
));
assert!(matches!(
read_message::<ServerMessage>(&mut closing.as_slice()).unwrap(),
ServerMessage::Closing
));
}
#[test]
fn rejects_oversized_frames_before_allocating_payload() {
let mut input = ((MAX_MESSAGE_BYTES + 1) as u32)
.to_le_bytes()
.as_slice()
.to_vec();
assert!(read_message::<ClientMessage>(&mut input.as_slice()).is_err());
input = 0u32.to_le_bytes().to_vec();
assert!(read_message::<ClientMessage>(&mut input.as_slice()).is_err());
}
#[test]
fn frames_round_trip_and_reject_trailing_payload() {
let mut bytes = Vec::new();
write_message(
&mut bytes,
&ClientMessage::Input {
pane: 42,
bytes: b"hello".to_vec(),
},
)
.unwrap();
let result: ClientMessage = read_message(&mut bytes.as_slice()).unwrap();
assert!(matches!(result, ClientMessage::Input { pane: 42, bytes } if bytes == b"hello"));
let len = u32::from_le_bytes(bytes[..4].try_into().unwrap()) + 1;
bytes[..4].copy_from_slice(&len.to_le_bytes());
bytes.push(0);
assert!(read_message::<ClientMessage>(&mut bytes.as_slice()).is_err());
}
}
+8 -1
View File
@@ -157,7 +157,13 @@ impl Renderer {
}
/// `origin` is the top-left terminal cell, after the view's padding.
pub fn paint(&self, origin: Point<Pixels>, window: &mut Window, cx: &mut App) {
pub fn paint_with_cursor(
&self,
origin: Point<Pixels>,
window: &mut Window,
cx: &mut App,
before_text: impl FnOnce(&mut Window),
) {
let bounds = Bounds::new(
origin,
size(
@@ -190,6 +196,7 @@ impl Renderer {
}
}
});
before_text(window);
for (row_index, row) in self.rows.iter().enumerate() {
for text in &row.text {
if text.unicode_color.is_some() {
+1384
View File
File diff suppressed because it is too large Load Diff
+42 -3
View File
@@ -70,19 +70,32 @@ pub struct Session {
// A pidfd identifies this process even after its numerical PID is reused.
#[cfg(target_os = "linux")]
process: LinuxProcess,
// A pinned proc directory cannot silently resolve to a reused numerical PID.
#[cfg(target_os = "linux")]
proc_directory: Option<std::fs::File>,
worker: Option<JoinHandle<()>>,
}
impl Session {
pub fn new() -> Result<(Self, async_channel::Receiver<Event>)> {
pub fn in_directory(
directory: Option<std::path::PathBuf>,
) -> Result<(Self, async_channel::Receiver<Event>)> {
let program = std::env::var("SHELL")
.ok()
.filter(|shell| !shell.is_empty())
.unwrap_or_else(|| "/bin/sh".into());
Self::with_shell(Shell::new(program, Vec::new()))
Self::with_shell_and_directory(Shell::new(program, Vec::new()), directory)
}
#[cfg(test)]
fn with_shell(shell: Shell) -> Result<(Self, async_channel::Receiver<Event>)> {
Self::with_shell_and_directory(shell, None)
}
pub(crate) fn with_shell_and_directory(
shell: Shell,
working_directory: Option<std::path::PathBuf>,
) -> Result<(Self, async_channel::Receiver<Event>)> {
let size = WindowSize {
num_cols: 80,
num_lines: 24,
@@ -100,7 +113,7 @@ impl Session {
let options = Options {
shell: Some(shell),
// None preserves the directory from which the application launched.
working_directory: None,
working_directory,
drain_on_exit: true,
env: HashMap::from([
("TERM".into(), "xterm-256color".into()),
@@ -110,6 +123,15 @@ impl Session {
let pty = tty::new(&options, size, 0).context("Could not start the shell PTY")?;
#[cfg(target_os = "linux")]
let process = LinuxProcess::new(pty.child().id())?;
#[cfg(target_os = "linux")]
let proc_directory = {
use std::os::unix::fs::OpenOptionsExt;
std::fs::OpenOptions::new()
.read(true)
.custom_flags(libc::O_PATH | libc::O_DIRECTORY | libc::O_CLOEXEC)
.open(format!("/proc/{}", pty.child().id()))
.ok()
};
let event_loop = EventLoop::new(term.clone(), proxy.clone(), pty, true, false)
.context("Could not initialize PTY polling")?;
let sender = event_loop.channel();
@@ -135,6 +157,8 @@ impl Session {
size,
#[cfg(target_os = "linux")]
process,
#[cfg(target_os = "linux")]
proc_directory,
worker: Some(worker),
},
rx,
@@ -152,6 +176,21 @@ impl Session {
self.size
}
/// Read the shell's current directory on the server, including `cd` changes.
/// This does not depend on shell integration or a client's local filesystem.
pub fn working_directory(&self) -> Option<std::path::PathBuf> {
#[cfg(target_os = "linux")]
{
use std::os::fd::AsRawFd;
let directory = self.proc_directory.as_ref()?;
std::fs::read_link(format!("/proc/self/fd/{}/cwd", directory.as_raw_fd())).ok()
}
#[cfg(not(target_os = "linux"))]
{
None
}
}
/// Call when receiving `Event::Wakeup`, before reading the grid for a frame.
pub fn acknowledge_wakeup(&self) {
self.wakeup_pending.store(false, Ordering::Release);
+629 -294
View File
File diff suppressed because it is too large Load Diff