Create independent sessions and open SSH sessions in adjacent tabs
Start new windows with a fresh shell and add explicit session selection through --attach. Route in-pane SSH launches back to the originating session, preserving remote shells and tab order across local detach and reattach.
This commit is contained in:
@@ -4,7 +4,8 @@ A terminal and multiplexer for macOS and Linux (Wayland), built with [GPUI 0.2.2
|
|||||||
and [alacritty_terminal 0.26.0](https://docs.rs/alacritty_terminal/0.26.0/).
|
and [alacritty_terminal 0.26.0](https://docs.rs/alacritty_terminal/0.26.0/).
|
||||||
A separate server owns terminal emulation, shells, tabs, panes, and scrollback.
|
A separate server owns terminal emulation, shells, tabs, panes, and scrollback.
|
||||||
GUI processes display its snapshots and send input commands. Closing a window
|
GUI processes display its snapshots and send input commands. Closing a window
|
||||||
detaches it; the shells keep running for the next local or remote connection.
|
detaches it. Run `psyterm --attach` to return to the running shells, or
|
||||||
|
`psyterm` to start a fresh session.
|
||||||
|
|
||||||
## Build and run
|
## Build and run
|
||||||
|
|
||||||
@@ -35,8 +36,8 @@ open target/release/bundle/osx/psyTerm.app
|
|||||||
```
|
```
|
||||||
|
|
||||||
You can copy `psyTerm.app` to Applications. The bundle and CLI both open a GUI
|
You can copy `psyTerm.app` to Applications. The bundle and CLI both open a GUI
|
||||||
in the launching process and connect to the same local server. Use `open -n`
|
in the launching process. Press Cmd+N for another window with its own session,
|
||||||
with the app path for another window. The bundle's
|
or run `open -n` with the app path. The bundle's
|
||||||
`Contents/MacOS/psyterm` executable also accepts the CLI commands below.
|
`Contents/MacOS/psyterm` executable also accepts the CLI commands below.
|
||||||
|
|
||||||
### Linux
|
### Linux
|
||||||
@@ -76,12 +77,19 @@ cargo build --locked --release
|
|||||||
```
|
```
|
||||||
|
|
||||||
The default command starts or reuses a local server, asks its zygote to fork a
|
The default command starts or reuses a local server, asks its zygote to fork a
|
||||||
GUI, and returns. Running it again opens another view of the same workspace.
|
GUI, and returns. Each invocation starts an independent session unless you pass
|
||||||
|
`--attach`.
|
||||||
|
|
||||||
### Shells and sessions
|
### Shells and sessions
|
||||||
|
|
||||||
The first attachment to an empty server creates a shell in the server's startup
|
Each new session starts with one tab and one shell. Windows opened with the
|
||||||
directory. Shells inherit the server's environment and receive
|
New Window shortcut start a fresh session in the focused pane’s directory on
|
||||||
|
the same host. Closing a window leaves its session available for reattachment.
|
||||||
|
To choose a session, run `psyterm --list` and pass its ID to `psyterm --attach ID`. With no ID,
|
||||||
|
`--attach` prefers the most recently used detached session and otherwise
|
||||||
|
selects the most recently used attached session.
|
||||||
|
|
||||||
|
Shells inherit the server's environment and receive
|
||||||
`TERM=xterm-256color` and `COLORTERM=truecolor`. The server uses `$SHELL`
|
`TERM=xterm-256color` and `COLORTERM=truecolor`. The server uses `$SHELL`
|
||||||
when set. On macOS it starts a login shell and falls back to the shell in
|
when set. On macOS it starts a login shell and falls back to the shell in
|
||||||
your account settings. On Linux the fallback is `/bin/sh`.
|
your account settings. On Linux the fallback is `/bin/sh`.
|
||||||
@@ -93,8 +101,9 @@ its zygote for new GUI windows, preserving existing windows and shells. Changes
|
|||||||
to server logic or the protocol still require restarting the server;
|
to server logic or the protocol still require restarting the server;
|
||||||
`--shutdown` also ends its shell sessions.
|
`--shutdown` also ends its shell sessions.
|
||||||
|
|
||||||
This build uses protocol version 4. An older server must be restarted before
|
This build uses protocol version 6. Both ends of an SSH connection need this protocol.
|
||||||
attaching; `psyterm --shutdown` can stop servers using versions 1–3.
|
An older server must be restarted before attaching. `psyterm --shutdown`
|
||||||
|
can stop servers using versions 1–5.
|
||||||
Finish any running work first, since shutdown ends its sessions, then launch
|
Finish any running work first, since shutdown ends its sessions, then launch
|
||||||
`psyterm` again to start the updated server.
|
`psyterm` again to start the updated server.
|
||||||
|
|
||||||
@@ -102,10 +111,12 @@ Finish any running work first, since shutdown ends its sessions, then launch
|
|||||||
|
|
||||||
| Command | Behavior |
|
| Command | Behavior |
|
||||||
| --- | --- |
|
| --- | --- |
|
||||||
| `psyterm` | Open a local window attached to the server |
|
| `psyterm` | Open a new local session in a new window |
|
||||||
| `psyterm --remote user@host` | Open a local GUI connected to the remote server over SSH |
|
| `psyterm --attach [ID]` | Open a window on an existing session |
|
||||||
|
| `psyterm --remote user@host` | Start a fresh SSH session in an adjacent tab when run from a local psyTerm pane, or a new window when run elsewhere |
|
||||||
|
| `psyterm --remote user@host --attach [ID]` | Reattach to an existing session on the SSH host |
|
||||||
| `psyterm --gui` | Run the GUI in the current process |
|
| `psyterm --gui` | Run the GUI in the current process |
|
||||||
| `psyterm --list` | Inspect tabs and panes in the running local server |
|
| `psyterm --list` | Show local sessions, attached window counts, tabs, and panes |
|
||||||
| `psyterm --shutdown` | Stop the local server and end its sessions |
|
| `psyterm --shutdown` | Stop the local server and end its sessions |
|
||||||
| `psyterm --server` | Run the terminal server in the foreground |
|
| `psyterm --server` | Run the terminal server in the foreground |
|
||||||
| `psyterm --socket PATH` | Select a separate local server socket; combine with other options |
|
| `psyterm --socket PATH` | Select a separate local server socket; combine with other options |
|
||||||
@@ -125,25 +136,33 @@ UID using `getpeereid` on macOS and `SO_PEERCRED` on Linux. The server logs
|
|||||||
to `server.sock.log` beside the socket. The Linux zygote logs to
|
to `server.sock.log` beside the socket. The Linux zygote logs to
|
||||||
`server.sock.zygote.log`.
|
`server.sock.zygote.log`.
|
||||||
|
|
||||||
SSH uses `BatchMode=yes`: configure key/agent authentication and known-host trust
|
From a local psyTerm shell, run `psyterm --remote me@workstation` to open a tab
|
||||||
before connecting. The remote host needs a compatible `psyterm` executable in
|
immediately to the right of the invoking tab. The command returns to the local
|
||||||
its noninteractive SSH `PATH`. Override that executable with
|
shell while SSH connects. Run it again for an independent remote session, or
|
||||||
`PSYTERM_REMOTE_BIN`; this direct-launch example uses the current environment:
|
add `--attach ID` to open an existing one. Use `ssh me@workstation psyterm --list`
|
||||||
|
to find remote session IDs. Closing the window and reattaching to the local
|
||||||
|
session restores its mixed tab bar. The **+** button creates a local tab in
|
||||||
|
this workspace. Splitting a remote pane creates another shell on its SSH host.
|
||||||
|
|
||||||
|
SSH uses `BatchMode=yes`. Configure key or agent authentication and trust the
|
||||||
|
host key before connecting. The remote host needs a compatible `psyterm`
|
||||||
|
executable on its noninteractive SSH `PATH`. To use a different path, set
|
||||||
|
`PSYTERM_REMOTE_BIN` in the invoking shell.
|
||||||
|
|
||||||
```sh
|
```sh
|
||||||
PSYTERM_REMOTE_BIN=/home/me/bin/psyterm \
|
PSYTERM_REMOTE_BIN=/home/me/bin/psyterm psyterm --remote me@workstation
|
||||||
cargo run --locked -- --gui --remote me@workstation
|
|
||||||
```
|
```
|
||||||
|
|
||||||
SSH starts `psyterm --bridge` on the remote host, which starts or reuses that
|
SSH starts `psyterm --bridge` on the remote host, which starts or reuses that
|
||||||
host's server. stdout carries only framed protocol bytes. No TCP listener or
|
host's server. SSH carries input and terminal updates over its standard streams.
|
||||||
separate network authentication service is exposed. To end remote sessions,
|
To end remote sessions,
|
||||||
run `psyterm --shutdown` on the remote host, for example through SSH.
|
run `psyterm --shutdown` on the remote host, for example through SSH.
|
||||||
|
|
||||||
## Controls
|
## Controls
|
||||||
|
|
||||||
| Action | macOS | Linux |
|
| Action | macOS | Linux |
|
||||||
| --- | --- | --- |
|
| --- | --- | --- |
|
||||||
|
| Open a new window and session | Cmd+N | Ctrl+Shift+N |
|
||||||
| Increase terminal text size | Cmd+Plus or Cmd+= | Ctrl+Plus or Ctrl+= |
|
| Increase terminal text size | Cmd+Plus or Cmd+= | Ctrl+Plus or Ctrl+= |
|
||||||
| Decrease terminal text size | Cmd+Minus | Ctrl+Minus |
|
| Decrease terminal text size | Cmd+Minus | Ctrl+Minus |
|
||||||
| Open or dismiss the command palette | Cmd+Shift+P | Ctrl+Shift+P |
|
| Open or dismiss the command palette | Cmd+Shift+P | Ctrl+Shift+P |
|
||||||
@@ -216,11 +235,11 @@ When a shell exits, its pane closes automatically. An empty tab closes too,
|
|||||||
and focus moves to an adjacent remaining pane or tab when needed. After the
|
and focus moves to an adjacent remaining pane or tab when needed. After the
|
||||||
last shell exits, the window stays open with `+` available to start another tab.
|
last shell exits, the window stays open with `+` available to start another tab.
|
||||||
|
|
||||||
Clients share the server's active tab, focused pane, selection, and scrollback
|
Each session has its own tabs, panes, focus, and scrollback. Windows attached
|
||||||
position. The most recent GUI resize sets each pane's grid size. These are
|
to the same session share those and the underlying PTY grid. Each window keeps
|
||||||
shared views of one workspace, not independent per-client layouts. Tabs and
|
its own text size, and the focused window sets the grid dimensions. Tabs and
|
||||||
panes survive GUI disconnects but are stored in daemon memory, not persisted
|
panes survive GUI disconnects and stay in server memory until the shells exit
|
||||||
across server shutdown or machine restart.
|
or the server stops.
|
||||||
|
|
||||||
## Appearance
|
## Appearance
|
||||||
|
|
||||||
@@ -336,6 +355,6 @@ navigation bindings, stack insertion in both directions, collapsed-pane focus,
|
|||||||
exit cleanup, and stack reattachment. A second client's focus changes preserve
|
exit cleanup, and stack reattachment. A second client's focus changes preserve
|
||||||
palette input. These checks cover Linux Wayland.
|
palette input. These checks cover Linux Wayland.
|
||||||
|
|
||||||
Current limits include no arbitrary split trees or floating panes, shared per-server
|
Current limits include no arbitrary split trees or floating panes, shared per-session
|
||||||
viewport state, no disk-restored sessions, no configuration files, no application mouse reporting,
|
viewport state, no disk-restored sessions, no configuration files, no application mouse reporting,
|
||||||
no Kitty keyboard protocol, no OSC 52 clipboard access, and no clickable links.
|
no Kitty keyboard protocol, no OSC 52 clipboard access, and no clickable links.
|
||||||
|
|||||||
@@ -15,6 +15,8 @@ import subprocess
|
|||||||
import tempfile
|
import tempfile
|
||||||
import time
|
import time
|
||||||
|
|
||||||
|
PROTOCOL_VERSION = 6
|
||||||
|
|
||||||
parser = argparse.ArgumentParser(description=__doc__)
|
parser = argparse.ArgumentParser(description=__doc__)
|
||||||
parser.add_argument("--binary", type=Path, default=Path("target/debug/psyterm"))
|
parser.add_argument("--binary", type=Path, default=Path("target/debug/psyterm"))
|
||||||
args = parser.parse_args()
|
args = parser.parse_args()
|
||||||
@@ -70,13 +72,16 @@ def write_frame(stream, payload):
|
|||||||
stream.sendall(struct.pack("<I", len(payload)) + payload)
|
stream.sendall(struct.pack("<I", len(payload)) + payload)
|
||||||
|
|
||||||
|
|
||||||
def send_input(version, pane, text):
|
def send_input(session_id, pane, text):
|
||||||
# These prefix commands have stable, regression-tested bincode wire tags.
|
# These prefix commands have stable, regression-tested bincode wire tags.
|
||||||
with socket.socket(socket.AF_UNIX) as stream:
|
with socket.socket(socket.AF_UNIX) as stream:
|
||||||
stream.settimeout(5)
|
stream.settimeout(5)
|
||||||
stream.connect(str(server_socket))
|
stream.connect(str(server_socket))
|
||||||
write_frame(stream, struct.pack("<II", 0, version)) # Hello
|
write_frame(stream, struct.pack("<II", 0, PROTOCOL_VERSION)) # Hello
|
||||||
assert struct.unpack_from("<II", read_frame(stream)) == (0, version)
|
assert struct.unpack_from("<II", read_frame(stream)) == (0, PROTOCOL_VERSION)
|
||||||
|
# Join the GUI's session before sending pane commands.
|
||||||
|
write_frame(stream, struct.pack("<IIBQ", 1, 1, 1, session_id)) # Connect(Attach(Some(id)))
|
||||||
|
assert struct.unpack("<IQ", read_frame(stream)) == (6, session_id) # Connected
|
||||||
data = text.encode()
|
data = text.encode()
|
||||||
write_frame(stream, struct.pack("<IQQ", 2, pane, len(data)) + data)
|
write_frame(stream, struct.pack("<IQQ", 2, pane, len(data)) + data)
|
||||||
write_frame(stream, struct.pack("<I", 15)) # Ping, after Input
|
write_frame(stream, struct.pack("<I", 15)) # Ping, after Input
|
||||||
@@ -110,11 +115,11 @@ try:
|
|||||||
)
|
)
|
||||||
wait_for(prepared_frames, "first terminal frame")
|
wait_for(prepared_frames, "first terminal frame")
|
||||||
listing = control("--list")
|
listing = control("--list")
|
||||||
version = int(re.search(r"version: (\d+)", listing).group(1))
|
session_id = int(re.search(r"session (\d+)", listing).group(1))
|
||||||
pane = int(re.search(r"panes \[(\d+)", listing).group(1))
|
pane = int(re.search(r"panes \[(\d+)", listing).group(1))
|
||||||
# No cursor animation, input event, resize, or screenshot may keep drawing
|
# No cursor animation, input event, resize, or screenshot may keep drawing
|
||||||
# alive or accidentally wake the output during the check.
|
# alive or accidentally wake the output during the check.
|
||||||
send_input(version, pane, "printf '\\033[?25l'\n")
|
send_input(session_id, pane, "printf '\\033[?25l'\n")
|
||||||
time.sleep(2)
|
time.sleep(2)
|
||||||
idle_paints = gui_log.read_text().count("paint_us=")
|
idle_paints = gui_log.read_text().count("paint_us=")
|
||||||
time.sleep(1.25)
|
time.sleep(1.25)
|
||||||
@@ -122,7 +127,7 @@ try:
|
|||||||
f"Hidden cursor keeps repainting an idle window; logs: {runtime}"
|
f"Hidden cursor keeps repainting an idle window; logs: {runtime}"
|
||||||
)
|
)
|
||||||
before = prepared_frames()
|
before = prepared_frames()
|
||||||
send_input(version, pane, "printf '\\033]2;IDLE-DRAW-CHECK\\007Fresh output after idle\\n'\n")
|
send_input(session_id, pane, "printf '\\033]2;IDLE-DRAW-CHECK\\007Fresh output after idle\\n'\n")
|
||||||
wait_for(lambda: "IDLE-DRAW-CHECK" in control("--list"), "updated server title")
|
wait_for(lambda: "IDLE-DRAW-CHECK" in control("--list"), "updated server title")
|
||||||
wait_for(lambda: prepared_frames() > before, "updated terminal paint without compositor input", timeout=2)
|
wait_for(lambda: prepared_frames() > before, "updated terminal paint without compositor input", timeout=2)
|
||||||
assert gui.poll() is None, "GUI exited during redraw"
|
assert gui.poll() is None, "GUI exited during redraw"
|
||||||
|
|||||||
+11
-1
@@ -14,6 +14,9 @@ pub fn action_for_key(key: &Keystroke) -> Option<CommandAction> {
|
|||||||
};
|
};
|
||||||
if modifiers == window_modifiers {
|
if modifiers == window_modifiers {
|
||||||
match name.as_str() {
|
match name.as_str() {
|
||||||
|
"n" if modifiers.shift == cfg!(not(target_os = "macos")) => {
|
||||||
|
return Some(CommandAction::NewWindow);
|
||||||
|
}
|
||||||
// GPUI may fold Shift into the symbol. On XKB the keypad keys
|
// GPUI may fold Shift into the symbol. On XKB the keypad keys
|
||||||
// have separate "add" and "subtract" names.
|
// have separate "add" and "subtract" names.
|
||||||
"+" | "=" | "add" => return Some(CommandAction::IncreaseFontSize),
|
"+" | "=" | "add" => return Some(CommandAction::IncreaseFontSize),
|
||||||
@@ -148,9 +151,16 @@ mod tests {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn text_size_shortcuts_use_platform_conventions() {
|
fn new_window_and_text_size_shortcuts_use_platform_conventions() {
|
||||||
use CommandAction::*;
|
use CommandAction::*;
|
||||||
|
|
||||||
|
let new_window = if cfg!(target_os = "macos") {
|
||||||
|
"cmd-n"
|
||||||
|
} else {
|
||||||
|
"ctrl-shift-n"
|
||||||
|
};
|
||||||
|
assert!(matches!(action(new_window), Some(NewWindow)));
|
||||||
|
assert!(action("ctrl-n").is_none());
|
||||||
for key in [
|
for key in [
|
||||||
"secondary-+",
|
"secondary-+",
|
||||||
"secondary-=",
|
"secondary-=",
|
||||||
|
|||||||
+321
-43
@@ -1,15 +1,20 @@
|
|||||||
//! Display-only client transport. No terminal parser, PTY, or shell lives here.
|
//! Display-only client transport. No terminal parser, PTY, or shell lives here.
|
||||||
use crate::protocol::{self, ClientMessage, ServerMessage, Snapshot};
|
use crate::protocol::{self, ClientMessage, ServerMessage, SessionTarget, Snapshot, SshOptions};
|
||||||
use anyhow::{Context, Result, bail};
|
use anyhow::{Context, Result, bail};
|
||||||
use std::{
|
use std::{
|
||||||
collections::VecDeque,
|
collections::{HashSet, VecDeque},
|
||||||
io::{Read, Write},
|
io::{self, Read, Write},
|
||||||
net::Shutdown,
|
net::Shutdown,
|
||||||
os::unix::net::UnixStream,
|
os::{fd::OwnedFd, unix::net::UnixStream},
|
||||||
path::Path,
|
path::{Path, PathBuf},
|
||||||
process::{Child, Command, Stdio},
|
process::{Child, ChildStderr, Command, Stdio},
|
||||||
sync::{Arc, Mutex, mpsc},
|
sync::{
|
||||||
|
Arc, Mutex,
|
||||||
|
atomic::{AtomicBool, Ordering},
|
||||||
|
mpsc,
|
||||||
|
},
|
||||||
thread,
|
thread,
|
||||||
|
time::{Duration, Instant},
|
||||||
};
|
};
|
||||||
|
|
||||||
#[derive(Default)]
|
#[derive(Default)]
|
||||||
@@ -17,6 +22,7 @@ pub struct Update {
|
|||||||
pub snapshot: Option<Arc<Snapshot>>,
|
pub snapshot: Option<Arc<Snapshot>>,
|
||||||
pub clipboard: VecDeque<String>,
|
pub clipboard: VecDeque<String>,
|
||||||
pub error: Option<String>,
|
pub error: Option<String>,
|
||||||
|
pub disconnected: bool,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct Updates {
|
pub struct Updates {
|
||||||
@@ -24,6 +30,11 @@ pub struct Updates {
|
|||||||
pending: Arc<Mutex<Update>>,
|
pending: Arc<Mutex<Update>>,
|
||||||
}
|
}
|
||||||
impl Updates {
|
impl Updates {
|
||||||
|
pub fn recv_blocking(&self) -> Option<Update> {
|
||||||
|
self.signal.recv_blocking().ok()?;
|
||||||
|
Some(std::mem::take(&mut *self.pending.lock().unwrap()))
|
||||||
|
}
|
||||||
|
|
||||||
pub async fn recv(&self) -> Option<Update> {
|
pub async fn recv(&self) -> Option<Update> {
|
||||||
self.signal.recv().await.ok()?;
|
self.signal.recv().await.ok()?;
|
||||||
Some(std::mem::take(&mut *self.pending.lock().unwrap()))
|
Some(std::mem::take(&mut *self.pending.lock().unwrap()))
|
||||||
@@ -33,6 +44,8 @@ impl Updates {
|
|||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct Client(Arc<Connection>);
|
pub struct Client(Arc<Connection>);
|
||||||
struct Connection {
|
struct Connection {
|
||||||
|
launcher_socket: PathBuf,
|
||||||
|
remote: Option<String>,
|
||||||
commands: mpsc::Sender<ClientMessage>,
|
commands: mpsc::Sender<ClientMessage>,
|
||||||
socket: Option<UnixStream>,
|
socket: Option<UnixStream>,
|
||||||
ssh: Mutex<Option<Child>>,
|
ssh: Mutex<Option<Child>>,
|
||||||
@@ -50,17 +63,86 @@ impl Drop for Connection {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl SshOptions {
|
||||||
|
pub fn from_env() -> Self {
|
||||||
|
Self {
|
||||||
|
executable: std::env::var("PSYTERM_REMOTE_BIN").ok(),
|
||||||
|
agent_socket: std::env::var_os("SSH_AUTH_SOCK").map(PathBuf::from),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn validate_destination(destination: &str) -> Result<()> {
|
||||||
|
if destination.is_empty()
|
||||||
|
|| destination.len() > 1024
|
||||||
|
|| destination.starts_with('-')
|
||||||
|
|| destination
|
||||||
|
.chars()
|
||||||
|
.any(|c| c.is_control() || c.is_whitespace())
|
||||||
|
{
|
||||||
|
bail!("invalid SSH destination");
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
impl Client {
|
impl Client {
|
||||||
pub fn connect(socket: &Path, remote: Option<&str>) -> Result<(Self, Updates)> {
|
pub fn connect(
|
||||||
let (reader, writer, socket, ssh): (Box<dyn Read + Send>, Box<dyn Write + Send>, _, _) =
|
launcher_socket: &Path,
|
||||||
|
remote: Option<&str>,
|
||||||
|
session: SessionTarget,
|
||||||
|
) -> Result<(Self, Updates)> {
|
||||||
|
Self::connect_with(
|
||||||
|
launcher_socket,
|
||||||
|
remote,
|
||||||
|
session,
|
||||||
|
SshOptions::from_env(),
|
||||||
|
None,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn connect_remote(
|
||||||
|
launcher_socket: &Path,
|
||||||
|
destination: &str,
|
||||||
|
session: SessionTarget,
|
||||||
|
ssh: SshOptions,
|
||||||
|
cancelled: Arc<AtomicBool>,
|
||||||
|
) -> Result<(Self, Updates)> {
|
||||||
|
Self::connect_with(
|
||||||
|
launcher_socket,
|
||||||
|
Some(destination),
|
||||||
|
session,
|
||||||
|
ssh,
|
||||||
|
Some(cancelled),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn connect_with(
|
||||||
|
launcher_socket: &Path,
|
||||||
|
remote: Option<&str>,
|
||||||
|
session: SessionTarget,
|
||||||
|
options: SshOptions,
|
||||||
|
cancelled: Option<Arc<AtomicBool>>,
|
||||||
|
) -> Result<(Self, Updates)> {
|
||||||
|
let (mut reader, mut writer, socket, mut ssh): (_, Box<dyn Write + Send>, _, _) =
|
||||||
if let Some(remote) = remote {
|
if let Some(remote) = remote {
|
||||||
if remote.is_empty() || remote.starts_with('-') || remote.contains(['\n', '\r']) {
|
validate_destination(remote)?;
|
||||||
bail!("invalid SSH destination");
|
let executable = options.executable.as_deref().unwrap_or("psyterm");
|
||||||
|
let attach = if matches!(session, SessionTarget::Attach(_)) {
|
||||||
|
" --attach"
|
||||||
|
} else {
|
||||||
|
""
|
||||||
|
};
|
||||||
|
let remote_command = format!("exec {} --bridge{attach}", shell_quote(executable));
|
||||||
|
let mut ssh_command = Command::new("ssh");
|
||||||
|
if let Some(socket) = options.agent_socket {
|
||||||
|
ssh_command.env("SSH_AUTH_SOCK", socket);
|
||||||
|
} else {
|
||||||
|
ssh_command.env_remove("SSH_AUTH_SOCK");
|
||||||
}
|
}
|
||||||
let executable =
|
// A socketpair allows a bounded, cancellable greeting even when the
|
||||||
std::env::var("PSYTERM_REMOTE_BIN").unwrap_or_else(|_| "psyterm".into());
|
// SSH connection succeeds but the remote bridge stalls.
|
||||||
let remote_command = format!("exec {} --bridge", shell_quote(&executable));
|
let (reader, stdout) = UnixStream::pair()?;
|
||||||
let mut child = Command::new("ssh")
|
let mut child = ssh_command
|
||||||
.args([
|
.args([
|
||||||
"-T",
|
"-T",
|
||||||
"-o",
|
"-o",
|
||||||
@@ -72,31 +154,52 @@ impl Client {
|
|||||||
&remote_command,
|
&remote_command,
|
||||||
])
|
])
|
||||||
.stdin(Stdio::piped())
|
.stdin(Stdio::piped())
|
||||||
.stdout(Stdio::piped())
|
.stdout(Stdio::from(OwnedFd::from(stdout)))
|
||||||
.stderr(Stdio::inherit())
|
.stderr(Stdio::piped())
|
||||||
.spawn()
|
.spawn()
|
||||||
.context("start SSH terminal transport")?;
|
.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>;
|
let writer = Box::new(child.stdin.take().unwrap()) as Box<dyn Write + Send>;
|
||||||
(reader, writer, None, Some(child))
|
(reader, writer, None, Some(child))
|
||||||
} else {
|
} else {
|
||||||
let stream = UnixStream::connect(socket).context("connect to psyTerm server")?;
|
let stream =
|
||||||
|
UnixStream::connect(launcher_socket).context("connect to psyTerm server")?;
|
||||||
crate::launcher::verify_peer(&stream)?;
|
crate::launcher::verify_peer(&stream)?;
|
||||||
(
|
(
|
||||||
Box::new(stream.try_clone()?) as Box<dyn Read + Send>,
|
stream.try_clone()?,
|
||||||
Box::new(stream.try_clone()?) as Box<dyn Write + Send>,
|
Box::new(stream.try_clone()?) as Box<dyn Write + Send>,
|
||||||
Some(stream),
|
Some(stream),
|
||||||
None,
|
None,
|
||||||
)
|
)
|
||||||
};
|
};
|
||||||
|
let stderr = ssh.as_mut().and_then(|child| child.stderr.take());
|
||||||
let (commands, receive) = mpsc::channel();
|
let (commands, receive) = mpsc::channel();
|
||||||
let (signal, notifications) = async_channel::bounded(1);
|
let (signal, notifications) = async_channel::bounded(1);
|
||||||
let pending = Arc::new(Mutex::new(Update::default()));
|
let pending = Arc::new(Mutex::new(Update::default()));
|
||||||
let connection = Self(Arc::new(Connection {
|
let connection = Self(Arc::new(Connection {
|
||||||
|
launcher_socket: launcher_socket.to_owned(),
|
||||||
|
remote: remote.map(str::to_owned),
|
||||||
commands,
|
commands,
|
||||||
socket,
|
socket,
|
||||||
ssh: Mutex::new(ssh),
|
ssh: Mutex::new(ssh),
|
||||||
}));
|
}));
|
||||||
|
let diagnostic = stderr.map(ssh_diagnostics).transpose()?;
|
||||||
|
reader.set_read_timeout(Some(Duration::from_millis(150)))?;
|
||||||
|
let mut greeting = GreetingReader {
|
||||||
|
reader: &mut reader,
|
||||||
|
deadline: Instant::now() + Duration::from_secs(if remote.is_some() { 30 } else { 5 }),
|
||||||
|
cancelled: cancelled.as_deref(),
|
||||||
|
};
|
||||||
|
if let Err(error) = greet(&mut greeting, &mut writer, session) {
|
||||||
|
drop(connection);
|
||||||
|
if let Some(detail) = diagnostic
|
||||||
|
.and_then(|rx| rx.recv_timeout(Duration::from_millis(150)).ok())
|
||||||
|
.filter(|s| !s.is_empty())
|
||||||
|
{
|
||||||
|
bail!("{error:#}: {detail}");
|
||||||
|
}
|
||||||
|
return Err(error);
|
||||||
|
}
|
||||||
|
reader.set_read_timeout(None)?;
|
||||||
let errors = pending.clone();
|
let errors = pending.clone();
|
||||||
let notify = signal.clone();
|
let notify = signal.clone();
|
||||||
thread::Builder::new()
|
thread::Builder::new()
|
||||||
@@ -116,24 +219,13 @@ impl Client {
|
|||||||
.name("psyterm-client-reader".into())
|
.name("psyterm-client-reader".into())
|
||||||
.spawn(move || {
|
.spawn(move || {
|
||||||
let mut reader = reader;
|
let mut reader = reader;
|
||||||
let mut greeted = false;
|
|
||||||
loop {
|
loop {
|
||||||
let message = protocol::read_message::<ServerMessage>(&mut reader);
|
let message = protocol::read_message::<ServerMessage>(&mut reader);
|
||||||
let mut update = incoming.lock().unwrap();
|
let mut update = incoming.lock().unwrap();
|
||||||
match message {
|
match message {
|
||||||
Ok(ServerMessage::Hello { version, .. })
|
Ok(ServerMessage::Snapshot(snapshot)) => {
|
||||||
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) {
|
if let Err(error) = validate_snapshot(&snapshot) {
|
||||||
|
update.disconnected = true;
|
||||||
update.error = Some(error.to_string());
|
update.error = Some(error.to_string());
|
||||||
let _ = signal.try_send(());
|
let _ = signal.try_send(());
|
||||||
break;
|
break;
|
||||||
@@ -141,13 +233,14 @@ impl Client {
|
|||||||
// A slow window never accumulates a queue of obsolete frames.
|
// A slow window never accumulates a queue of obsolete frames.
|
||||||
update.snapshot = Some(Arc::new(snapshot));
|
update.snapshot = Some(Arc::new(snapshot));
|
||||||
}
|
}
|
||||||
Ok(ServerMessage::Clipboard(text)) if greeted => {
|
Ok(ServerMessage::Clipboard(text)) => {
|
||||||
if update.clipboard.len() < 16 {
|
if update.clipboard.len() < 16 {
|
||||||
update.clipboard.push_back(text);
|
update.clipboard.push_back(text);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Ok(ServerMessage::Error(error)) => update.error = Some(error),
|
Ok(ServerMessage::Error(error)) => update.error = Some(error),
|
||||||
Ok(ServerMessage::Closing) => {
|
Ok(ServerMessage::Closing) => {
|
||||||
|
update.disconnected = true;
|
||||||
update.error =
|
update.error =
|
||||||
Some("Server stopped. Shell sessions have ended.".into());
|
Some("Server stopped. Shell sessions have ended.".into());
|
||||||
let _ = signal.try_send(());
|
let _ = signal.try_send(());
|
||||||
@@ -155,9 +248,11 @@ impl Client {
|
|||||||
}
|
}
|
||||||
Ok(ServerMessage::Pong) => {}
|
Ok(ServerMessage::Pong) => {}
|
||||||
Ok(_) => {
|
Ok(_) => {
|
||||||
update.error = Some("Server sent data before its handshake".into());
|
update.error =
|
||||||
|
Some("Unexpected server response after session handshake".into());
|
||||||
}
|
}
|
||||||
Err(error) => {
|
Err(error) => {
|
||||||
|
update.disconnected = true;
|
||||||
update.error = Some(format!(
|
update.error = Some(format!(
|
||||||
"Disconnected — sessions remain on the server. {error:#}"
|
"Disconnected — sessions remain on the server. {error:#}"
|
||||||
));
|
));
|
||||||
@@ -169,10 +264,6 @@ impl Client {
|
|||||||
let _ = signal.try_send(());
|
let _ = signal.try_send(());
|
||||||
}
|
}
|
||||||
})?;
|
})?;
|
||||||
connection.send(ClientMessage::Hello {
|
|
||||||
version: protocol::VERSION,
|
|
||||||
})?;
|
|
||||||
connection.send(ClientMessage::Attach)?;
|
|
||||||
Ok((
|
Ok((
|
||||||
connection,
|
connection,
|
||||||
Updates {
|
Updates {
|
||||||
@@ -182,6 +273,22 @@ impl Client {
|
|||||||
))
|
))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn remote(&self) -> Option<&str> {
|
||||||
|
self.0.remote.as_deref()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Launch through the local daemon even when this terminal connects over SSH.
|
||||||
|
pub fn open_window(&self, remote: Option<String>, cwd: Option<String>) -> Result<()> {
|
||||||
|
crate::launcher::control(
|
||||||
|
&self.0.launcher_socket,
|
||||||
|
ClientMessage::OpenWindow {
|
||||||
|
target: remote,
|
||||||
|
session: SessionTarget::New { cwd },
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
pub fn send(&self, message: ClientMessage) -> Result<()> {
|
pub fn send(&self, message: ClientMessage) -> Result<()> {
|
||||||
self.0
|
self.0
|
||||||
.commands
|
.commands
|
||||||
@@ -199,17 +306,150 @@ impl Client {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Drain SSH stderr throughout the connection. Keep a bounded tail to explain
|
||||||
|
/// startup failures in the invoking window as well as in the daemon log.
|
||||||
|
fn ssh_diagnostics(mut stderr: ChildStderr) -> io::Result<mpsc::Receiver<String>> {
|
||||||
|
let (tx, rx) = mpsc::channel();
|
||||||
|
thread::Builder::new()
|
||||||
|
.name("psyterm-ssh-stderr".into())
|
||||||
|
.spawn(move || {
|
||||||
|
let mut tail = Vec::new();
|
||||||
|
let mut buf = [0; 1024];
|
||||||
|
while let Ok(n) = stderr.read(&mut buf) {
|
||||||
|
if n == 0 {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
let _ = io::stderr().write_all(&buf[..n]);
|
||||||
|
tail.extend_from_slice(&buf[..n]);
|
||||||
|
tail.drain(..tail.len().saturating_sub(1024));
|
||||||
|
}
|
||||||
|
let detail = String::from_utf8_lossy(&tail);
|
||||||
|
let _ = tx.send(
|
||||||
|
detail
|
||||||
|
.trim()
|
||||||
|
.lines()
|
||||||
|
.next_back()
|
||||||
|
.unwrap_or_default()
|
||||||
|
.to_owned(),
|
||||||
|
);
|
||||||
|
})?;
|
||||||
|
Ok(rx)
|
||||||
|
}
|
||||||
|
|
||||||
|
struct GreetingReader<'a> {
|
||||||
|
reader: &'a mut UnixStream,
|
||||||
|
deadline: Instant,
|
||||||
|
cancelled: Option<&'a AtomicBool>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl GreetingReader<'_> {
|
||||||
|
fn check(&self) -> io::Result<()> {
|
||||||
|
if self
|
||||||
|
.cancelled
|
||||||
|
.is_some_and(|flag| flag.load(Ordering::Acquire))
|
||||||
|
{
|
||||||
|
return Err(io::Error::new(
|
||||||
|
io::ErrorKind::ConnectionAborted,
|
||||||
|
"connection cancelled",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
if Instant::now() >= self.deadline {
|
||||||
|
return Err(io::Error::new(
|
||||||
|
io::ErrorKind::TimedOut,
|
||||||
|
"timed out waiting for the psyTerm server",
|
||||||
|
));
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Read for GreetingReader<'_> {
|
||||||
|
fn read(&mut self, buffer: &mut [u8]) -> io::Result<usize> {
|
||||||
|
loop {
|
||||||
|
self.check()?;
|
||||||
|
match self.reader.read(buffer) {
|
||||||
|
Err(e)
|
||||||
|
if matches!(
|
||||||
|
e.kind(),
|
||||||
|
io::ErrorKind::TimedOut | io::ErrorKind::WouldBlock
|
||||||
|
) => {}
|
||||||
|
result => return result,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn greet(
|
||||||
|
reader: &mut GreetingReader<'_>,
|
||||||
|
writer: &mut impl Write,
|
||||||
|
session: SessionTarget,
|
||||||
|
) -> Result<()> {
|
||||||
|
reader.check()?;
|
||||||
|
protocol::write_message(
|
||||||
|
writer,
|
||||||
|
&ClientMessage::Hello {
|
||||||
|
version: protocol::VERSION,
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
match protocol::read_message::<ServerMessage>(reader)? {
|
||||||
|
ServerMessage::Hello { version, .. } if version == protocol::VERSION => {}
|
||||||
|
ServerMessage::Error(error) => bail!("{error}"),
|
||||||
|
_ => bail!("server protocol differs from this client"),
|
||||||
|
}
|
||||||
|
reader.check()?;
|
||||||
|
protocol::write_message(writer, &ClientMessage::Connect(session))?;
|
||||||
|
match protocol::read_message::<ServerMessage>(reader)? {
|
||||||
|
ServerMessage::Connected { .. } => Ok(()),
|
||||||
|
ServerMessage::Error(error) => bail!("{error}"),
|
||||||
|
_ => bail!("server did not acknowledge the session"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
fn shell_quote(value: &str) -> String {
|
fn shell_quote(value: &str) -> String {
|
||||||
format!("'{}'", value.replace('\'', "'\\''"))
|
format!("'{}'", value.replace('\'', "'\\''"))
|
||||||
}
|
}
|
||||||
|
|
||||||
fn validate_snapshot(snapshot: &Snapshot) -> Result<()> {
|
fn validate_snapshot(snapshot: &Snapshot) -> Result<()> {
|
||||||
if snapshot.tabs.len() > 256 || snapshot.panes.len() > 64 {
|
if snapshot.tabs.len() > 256 || snapshot.lineage.len() > 256 || snapshot.panes.len() > 64 {
|
||||||
bail!("Server layout exceeds client limits");
|
bail!("Server layout exceeds client limits");
|
||||||
}
|
}
|
||||||
|
let mut tab_ids = HashSet::new();
|
||||||
|
let mut pane_ids = HashSet::new();
|
||||||
|
let mut expanded = HashSet::new();
|
||||||
|
for tab in &snapshot.tabs {
|
||||||
|
if !tab_ids.insert(tab.id) {
|
||||||
|
bail!("Server sent a duplicate tab ID");
|
||||||
|
}
|
||||||
|
if tab.is_connecting() {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
let ordered = tab.stacks.iter().flat_map(|s| s.panes.iter().map(|p| p.id));
|
||||||
|
if tab.panes.is_empty()
|
||||||
|
|| tab.panes.len() > 64
|
||||||
|
|| !tab.panes.iter().all(|id| pane_ids.insert(*id))
|
||||||
|
|| ordered.ne(tab.panes.iter().copied())
|
||||||
|
|| !tab.stacks.iter().any(|s| s.active_pane == tab.active_pane)
|
||||||
|
{
|
||||||
|
bail!("Server sent an invalid tab layout");
|
||||||
|
}
|
||||||
|
for stack in &tab.stacks {
|
||||||
|
if !stack.panes.iter().any(|p| p.id == stack.active_pane) {
|
||||||
|
bail!("Server sent an invalid pane stack");
|
||||||
|
}
|
||||||
|
if tab.id == snapshot.active_tab {
|
||||||
|
expanded.insert(stack.active_pane);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !(tab_ids.contains(&snapshot.active_tab) || (tab_ids.is_empty() && snapshot.active_tab == 0))
|
||||||
|
{
|
||||||
|
bail!("Server sent an invalid active tab");
|
||||||
|
}
|
||||||
|
|
||||||
for pane in &snapshot.panes {
|
for pane in &snapshot.panes {
|
||||||
let count = usize::from(pane.columns) * usize::from(pane.lines);
|
let count = usize::from(pane.columns) * usize::from(pane.lines);
|
||||||
if pane.columns < 2
|
if !expanded.remove(&pane.id)
|
||||||
|
|| pane.columns < 2
|
||||||
|| pane.lines == 0
|
|| pane.lines == 0
|
||||||
|| count > 1_000_000
|
|| count > 1_000_000
|
||||||
|| pane.cells.len() != count
|
|| pane.cells.len() != count
|
||||||
@@ -223,8 +463,12 @@ fn validate_snapshot(snapshot: &Snapshot) -> Result<()> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
/// SSH starts this command on the remote host. Only framed protocol bytes use stdout.
|
/// SSH starts this command on the remote host. Only framed protocol bytes use stdout.
|
||||||
pub fn bridge(socket: &Path) -> Result<()> {
|
pub fn bridge(socket: &Path, attach: bool) -> Result<()> {
|
||||||
crate::launcher::ensure_server(socket)?;
|
if attach {
|
||||||
|
crate::launcher::require_server(socket)?;
|
||||||
|
} else {
|
||||||
|
crate::launcher::ensure_server(socket)?;
|
||||||
|
}
|
||||||
let stream = UnixStream::connect(socket)?;
|
let stream = UnixStream::connect(socket)?;
|
||||||
let mut output = stream.try_clone()?;
|
let mut output = stream.try_clone()?;
|
||||||
let copy_input = thread::spawn(move || {
|
let copy_input = thread::spawn(move || {
|
||||||
@@ -282,6 +526,40 @@ mod tests {
|
|||||||
assert_eq!(output.bytes, b"binary-without-newlines");
|
assert_eq!(output.bytes, b"binary-without-newlines");
|
||||||
assert!(output.flushes > 0);
|
assert!(output.flushes > 0);
|
||||||
}
|
}
|
||||||
|
#[test]
|
||||||
|
fn stalled_bridge_can_be_cancelled_during_a_partial_greeting() {
|
||||||
|
let (mut socket, mut peer) = UnixStream::pair().unwrap();
|
||||||
|
socket
|
||||||
|
.set_read_timeout(Some(Duration::from_millis(15)))
|
||||||
|
.unwrap();
|
||||||
|
let cancelled = AtomicBool::new(false);
|
||||||
|
thread::scope(|threads| {
|
||||||
|
let (ready, start) = mpsc::channel();
|
||||||
|
let (done, wait) = mpsc::channel::<()>();
|
||||||
|
let flag = &cancelled;
|
||||||
|
threads.spawn(move || {
|
||||||
|
peer.write_all(&[8, 0]).unwrap();
|
||||||
|
start.recv().unwrap();
|
||||||
|
flag.store(true, Ordering::Release);
|
||||||
|
// Keep the peer open until the reader notices cancellation.
|
||||||
|
let _ = wait.recv();
|
||||||
|
});
|
||||||
|
let mut greeting = GreetingReader {
|
||||||
|
reader: &mut socket,
|
||||||
|
deadline: Instant::now() + Duration::from_secs(5),
|
||||||
|
cancelled: Some(&cancelled),
|
||||||
|
};
|
||||||
|
let mut header = [0; 4];
|
||||||
|
greeting.read_exact(&mut header[..2]).unwrap();
|
||||||
|
ready.send(()).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
greeting.read_exact(&mut header[2..]).unwrap_err().kind(),
|
||||||
|
io::ErrorKind::ConnectionAborted
|
||||||
|
);
|
||||||
|
drop(done);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn remote_binary_paths_are_shell_quoted() {
|
fn remote_binary_paths_are_shell_quoted() {
|
||||||
assert_eq!(shell_quote("/tmp/a'b; x"), "'/tmp/a'\\''b; x'");
|
assert_eq!(shell_quote("/tmp/a'b; x"), "'/tmp/a'\\''b; x'");
|
||||||
|
|||||||
@@ -7,6 +7,7 @@ use crate::protocol::{ScrollKind, Snapshot};
|
|||||||
#[derive(Clone, Debug)]
|
#[derive(Clone, Debug)]
|
||||||
pub enum CommandAction {
|
pub enum CommandAction {
|
||||||
TogglePalette,
|
TogglePalette,
|
||||||
|
NewWindow,
|
||||||
NewTab,
|
NewTab,
|
||||||
IncreaseFontSize,
|
IncreaseFontSize,
|
||||||
DecreaseFontSize,
|
DecreaseFontSize,
|
||||||
@@ -112,6 +113,13 @@ pub fn root_items(snapshot: Option<&Snapshot>) -> Vec<PaletteItem> {
|
|||||||
shortcut("Cmd+T", "Ctrl+Shift+T"),
|
shortcut("Cmd+T", "Ctrl+Shift+T"),
|
||||||
NewTab,
|
NewTab,
|
||||||
),
|
),
|
||||||
|
PaletteItem::action(
|
||||||
|
"new-window",
|
||||||
|
"New window",
|
||||||
|
"create independent terminal session",
|
||||||
|
shortcut("Cmd+N", "Ctrl+Shift+N"),
|
||||||
|
NewWindow,
|
||||||
|
),
|
||||||
PaletteItem::action(
|
PaletteItem::action(
|
||||||
"split-pane",
|
"split-pane",
|
||||||
"Split pane right",
|
"Split pane right",
|
||||||
|
|||||||
+27
-2
@@ -105,6 +105,13 @@ pub fn control(socket: &Path, command: ClientMessage) -> Result<ServerMessage> {
|
|||||||
result
|
result
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn require_server(socket: &Path) -> Result<()> {
|
||||||
|
if !probe_server(socket)? {
|
||||||
|
bail!("no sessions to attach to at {}", socket.display());
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
fn probe_server(socket: &Path) -> Result<bool> {
|
fn probe_server(socket: &Path) -> Result<bool> {
|
||||||
match UnixStream::connect(socket) {
|
match UnixStream::connect(socket) {
|
||||||
Ok(stream) => {
|
Ok(stream) => {
|
||||||
@@ -163,7 +170,9 @@ fn control_stream_version(
|
|||||||
loop {
|
loop {
|
||||||
let message: ServerMessage = protocol::read_message(&mut stream)?;
|
let message: ServerMessage = protocol::read_message(&mut stream)?;
|
||||||
match message {
|
match message {
|
||||||
ServerMessage::Pong | ServerMessage::Closing => return Ok(message),
|
ServerMessage::Pong | ServerMessage::Closing | ServerMessage::Sessions(_) => {
|
||||||
|
return Ok(message);
|
||||||
|
}
|
||||||
ServerMessage::Error(error) => bail!("{error}"),
|
ServerMessage::Error(error) => bail!("{error}"),
|
||||||
_ => {}
|
_ => {}
|
||||||
}
|
}
|
||||||
@@ -215,13 +224,29 @@ fn role_command(executable: &Path, role: &str, socket: &Path, log_path: &Path) -
|
|||||||
|
|
||||||
// AppKit needs a fresh process for a server-requested window on macOS.
|
// AppKit needs a fresh process for a server-requested window on macOS.
|
||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
pub fn open_window(socket: &Path, remote: Option<String>) -> Result<()> {
|
pub fn open_window(
|
||||||
|
socket: &Path,
|
||||||
|
remote: Option<String>,
|
||||||
|
session: protocol::SessionTarget,
|
||||||
|
) -> Result<()> {
|
||||||
let mut command = role_command(
|
let mut command = role_command(
|
||||||
&executable_path()?,
|
&executable_path()?,
|
||||||
"--gui",
|
"--gui",
|
||||||
socket,
|
socket,
|
||||||
&suffixed(socket, ".gui.log"),
|
&suffixed(socket, ".gui.log"),
|
||||||
)?;
|
)?;
|
||||||
|
match session {
|
||||||
|
protocol::SessionTarget::New { cwd: Some(cwd) } => {
|
||||||
|
command.arg("--cwd").arg(cwd);
|
||||||
|
}
|
||||||
|
protocol::SessionTarget::New { .. } => {}
|
||||||
|
protocol::SessionTarget::Attach(id) => {
|
||||||
|
command.arg("--attach");
|
||||||
|
if let Some(id) = id {
|
||||||
|
command.arg(id.to_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
if let Some(host) = remote {
|
if let Some(host) = remote {
|
||||||
command.arg("--remote").arg(host);
|
command.arg("--remote").arg(host);
|
||||||
}
|
}
|
||||||
|
|||||||
@@ -75,7 +75,11 @@ impl Zygote {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn open_window(&mut self, remote: Option<String>) -> Result<()> {
|
pub fn open_window(
|
||||||
|
&mut self,
|
||||||
|
remote: Option<String>,
|
||||||
|
session: protocol::SessionTarget,
|
||||||
|
) -> Result<()> {
|
||||||
let executable = executable_path()?;
|
let executable = executable_path()?;
|
||||||
let identity = ExecutableIdentity::read(&executable)?;
|
let identity = ExecutableIdentity::read(&executable)?;
|
||||||
let helper_exited = self.child.try_wait()?.is_some();
|
let helper_exited = self.child.try_wait()?.is_some();
|
||||||
@@ -89,6 +93,7 @@ impl Zygote {
|
|||||||
match self.request(&LaunchRequest::Launch {
|
match self.request(&LaunchRequest::Launch {
|
||||||
server_socket: self.server_socket.clone(),
|
server_socket: self.server_socket.clone(),
|
||||||
remote,
|
remote,
|
||||||
|
session,
|
||||||
})? {
|
})? {
|
||||||
LaunchResponse::Launched { pid } => {
|
LaunchResponse::Launched { pid } => {
|
||||||
log::info!("Forked psyTerm GUI {pid} from zygote {}", self.child.id());
|
log::info!("Forked psyTerm GUI {pid} from zygote {}", self.child.id());
|
||||||
@@ -164,6 +169,7 @@ enum LaunchRequest {
|
|||||||
Launch {
|
Launch {
|
||||||
server_socket: PathBuf,
|
server_socket: PathBuf,
|
||||||
remote: Option<String>,
|
remote: Option<String>,
|
||||||
|
session: protocol::SessionTarget,
|
||||||
},
|
},
|
||||||
Shutdown,
|
Shutdown,
|
||||||
}
|
}
|
||||||
@@ -222,6 +228,7 @@ pub fn run_zygote(socket: &Path) -> Result<()> {
|
|||||||
LaunchRequest::Launch {
|
LaunchRequest::Launch {
|
||||||
server_socket,
|
server_socket,
|
||||||
remote,
|
remote,
|
||||||
|
session,
|
||||||
} => {
|
} => {
|
||||||
if let Err(error) = ensure_single_threaded() {
|
if let Err(error) = ensure_single_threaded() {
|
||||||
protocol::write_message(
|
protocol::write_message(
|
||||||
@@ -251,7 +258,7 @@ pub fn run_zygote(socket: &Path) -> Result<()> {
|
|||||||
drop(stream);
|
drop(stream);
|
||||||
drop(listener);
|
drop(listener);
|
||||||
let result = set_child_reaping(false)
|
let result = set_child_reaping(false)
|
||||||
.and_then(|()| crate::run_gui(server_socket, remote));
|
.and_then(|()| crate::run_gui(server_socket, remote, session));
|
||||||
let code = if let Err(error) = result {
|
let code = if let Err(error) = result {
|
||||||
log::error!("GUI startup failed: {error:#}");
|
log::error!("GUI startup failed: {error:#}");
|
||||||
1
|
1
|
||||||
|
|||||||
+132
-65
@@ -19,24 +19,33 @@ mod transition;
|
|||||||
|
|
||||||
use anyhow::{Result, bail};
|
use anyhow::{Result, bail};
|
||||||
use gpui::{prelude::*, *};
|
use gpui::{prelude::*, *};
|
||||||
|
use protocol::{SessionId, SessionTarget};
|
||||||
use std::path::PathBuf;
|
use std::path::PathBuf;
|
||||||
|
|
||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
gpui::actions!(psyterm, [Quit]);
|
gpui::actions!(psyterm, [Quit, NewWindow]);
|
||||||
|
|
||||||
fn main() -> Result<()> {
|
fn main() -> Result<()> {
|
||||||
env_logger::init();
|
env_logger::init();
|
||||||
// AppKit runs in the process that LaunchServices opens. Linux uses a prefork helper.
|
// AppKit runs in the process that LaunchServices opens. Linux uses a prefork helper.
|
||||||
let mut role = if cfg!(target_os = "macos") {
|
let mut role = "launch";
|
||||||
"gui"
|
|
||||||
} else {
|
|
||||||
"launch"
|
|
||||||
};
|
|
||||||
let mut socket = None;
|
let mut socket = None;
|
||||||
let mut remote = None;
|
let mut remote = None;
|
||||||
let mut args = std::env::args().skip(1);
|
let mut cwd = None;
|
||||||
|
let mut attach: Option<Option<SessionId>> = None;
|
||||||
|
let mut args = std::env::args().skip(1).peekable();
|
||||||
while let Some(arg) = args.next() {
|
while let Some(arg) = args.next() {
|
||||||
match arg.as_str() {
|
match arg.as_str() {
|
||||||
|
"--attach" => {
|
||||||
|
let id = args
|
||||||
|
.next_if(|arg| !arg.starts_with('-'))
|
||||||
|
.map(|id| id.parse::<SessionId>())
|
||||||
|
.transpose()
|
||||||
|
.map_err(|_| {
|
||||||
|
anyhow::anyhow!("--attach expects a numeric session ID from --list")
|
||||||
|
})?;
|
||||||
|
attach = Some(id);
|
||||||
|
}
|
||||||
"--server" => role = "server",
|
"--server" => role = "server",
|
||||||
#[cfg(target_os = "linux")]
|
#[cfg(target_os = "linux")]
|
||||||
"--zygote" => role = "zygote",
|
"--zygote" => role = "zygote",
|
||||||
@@ -44,6 +53,12 @@ fn main() -> Result<()> {
|
|||||||
"--bridge" => role = "bridge",
|
"--bridge" => role = "bridge",
|
||||||
"--shutdown" => role = "shutdown",
|
"--shutdown" => role = "shutdown",
|
||||||
"--list" => role = "list",
|
"--list" => role = "list",
|
||||||
|
"--cwd" => {
|
||||||
|
cwd = Some(
|
||||||
|
args.next()
|
||||||
|
.ok_or_else(|| anyhow::anyhow!("--cwd needs a directory"))?,
|
||||||
|
);
|
||||||
|
}
|
||||||
"--socket" => {
|
"--socket" => {
|
||||||
socket = Some(PathBuf::from(
|
socket = Some(PathBuf::from(
|
||||||
args.next()
|
args.next()
|
||||||
@@ -52,63 +67,116 @@ fn main() -> Result<()> {
|
|||||||
}
|
}
|
||||||
"--remote" => {
|
"--remote" => {
|
||||||
remote = Some(
|
remote = Some(
|
||||||
args.next()
|
args.next_if(|arg| !arg.starts_with('-'))
|
||||||
.ok_or_else(|| anyhow::anyhow!("--remote needs an SSH destination"))?,
|
.ok_or_else(|| anyhow::anyhow!("--remote needs an SSH destination"))?,
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
"--help" | "-h" => {
|
"--help" | "-h" => {
|
||||||
println!(
|
println!(
|
||||||
"psyTerm — server-owned terminals with a GPUI front end\n\n psyterm Open a local terminal window\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 Run the GUI in the current process\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"
|
"psyTerm — server-owned terminals with a GPUI front end\n\n psyterm Open a new session in a new window\n psyterm --attach [ID] Join an existing session (prefer the latest detached session)\n psyterm --remote user@host Open an SSH session (an adjacent tab when run inside psyTerm)\n psyterm --list List local sessions, 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 Run the GUI in the current process\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(());
|
return Ok(());
|
||||||
}
|
}
|
||||||
_ => bail!("unknown argument: {arg}; see --help"),
|
_ => bail!("unknown argument: {arg}; see --help"),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
if attach.is_some() && !matches!(role, "gui" | "launch" | "bridge") {
|
||||||
|
bail!("--attach applies to a window or an SSH bridge");
|
||||||
|
}
|
||||||
|
#[cfg(target_os = "macos")]
|
||||||
|
if matches!(role, "launch" | "gui")
|
||||||
|
&& unsafe { libc::getppid() } == 1
|
||||||
|
&& std::env::current_dir()? == std::path::Path::new("/")
|
||||||
|
&& let Some(home) = std::env::home_dir()
|
||||||
|
{
|
||||||
|
// Finder launches the bundled process from the filesystem root.
|
||||||
|
std::env::set_current_dir(home)?;
|
||||||
|
}
|
||||||
|
let session = if let Some(id) = attach {
|
||||||
|
SessionTarget::Attach(id)
|
||||||
|
} else {
|
||||||
|
SessionTarget::New {
|
||||||
|
cwd: if cwd.is_some() {
|
||||||
|
cwd
|
||||||
|
} else if remote.is_none() && matches!(role, "gui" | "launch") {
|
||||||
|
std::env::current_dir()?.into_os_string().into_string().ok()
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
},
|
||||||
|
}
|
||||||
|
};
|
||||||
|
if role == "launch"
|
||||||
|
&& let Some(destination) = &remote
|
||||||
|
&& let Some(origin) = session::PaneContext::from_env()?
|
||||||
|
{
|
||||||
|
if let Some(explicit) = &socket
|
||||||
|
&& explicit.canonicalize()? != origin.socket.canonicalize()?
|
||||||
|
{
|
||||||
|
bail!("--socket points outside the invoking psyTerm pane");
|
||||||
|
}
|
||||||
|
launcher::control(
|
||||||
|
&origin.socket,
|
||||||
|
protocol::ClientMessage::OpenRemoteTab {
|
||||||
|
session: origin.session,
|
||||||
|
pane: origin.pane,
|
||||||
|
destination: destination.clone(),
|
||||||
|
target: session,
|
||||||
|
ssh: protocol::SshOptions::from_env(),
|
||||||
|
},
|
||||||
|
)?;
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
|
||||||
let socket = socket.map(Ok).unwrap_or_else(launcher::default_socket)?;
|
let socket = socket.map(Ok).unwrap_or_else(launcher::default_socket)?;
|
||||||
match role {
|
match role {
|
||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
"server" => server::run(&socket, |remote| launcher::open_window(&socket, remote)),
|
"server" => server::run(&socket, |remote, session| {
|
||||||
|
launcher::open_window(&socket, remote, session)
|
||||||
|
}),
|
||||||
#[cfg(target_os = "linux")]
|
#[cfg(target_os = "linux")]
|
||||||
"server" => {
|
"server" => {
|
||||||
let zygote_socket = socket.clone();
|
let zygote_socket = socket.clone();
|
||||||
let mut zygote: Option<launcher::zygote::Zygote> = None;
|
let mut zygote: Option<launcher::zygote::Zygote> = None;
|
||||||
server::run(&socket, move |remote| {
|
server::run(&socket, move |remote, session| {
|
||||||
if zygote.is_none() {
|
if zygote.is_none() {
|
||||||
zygote = Some(launcher::zygote::Zygote::start(&zygote_socket)?);
|
zygote = Some(launcher::zygote::Zygote::start(&zygote_socket)?);
|
||||||
}
|
}
|
||||||
zygote.as_mut().unwrap().open_window(remote)
|
zygote.as_mut().unwrap().open_window(remote, session)
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
#[cfg(target_os = "linux")]
|
#[cfg(target_os = "linux")]
|
||||||
"zygote" => launcher::zygote::run_zygote(&socket),
|
"zygote" => launcher::zygote::run_zygote(&socket),
|
||||||
"gui" => {
|
// Check remote attach synchronously so a failed SSH/session lookup reaches the CLI.
|
||||||
#[cfg(target_os = "macos")]
|
"gui" | "launch"
|
||||||
{
|
if cfg!(target_os = "macos")
|
||||||
// LaunchServices starts Finder-launched apps in / with launchd as parent.
|
|| role == "gui"
|
||||||
// Give that first shell a useful directory while preserving CLI launch paths.
|
|| (remote.is_some() && attach.is_some()) =>
|
||||||
// SAFETY: getppid has no preconditions.
|
{
|
||||||
if unsafe { libc::getppid() } == 1
|
if remote.is_none() && attach.is_some() {
|
||||||
&& std::env::current_dir()? == std::path::Path::new("/")
|
launcher::require_server(&socket)?;
|
||||||
&& let Some(home) = std::env::home_dir()
|
} else {
|
||||||
{
|
launcher::ensure_server(&socket)?;
|
||||||
std::env::set_current_dir(home)?;
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
launcher::ensure_server(&socket)?;
|
run_gui(socket, remote, session)
|
||||||
run_gui(socket, remote)
|
|
||||||
}
|
}
|
||||||
"bridge" => client::bridge(&socket),
|
"bridge" => client::bridge(&socket, attach.is_some()),
|
||||||
"shutdown" => {
|
"shutdown" => {
|
||||||
launcher::control(&socket, protocol::ClientMessage::Shutdown)?;
|
launcher::control(&socket, protocol::ClientMessage::Shutdown)?;
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
"list" => list_sessions(&socket),
|
"list" => list_sessions(&socket),
|
||||||
_ => {
|
_ => {
|
||||||
launcher::ensure_server(&socket)?;
|
if attach.is_some() {
|
||||||
|
launcher::require_server(&socket)?;
|
||||||
|
} else {
|
||||||
|
launcher::ensure_server(&socket)?;
|
||||||
|
}
|
||||||
launcher::control(
|
launcher::control(
|
||||||
&socket,
|
&socket,
|
||||||
protocol::ClientMessage::OpenWindow { target: remote },
|
protocol::ClientMessage::OpenWindow {
|
||||||
|
target: remote,
|
||||||
|
session,
|
||||||
|
},
|
||||||
)?;
|
)?;
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
@@ -116,44 +184,34 @@ fn main() -> Result<()> {
|
|||||||
}
|
}
|
||||||
|
|
||||||
fn list_sessions(socket: &std::path::Path) -> Result<()> {
|
fn list_sessions(socket: &std::path::Path) -> Result<()> {
|
||||||
let mut stream = std::os::unix::net::UnixStream::connect(socket)?;
|
let response = launcher::control(socket, protocol::ClientMessage::ListSessions)?;
|
||||||
launcher::verify_peer(&stream)?;
|
let protocol::ServerMessage::Sessions(sessions) = response else {
|
||||||
stream.set_read_timeout(Some(std::time::Duration::from_secs(5)))?;
|
bail!("expected session list");
|
||||||
protocol::write_message(
|
};
|
||||||
&mut stream,
|
for session in sessions {
|
||||||
&protocol::ClientMessage::Hello {
|
println!("session {} ({} attached)", session.id, session.attached);
|
||||||
version: protocol::VERSION,
|
for tab in session.tabs {
|
||||||
},
|
println!("tab {} {} panes {:?}", tab.id, tab.title, tab.panes);
|
||||||
)?;
|
for (index, stack) in tab.stacks.iter().enumerate() {
|
||||||
let hello: protocol::ServerMessage = protocol::read_message(&mut stream)?;
|
println!(
|
||||||
println!("{hello:?}");
|
" stack {} expanded {} panes {:?}",
|
||||||
protocol::write_message(&mut stream, &protocol::ClientMessage::List)?;
|
index + 1,
|
||||||
loop {
|
stack.active_pane,
|
||||||
match protocol::read_message(&mut stream)? {
|
stack.panes.iter().map(|pane| pane.id).collect::<Vec<_>>()
|
||||||
protocol::ServerMessage::Snapshot(snapshot) => {
|
);
|
||||||
for tab in snapshot.tabs {
|
|
||||||
println!("tab {} {} panes {:?}", tab.id, tab.title, tab.panes);
|
|
||||||
for (index, stack) in tab.stacks.iter().enumerate() {
|
|
||||||
println!(
|
|
||||||
" stack {} expanded {} panes {:?}",
|
|
||||||
index + 1,
|
|
||||||
stack.active_pane,
|
|
||||||
stack.panes.iter().map(|pane| pane.id).collect::<Vec<_>>()
|
|
||||||
);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
}
|
||||||
protocol::ServerMessage::Error(error) => bail!("{error}"),
|
|
||||||
_ => {}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Initialize GPUI on the main thread of the GUI process.
|
/// Initialize GPUI on the main thread of the GUI process.
|
||||||
pub(crate) fn run_gui(socket: PathBuf, remote: Option<String>) -> Result<()> {
|
pub(crate) fn run_gui(
|
||||||
let (client, updates) = client::Client::connect(&socket, remote.as_deref())?;
|
socket: PathBuf,
|
||||||
|
remote: Option<String>,
|
||||||
|
session: SessionTarget,
|
||||||
|
) -> Result<()> {
|
||||||
|
let (client, updates) = client::Client::connect(&socket, remote.as_deref(), session)?;
|
||||||
let connection: SharedString = remote
|
let connection: SharedString = remote
|
||||||
.map(|host| format!("SSH · {host}"))
|
.map(|host| format!("SSH · {host}"))
|
||||||
.unwrap_or_else(|| "Local".into())
|
.unwrap_or_else(|| "Local".into())
|
||||||
@@ -162,11 +220,20 @@ pub(crate) fn run_gui(socket: PathBuf, remote: Option<String>) -> Result<()> {
|
|||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
{
|
{
|
||||||
cx.on_action(|_: &Quit, cx| cx.quit());
|
cx.on_action(|_: &Quit, cx| cx.quit());
|
||||||
cx.bind_keys([KeyBinding::new("cmd-q", Quit, None)]);
|
cx.bind_keys([
|
||||||
cx.set_menus(vec![Menu {
|
KeyBinding::new("cmd-q", Quit, None),
|
||||||
name: "psyTerm".into(),
|
KeyBinding::new("cmd-n", NewWindow, None),
|
||||||
items: vec![MenuItem::action("Quit psyTerm", Quit)],
|
]);
|
||||||
}]);
|
cx.set_menus(vec![
|
||||||
|
Menu {
|
||||||
|
name: "psyTerm".into(),
|
||||||
|
items: vec![MenuItem::action("Quit psyTerm", Quit)],
|
||||||
|
},
|
||||||
|
Menu {
|
||||||
|
name: "File".into(),
|
||||||
|
items: vec![MenuItem::action("New Window", NewWindow)],
|
||||||
|
},
|
||||||
|
]);
|
||||||
}
|
}
|
||||||
cx.on_window_closed(|cx| {
|
cx.on_window_closed(|cx| {
|
||||||
if cx.windows().is_empty() {
|
if cx.windows().is_empty() {
|
||||||
|
|||||||
+63
-3
@@ -10,10 +10,37 @@ use anyhow::{Context, Result, bail};
|
|||||||
use bincode::Options;
|
use bincode::Options;
|
||||||
use serde::{Deserialize, Serialize, de::DeserializeOwned};
|
use serde::{Deserialize, Serialize, de::DeserializeOwned};
|
||||||
|
|
||||||
pub const VERSION: u32 = 4;
|
pub const VERSION: u32 = 6;
|
||||||
pub const MAX_MESSAGE_BYTES: usize = 16 * 1024 * 1024;
|
pub const MAX_MESSAGE_BYTES: usize = 16 * 1024 * 1024;
|
||||||
pub type PaneId = u64;
|
pub type PaneId = u64;
|
||||||
pub type TabId = u64;
|
pub type TabId = u64;
|
||||||
|
pub type SessionId = u64;
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Copy, Hash, Eq, PartialEq, Ord, PartialOrd, Serialize, Deserialize)]
|
||||||
|
pub struct SessionIdentity {
|
||||||
|
pub server: [u8; 16],
|
||||||
|
pub session: SessionId,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||||
|
pub enum SessionTarget {
|
||||||
|
New { cwd: Option<String> },
|
||||||
|
Attach(Option<SessionId>),
|
||||||
|
}
|
||||||
|
|
||||||
|
/// SSH settings inherited from the shell that requested a remote tab.
|
||||||
|
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
|
||||||
|
pub struct SshOptions {
|
||||||
|
pub executable: Option<String>,
|
||||||
|
pub agent_socket: Option<std::path::PathBuf>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||||
|
pub struct SessionInfo {
|
||||||
|
pub id: SessionId,
|
||||||
|
pub attached: usize,
|
||||||
|
pub tabs: Vec<TabInfo>,
|
||||||
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||||
// Keep variants append-only: the shutdown command can retire an older server.
|
// Keep variants append-only: the shutdown command can retire an older server.
|
||||||
@@ -21,7 +48,7 @@ pub enum ClientMessage {
|
|||||||
Hello {
|
Hello {
|
||||||
version: u32,
|
version: u32,
|
||||||
},
|
},
|
||||||
Attach,
|
Connect(SessionTarget),
|
||||||
Input {
|
Input {
|
||||||
pane: PaneId,
|
pane: PaneId,
|
||||||
bytes: Vec<u8>,
|
bytes: Vec<u8>,
|
||||||
@@ -62,11 +89,12 @@ pub enum ClientMessage {
|
|||||||
},
|
},
|
||||||
OpenWindow {
|
OpenWindow {
|
||||||
target: Option<String>,
|
target: Option<String>,
|
||||||
|
session: SessionTarget,
|
||||||
},
|
},
|
||||||
Detach,
|
Detach,
|
||||||
Shutdown,
|
Shutdown,
|
||||||
Ping,
|
Ping,
|
||||||
/// Read current layout without attaching or creating a shell.
|
/// Inspect the layout of the session this client has joined.
|
||||||
List,
|
List,
|
||||||
/// A blank/absent name returns to program-title/CWD naming.
|
/// A blank/absent name returns to program-title/CWD naming.
|
||||||
RenamePane {
|
RenamePane {
|
||||||
@@ -101,6 +129,17 @@ pub enum ClientMessage {
|
|||||||
tab: TabId,
|
tab: TabId,
|
||||||
name: Option<String>,
|
name: Option<String>,
|
||||||
},
|
},
|
||||||
|
ListSessions,
|
||||||
|
OpenRemoteTab {
|
||||||
|
session: SessionIdentity,
|
||||||
|
pane: PaneId,
|
||||||
|
destination: String,
|
||||||
|
target: SessionTarget,
|
||||||
|
ssh: SshOptions,
|
||||||
|
},
|
||||||
|
ClosePendingTab {
|
||||||
|
tab: TabId,
|
||||||
|
},
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
@@ -164,10 +203,14 @@ pub enum ServerMessage {
|
|||||||
Error(String),
|
Error(String),
|
||||||
Pong,
|
Pong,
|
||||||
Closing,
|
Closing,
|
||||||
|
Connected { session: SessionId },
|
||||||
|
Sessions(Vec<SessionInfo>),
|
||||||
}
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||||
pub struct Snapshot {
|
pub struct Snapshot {
|
||||||
|
/// This session and the other sessions contributing tabs to its layout.
|
||||||
|
pub lineage: Vec<SessionIdentity>,
|
||||||
pub revision: u64,
|
pub revision: u64,
|
||||||
pub tabs: Vec<TabInfo>,
|
pub tabs: Vec<TabInfo>,
|
||||||
pub active_tab: TabId,
|
pub active_tab: TabId,
|
||||||
@@ -175,9 +218,17 @@ pub struct Snapshot {
|
|||||||
pub panes: Vec<PaneSnapshot>,
|
pub panes: Vec<PaneSnapshot>,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl Snapshot {
|
||||||
|
pub fn active_tab(&self) -> Option<&TabInfo> {
|
||||||
|
self.tabs.iter().find(|tab| tab.id == self.active_tab)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
pub struct TabInfo {
|
pub struct TabInfo {
|
||||||
pub id: TabId,
|
pub id: TabId,
|
||||||
|
/// SSH destination for a tab mounted from another host.
|
||||||
|
pub remote: Option<String>,
|
||||||
/// Effective display name: manual override, then the selected pane's name.
|
/// Effective display name: manual override, then the selected pane's name.
|
||||||
pub title: String,
|
pub title: String,
|
||||||
pub manual_title: Option<String>,
|
pub manual_title: Option<String>,
|
||||||
@@ -188,6 +239,15 @@ pub struct TabInfo {
|
|||||||
pub stacks: Vec<StackInfo>,
|
pub stacks: Vec<StackInfo>,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
impl TabInfo {
|
||||||
|
pub fn is_connecting(&self) -> bool {
|
||||||
|
self.remote.is_some()
|
||||||
|
&& self.panes.is_empty()
|
||||||
|
&& self.stacks.is_empty()
|
||||||
|
&& self.active_pane == 0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
|
||||||
pub struct StackInfo {
|
pub struct StackInfo {
|
||||||
pub panes: Vec<StackPaneInfo>,
|
pub panes: Vec<StackPaneInfo>,
|
||||||
|
|||||||
+506
-126
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,743 @@
|
|||||||
|
//! Mirror an SSH session into its parent session's tab bar. The SSH host owns
|
||||||
|
//! its PTYs and layout. IDs in each mirror are independent of both daemons.
|
||||||
|
use super::*;
|
||||||
|
use crate::client::{Client as Transport, Update};
|
||||||
|
use std::sync::{
|
||||||
|
Weak,
|
||||||
|
atomic::{AtomicBool, Ordering},
|
||||||
|
};
|
||||||
|
|
||||||
|
pub(super) enum RemoteEvent {
|
||||||
|
Connected(Transport),
|
||||||
|
Updated(Update),
|
||||||
|
Ended(Option<String>),
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) struct RemoteSession {
|
||||||
|
destination: String,
|
||||||
|
anchor: TabId,
|
||||||
|
slot: TabId,
|
||||||
|
cancelled: Arc<AtomicBool>,
|
||||||
|
connection: Option<Transport>,
|
||||||
|
// Remote IDs map to stable IDs allocated from the parent session's pool.
|
||||||
|
tabs: HashMap<TabId, TabId>,
|
||||||
|
panes: HashMap<PaneId, PaneId>,
|
||||||
|
latest: Option<Arc<Snapshot>>,
|
||||||
|
requested_tab: Option<TabId>,
|
||||||
|
clipboard: VecDeque<(PaneId, Weak<Outbox>)>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Drop for RemoteSession {
|
||||||
|
fn drop(&mut self) {
|
||||||
|
self.cancelled.store(true, Ordering::Release);
|
||||||
|
self.cancel_copies();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn original(ids: &HashMap<u64, u64>, local: u64) -> Option<u64> {
|
||||||
|
ids.iter()
|
||||||
|
.find_map(|(&remote, &id)| (id == local).then_some(remote))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn mapped(ids: &mut HashMap<u64, u64>, remote: u64, next: &mut u64) -> u64 {
|
||||||
|
*ids.entry(remote).or_insert_with(|| {
|
||||||
|
let id = *next;
|
||||||
|
*next += 1;
|
||||||
|
id
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
impl RemoteSession {
|
||||||
|
pub(super) fn owns_tab(&self, local: TabId) -> bool {
|
||||||
|
(self.latest.is_none() && self.slot == local) || original(&self.tabs, local).is_some()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn send(&self, command: ClientMessage) -> Result<()> {
|
||||||
|
self.connection
|
||||||
|
.as_ref()
|
||||||
|
.context("SSH session is connecting")?
|
||||||
|
.send(command)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Keep one copy in flight on this connection. An attached session can
|
||||||
|
// contain multiple SSH hosts whose clipboard replies arrive out of order.
|
||||||
|
fn copy(&mut self, pane: PaneId, output: &Arc<Outbox>) -> Result<()> {
|
||||||
|
if self.clipboard.len() >= 16 {
|
||||||
|
output.reliable(ServerMessage::Clipboard(String::new()));
|
||||||
|
anyhow::bail!("too many pending clipboard requests");
|
||||||
|
}
|
||||||
|
self.clipboard.push_back((pane, Arc::downgrade(output)));
|
||||||
|
if self.clipboard.len() == 1 {
|
||||||
|
self.send_next_copy()?;
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn finish_copy(&mut self, text: String) -> Result<()> {
|
||||||
|
if let Some((_, output)) = self.clipboard.pop_front()
|
||||||
|
&& let Some(output) = output.upgrade()
|
||||||
|
{
|
||||||
|
output.reliable(ServerMessage::Clipboard(text));
|
||||||
|
}
|
||||||
|
self.send_next_copy()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn send_next_copy(&mut self) -> Result<()> {
|
||||||
|
if let Some(&(pane, _)) = self.clipboard.front()
|
||||||
|
&& let Err(error) = self.send(ClientMessage::Copy { pane })
|
||||||
|
{
|
||||||
|
self.cancel_copies();
|
||||||
|
return Err(error);
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn cancel_copies(&mut self) {
|
||||||
|
for (_, output) in self.clipboard.drain(..) {
|
||||||
|
if let Some(output) = output.upgrade() {
|
||||||
|
output.reliable(ServerMessage::Clipboard(String::new()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn visible_panes(&self, local: TabId) -> Vec<PaneSnapshot> {
|
||||||
|
self.latest
|
||||||
|
.as_ref()
|
||||||
|
.filter(|s| self.tabs.get(&s.active_tab) == Some(&local))
|
||||||
|
.map(|s| {
|
||||||
|
s.panes
|
||||||
|
.iter()
|
||||||
|
.filter_map(|pane| {
|
||||||
|
let mut copy = pane.clone();
|
||||||
|
copy.id = *self.panes.get(&pane.id)?;
|
||||||
|
Some(copy)
|
||||||
|
})
|
||||||
|
.collect()
|
||||||
|
})
|
||||||
|
.unwrap_or_default()
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reconcile a whole remote session, including other tabs that may already
|
||||||
|
/// exist when explicitly attaching. Only the active remote tab has grids.
|
||||||
|
fn apply(
|
||||||
|
&mut self,
|
||||||
|
snapshot: Arc<Snapshot>,
|
||||||
|
tabs: &mut Vec<TabInfo>,
|
||||||
|
active: &mut TabId,
|
||||||
|
next: &mut u64,
|
||||||
|
) -> Result<bool> {
|
||||||
|
let first = self.latest.is_none();
|
||||||
|
let selected = self.owns_tab(*active);
|
||||||
|
if self.latest.as_ref().is_some_and(|old| {
|
||||||
|
old.tabs == snapshot.tabs
|
||||||
|
&& old.active_tab == snapshot.active_tab
|
||||||
|
&& old.lineage == snapshot.lineage
|
||||||
|
}) {
|
||||||
|
if self.requested_tab == Some(snapshot.active_tab) {
|
||||||
|
self.requested_tab = None;
|
||||||
|
}
|
||||||
|
self.latest = Some(snapshot);
|
||||||
|
return Ok(selected);
|
||||||
|
}
|
||||||
|
let index = tabs
|
||||||
|
.iter()
|
||||||
|
.position(|tab| self.owns_tab(tab.id))
|
||||||
|
.context("SSH tab has closed")?;
|
||||||
|
let previous_count = if first { 1 } else { self.tabs.len() };
|
||||||
|
ensure!(
|
||||||
|
tabs.len() - previous_count + snapshot.tabs.len() <= 256,
|
||||||
|
"a window supports at most 256 tabs"
|
||||||
|
);
|
||||||
|
let mut new_tab_ids = self.tabs.clone();
|
||||||
|
let mut new_pane_ids = self.panes.clone();
|
||||||
|
new_tab_ids.retain(|id, _| snapshot.tabs.iter().any(|tab| tab.id == *id));
|
||||||
|
new_pane_ids.retain(|id, _| snapshot.tabs.iter().any(|tab| tab.panes.contains(id)));
|
||||||
|
if first && !snapshot.tabs.is_empty() {
|
||||||
|
new_tab_ids.insert(snapshot.active_tab, self.slot);
|
||||||
|
}
|
||||||
|
let mut mapped_tabs = snapshot.tabs.clone();
|
||||||
|
for tab in &mut mapped_tabs {
|
||||||
|
tab.id = mapped(&mut new_tab_ids, tab.id, next);
|
||||||
|
if tab.remote.is_none() {
|
||||||
|
tab.remote = Some(self.destination.clone());
|
||||||
|
}
|
||||||
|
for pane in &mut tab.panes {
|
||||||
|
*pane = mapped(&mut new_pane_ids, *pane, next);
|
||||||
|
}
|
||||||
|
if tab.panes.is_empty() {
|
||||||
|
continue; // Nested SSH connection still establishing its first shell.
|
||||||
|
}
|
||||||
|
tab.active_pane = *new_pane_ids
|
||||||
|
.get(&tab.active_pane)
|
||||||
|
.context("invalid active SSH pane")?;
|
||||||
|
for stack in &mut tab.stacks {
|
||||||
|
stack.active_pane = *new_pane_ids
|
||||||
|
.get(&stack.active_pane)
|
||||||
|
.context("invalid SSH stack")?;
|
||||||
|
for pane in &mut stack.panes {
|
||||||
|
pane.id = *new_pane_ids.get(&pane.id).context("invalid SSH pane")?;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let remote_active = if snapshot.tabs.is_empty() {
|
||||||
|
0
|
||||||
|
} else {
|
||||||
|
*new_tab_ids
|
||||||
|
.get(&snapshot.active_tab)
|
||||||
|
.context("invalid active SSH tab")?
|
||||||
|
};
|
||||||
|
self.tabs = new_tab_ids;
|
||||||
|
self.panes = new_pane_ids;
|
||||||
|
let changed = tabs[index..index + previous_count] != mapped_tabs;
|
||||||
|
if changed {
|
||||||
|
tabs.splice(index..index + previous_count, mapped_tabs);
|
||||||
|
}
|
||||||
|
if !snapshot.tabs.is_empty() {
|
||||||
|
// Ignore intermediate focus acknowledgements when a user cycles
|
||||||
|
// tabs several times before an SSH round trip finishes.
|
||||||
|
if self
|
||||||
|
.requested_tab
|
||||||
|
.is_some_and(|id| id == snapshot.active_tab || !self.tabs.contains_key(&id))
|
||||||
|
{
|
||||||
|
self.requested_tab = None;
|
||||||
|
}
|
||||||
|
if selected && self.requested_tab.is_none() {
|
||||||
|
*active = remote_active;
|
||||||
|
}
|
||||||
|
} else if selected {
|
||||||
|
*active = tabs
|
||||||
|
.get(index.min(tabs.len().saturating_sub(1)))
|
||||||
|
.map_or(0, |tab| tab.id);
|
||||||
|
}
|
||||||
|
let ancestry_changed = self
|
||||||
|
.latest
|
||||||
|
.as_ref()
|
||||||
|
.is_none_or(|old| old.lineage != snapshot.lineage);
|
||||||
|
self.latest = Some(snapshot);
|
||||||
|
Ok(changed || selected || first || ancestry_changed)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl SessionState {
|
||||||
|
/// Propagate identities through nested SSH connections. This also catches
|
||||||
|
/// a user attaching a localhost SSH tab to its own parent session.
|
||||||
|
pub(super) fn lineage(&self) -> Vec<SessionIdentity> {
|
||||||
|
let descendants = self
|
||||||
|
.remotes
|
||||||
|
.values()
|
||||||
|
.filter_map(|remote| remote.latest.as_ref())
|
||||||
|
.flat_map(|snapshot| snapshot.lineage.iter().copied())
|
||||||
|
.collect::<BTreeSet<_>>();
|
||||||
|
std::iter::once(self.identity).chain(descendants).collect()
|
||||||
|
}
|
||||||
|
|
||||||
|
fn check_lineage(&self, group: u64, incoming: &[SessionIdentity]) -> Result<()> {
|
||||||
|
ensure!(
|
||||||
|
!incoming.is_empty() && !incoming.contains(&self.identity),
|
||||||
|
"cannot attach an SSH session inside itself"
|
||||||
|
);
|
||||||
|
let count = self
|
||||||
|
.remotes
|
||||||
|
.iter()
|
||||||
|
.filter(|(id, _)| **id != group)
|
||||||
|
.filter_map(|(_, remote)| remote.latest.as_ref())
|
||||||
|
.flat_map(|snapshot| &snapshot.lineage)
|
||||||
|
.chain(incoming)
|
||||||
|
.collect::<BTreeSet<_>>()
|
||||||
|
.len();
|
||||||
|
ensure!(count < 256, "too many nested SSH sessions");
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
pub(super) fn is_live(&self) -> bool {
|
||||||
|
!self.tabs.is_empty() || !self.remotes.is_empty()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn open_remote(
|
||||||
|
&mut self,
|
||||||
|
pane: PaneId,
|
||||||
|
destination: String,
|
||||||
|
target: SessionTarget,
|
||||||
|
ssh: SshOptions,
|
||||||
|
) -> Result<()> {
|
||||||
|
crate::client::validate_destination(&destination)?;
|
||||||
|
ensure!(
|
||||||
|
self.panes.contains_key(&pane),
|
||||||
|
"originating shell has ended"
|
||||||
|
);
|
||||||
|
ensure!(
|
||||||
|
self.remotes.len() < MAX_PANES && self.tabs.len() < 256,
|
||||||
|
"too many SSH sessions or tabs"
|
||||||
|
);
|
||||||
|
let (index, _, _) = self.pane_position(pane)?;
|
||||||
|
let group = self.next_id;
|
||||||
|
self.next_id += 1;
|
||||||
|
let socket = self.socket.clone();
|
||||||
|
let session = self.id;
|
||||||
|
let sender = self.sender.clone();
|
||||||
|
let dest = destination.clone();
|
||||||
|
let cancelled = Arc::new(AtomicBool::new(false));
|
||||||
|
let worker_cancelled = cancelled.clone();
|
||||||
|
thread::Builder::new()
|
||||||
|
.name("psyterm-remote-tab".into())
|
||||||
|
.spawn(move || {
|
||||||
|
// Permit one outstanding actor update per connection. The
|
||||||
|
// transport coalesces newer grids while the actor is busy.
|
||||||
|
let notify = |event| {
|
||||||
|
let (ack, processed) = mpsc::channel();
|
||||||
|
sender
|
||||||
|
.send(Action::Remote(session, group, event, ack))
|
||||||
|
.is_ok()
|
||||||
|
&& processed.recv().is_ok()
|
||||||
|
};
|
||||||
|
match Transport::connect_remote(&socket, &dest, target, ssh, worker_cancelled) {
|
||||||
|
Ok((client, updates)) => {
|
||||||
|
// Ownership of the transport moves to the server actor so
|
||||||
|
// dropping a mirror also tears down its SSH child/reader.
|
||||||
|
if !notify(RemoteEvent::Connected(client)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
while let Some(update) = updates.recv_blocking() {
|
||||||
|
let closed = update.disconnected;
|
||||||
|
if !notify(RemoteEvent::Updated(update)) || closed {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
notify(RemoteEvent::Ended(None));
|
||||||
|
}
|
||||||
|
Err(error) => {
|
||||||
|
notify(RemoteEvent::Ended(Some(format!(
|
||||||
|
"Could not connect to {dest}: {error:#}"
|
||||||
|
))));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})?;
|
||||||
|
self.insert_remote_slot(index, group, destination, cancelled);
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn insert_remote_slot(
|
||||||
|
&mut self,
|
||||||
|
index: usize,
|
||||||
|
group: u64,
|
||||||
|
destination: String,
|
||||||
|
cancelled: Arc<AtomicBool>,
|
||||||
|
) {
|
||||||
|
let anchor = self.tabs[index].id;
|
||||||
|
self.tabs.insert(
|
||||||
|
index + 1,
|
||||||
|
TabInfo {
|
||||||
|
id: group,
|
||||||
|
title: "Connecting…".into(),
|
||||||
|
remote: Some(destination.clone()),
|
||||||
|
manual_title: None,
|
||||||
|
panes: Vec::new(),
|
||||||
|
active_pane: 0,
|
||||||
|
stacks: Vec::new(),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
if self.active_tab == anchor {
|
||||||
|
self.active_tab = group;
|
||||||
|
}
|
||||||
|
self.dirty = true;
|
||||||
|
self.remotes.insert(
|
||||||
|
group,
|
||||||
|
RemoteSession {
|
||||||
|
destination,
|
||||||
|
anchor,
|
||||||
|
slot: group,
|
||||||
|
cancelled,
|
||||||
|
connection: None,
|
||||||
|
tabs: HashMap::new(),
|
||||||
|
panes: HashMap::new(),
|
||||||
|
latest: None,
|
||||||
|
requested_tab: None,
|
||||||
|
clipboard: VecDeque::new(),
|
||||||
|
},
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn cancel_pending_tab(&mut self, tab: TabId) -> Result<()> {
|
||||||
|
if self
|
||||||
|
.remotes
|
||||||
|
.get(&tab)
|
||||||
|
.is_some_and(|remote| remote.latest.is_none())
|
||||||
|
{
|
||||||
|
self.remove_remote(tab);
|
||||||
|
return Ok(());
|
||||||
|
}
|
||||||
|
if let Some((remote, id)) = self
|
||||||
|
.remotes
|
||||||
|
.values()
|
||||||
|
.find_map(|remote| original(&remote.tabs, tab).map(|id| (remote, id)))
|
||||||
|
{
|
||||||
|
return remote.send(ClientMessage::ClosePendingTab { tab: id });
|
||||||
|
}
|
||||||
|
anyhow::bail!("SSH tab is no longer connecting")
|
||||||
|
}
|
||||||
|
|
||||||
|
fn remove_remote(&mut self, group: u64) {
|
||||||
|
let Some(remote) = self.remotes.remove(&group) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
let index = self
|
||||||
|
.tabs
|
||||||
|
.iter()
|
||||||
|
.position(|tab| remote.owns_tab(tab.id))
|
||||||
|
.unwrap_or(0);
|
||||||
|
self.tabs.retain(|tab| !remote.owns_tab(tab.id));
|
||||||
|
if remote.owns_tab(self.active_tab) {
|
||||||
|
self.active_tab = self
|
||||||
|
.tabs
|
||||||
|
.iter()
|
||||||
|
.find(|tab| remote.latest.is_none() && tab.id == remote.anchor)
|
||||||
|
.or_else(|| self.tabs.get(index.min(self.tabs.len().saturating_sub(1))))
|
||||||
|
.map_or(0, |tab| tab.id);
|
||||||
|
}
|
||||||
|
if self.active_tab != 0 {
|
||||||
|
let _ = self.focus_tab(self.active_tab);
|
||||||
|
}
|
||||||
|
self.dirty = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn focus_tab(&mut self, tab: TabId) -> Result<()> {
|
||||||
|
ensure!(self.tabs.iter().any(|entry| entry.id == tab), "unknown tab");
|
||||||
|
if let Some((remote, original)) = self
|
||||||
|
.remotes
|
||||||
|
.values_mut()
|
||||||
|
.find_map(|remote| original(&remote.tabs, tab).map(|id| (remote, id)))
|
||||||
|
&& (remote.requested_tab.is_some()
|
||||||
|
|| remote
|
||||||
|
.latest
|
||||||
|
.as_ref()
|
||||||
|
.is_none_or(|s| s.active_tab != original))
|
||||||
|
{
|
||||||
|
remote.send(ClientMessage::FocusTab { tab: original })?;
|
||||||
|
remote.requested_tab = Some(original);
|
||||||
|
}
|
||||||
|
self.active_tab = tab;
|
||||||
|
self.dirty = true;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(super) fn remote_pane(&mut self, pane: PaneId) -> Option<(&mut RemoteSession, PaneId)> {
|
||||||
|
self.remotes
|
||||||
|
.values_mut()
|
||||||
|
.find_map(|remote| original(&remote.panes, pane).map(|id| (remote, id)))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Absolute pane actions use the pane's owner even if an older frame is
|
||||||
|
/// being acted on. Relative navigation is resolved in the mixed tab order.
|
||||||
|
pub(super) fn route_command(
|
||||||
|
&mut self,
|
||||||
|
mut command: ClientMessage,
|
||||||
|
output: &Arc<Outbox>,
|
||||||
|
) -> Result<Option<ClientMessage>> {
|
||||||
|
use ClientMessage::*;
|
||||||
|
let remote = match &mut command {
|
||||||
|
RenameTab { tab, .. } => self.remotes.values_mut().find_map(|remote| {
|
||||||
|
*tab = original(&remote.tabs, *tab)?;
|
||||||
|
Some(remote)
|
||||||
|
}),
|
||||||
|
NewStackPane { pane, .. } => {
|
||||||
|
let Some(local) = (*pane).or_else(|| {
|
||||||
|
self.tabs
|
||||||
|
.iter()
|
||||||
|
.find(|t| t.id == self.active_tab)
|
||||||
|
.map(|t| t.active_pane)
|
||||||
|
}) else {
|
||||||
|
return Ok(Some(command));
|
||||||
|
};
|
||||||
|
self.remote_pane(local).map(|(remote, original)| {
|
||||||
|
*pane = Some(original);
|
||||||
|
remote
|
||||||
|
})
|
||||||
|
}
|
||||||
|
Input { pane, .. }
|
||||||
|
| Resize { pane, .. }
|
||||||
|
| Selection { pane, .. }
|
||||||
|
| Copy { pane }
|
||||||
|
| Scroll { pane, .. }
|
||||||
|
| Split { pane, .. }
|
||||||
|
| ClosePane { pane }
|
||||||
|
| RenamePane { pane, .. } => self.remote_pane(*pane).map(|(remote, original)| {
|
||||||
|
*pane = original;
|
||||||
|
remote
|
||||||
|
}),
|
||||||
|
_ => None,
|
||||||
|
};
|
||||||
|
let Some(remote) = remote else {
|
||||||
|
return Ok(Some(command));
|
||||||
|
};
|
||||||
|
if let Copy { pane } = command {
|
||||||
|
remote.copy(pane, output)?;
|
||||||
|
} else {
|
||||||
|
remote.send(command)?;
|
||||||
|
}
|
||||||
|
Ok(None)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl Server {
|
||||||
|
pub(super) fn remote_event(&mut self, session: SessionId, group: u64, event: RemoteEvent) {
|
||||||
|
let Some(state) = self.sessions.get_mut(&session) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
if let RemoteEvent::Updated(update) = &event
|
||||||
|
&& let Some(snapshot) = &update.snapshot
|
||||||
|
&& let Err(reason) = state.check_lineage(group, &snapshot.lineage)
|
||||||
|
{
|
||||||
|
self.remote_event(session, group, RemoteEvent::Ended(Some(reason.to_string())));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
let Some(remote) = state.remotes.get_mut(&group) else {
|
||||||
|
return;
|
||||||
|
};
|
||||||
|
let (closed, error) = match event {
|
||||||
|
RemoteEvent::Connected(client) => {
|
||||||
|
remote.connection = Some(client);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
RemoteEvent::Ended(error) => (true, error),
|
||||||
|
RemoteEvent::Updated(update) => {
|
||||||
|
for text in update.clipboard {
|
||||||
|
if let Err(error) = remote.finish_copy(text) {
|
||||||
|
log::warn!("SSH clipboard: {error}");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
let mut closed = update.disconnected;
|
||||||
|
let mut error = update
|
||||||
|
.error
|
||||||
|
.map(|error| format!("{}: {error}", remote.destination));
|
||||||
|
if let Some(snapshot) = update.snapshot {
|
||||||
|
closed |= snapshot.tabs.is_empty();
|
||||||
|
match remote.apply(
|
||||||
|
snapshot,
|
||||||
|
&mut state.tabs,
|
||||||
|
&mut state.active_tab,
|
||||||
|
&mut state.next_id,
|
||||||
|
) {
|
||||||
|
Ok(changed) => state.dirty |= changed,
|
||||||
|
Err(reason) => {
|
||||||
|
closed = true;
|
||||||
|
error = Some(format!(
|
||||||
|
"Invalid layout from {}: {reason}",
|
||||||
|
remote.destination
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
(closed, error)
|
||||||
|
}
|
||||||
|
};
|
||||||
|
if closed {
|
||||||
|
state.remove_remote(group);
|
||||||
|
self.remove_empty_session(session);
|
||||||
|
}
|
||||||
|
if let Some(error) = error {
|
||||||
|
for client in self
|
||||||
|
.clients
|
||||||
|
.values()
|
||||||
|
.filter(|client| client.session == Some(session))
|
||||||
|
{
|
||||||
|
client.output.reliable(ServerMessage::Error(error.clone()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
fn session(server: u8) -> SessionState {
|
||||||
|
let (sender, _) = mpsc::sync_channel(64);
|
||||||
|
SessionState::new(
|
||||||
|
SessionIdentity {
|
||||||
|
server: [server; 16],
|
||||||
|
session: 1,
|
||||||
|
},
|
||||||
|
PathBuf::from("/tmp/psyterm-unused-test-socket"),
|
||||||
|
Some(Shell::new("/bin/sh".into(), vec![])),
|
||||||
|
sender,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn reserve(local: &mut SessionState, anchor: usize) -> TabId {
|
||||||
|
let group = local.next_id;
|
||||||
|
local.next_id += 1;
|
||||||
|
local.insert_remote_slot(
|
||||||
|
anchor,
|
||||||
|
group,
|
||||||
|
"user@work".into(),
|
||||||
|
Arc::new(AtomicBool::new(false)),
|
||||||
|
);
|
||||||
|
group
|
||||||
|
}
|
||||||
|
|
||||||
|
fn apply(local: &mut SessionState, group: u64, snapshot: Snapshot) -> Result<bool> {
|
||||||
|
local.check_lineage(group, &snapshot.lineage)?;
|
||||||
|
local.remotes.get_mut(&group).unwrap().apply(
|
||||||
|
Arc::new(snapshot),
|
||||||
|
&mut local.tabs,
|
||||||
|
&mut local.active_tab,
|
||||||
|
&mut local.next_id,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn remote_ids_remain_stable_and_do_not_collide_with_local_tabs_or_other_mirrors() {
|
||||||
|
let mut local = session(1);
|
||||||
|
let mut remote = session(2);
|
||||||
|
local.new_tab(None).unwrap();
|
||||||
|
local.new_tab(None).unwrap();
|
||||||
|
let left = local.tabs[0].clone();
|
||||||
|
let right = local.tabs[1].clone();
|
||||||
|
local.focus_tab(left.id).unwrap();
|
||||||
|
let group = reserve(&mut local, 0);
|
||||||
|
assert_eq!(local.active_tab, group);
|
||||||
|
assert!(local.snapshot().panes.is_empty());
|
||||||
|
remote.new_tab(None).unwrap();
|
||||||
|
remote.new_tab(None).unwrap();
|
||||||
|
// The peers allocated exactly the same tab/pane IDs.
|
||||||
|
assert_eq!(remote.tabs[0].id, left.id);
|
||||||
|
apply(&mut local, group, remote.snapshot()).unwrap();
|
||||||
|
assert_eq!(local.tabs[0].id, left.id);
|
||||||
|
assert_eq!(local.tabs[2].id, group);
|
||||||
|
assert_eq!(local.tabs[3].id, right.id);
|
||||||
|
assert_eq!(local.active_tab, group);
|
||||||
|
assert!(
|
||||||
|
local.tabs[1..3]
|
||||||
|
.iter()
|
||||||
|
.all(|t| t.remote.as_deref() == Some("user@work"))
|
||||||
|
);
|
||||||
|
let remote_pane = local.tabs[2].active_pane;
|
||||||
|
assert_eq!(local.snapshot().panes[0].id, remote_pane);
|
||||||
|
assert_ne!(remote_pane, right.active_pane);
|
||||||
|
let first_remote = local.tabs[1].id;
|
||||||
|
local.focus_tab(left.id).unwrap();
|
||||||
|
let second = reserve(&mut local, 0);
|
||||||
|
apply(&mut local, second, remote.snapshot()).unwrap();
|
||||||
|
assert_eq!(
|
||||||
|
local
|
||||||
|
.tabs
|
||||||
|
.iter()
|
||||||
|
.map(|t| t.id)
|
||||||
|
.collect::<BTreeSet<_>>()
|
||||||
|
.len(),
|
||||||
|
6
|
||||||
|
);
|
||||||
|
let second_pane = local.snapshot().panes[0].id;
|
||||||
|
assert_ne!(second_pane, remote_pane);
|
||||||
|
remote.tabs[0].manual_title = Some("renamed elsewhere".into());
|
||||||
|
apply(&mut local, group, remote.snapshot()).unwrap();
|
||||||
|
let renamed = local.tabs.iter().find(|t| t.id == first_remote).unwrap();
|
||||||
|
assert_eq!(renamed.title, "renamed elsewhere");
|
||||||
|
assert_eq!(local.active_tab, second);
|
||||||
|
local.remove_remote(group);
|
||||||
|
assert_eq!(local.tabs.len(), 4);
|
||||||
|
assert_eq!(local.snapshot().panes[0].id, second_pane);
|
||||||
|
local.remove_remote(second);
|
||||||
|
assert_eq!(
|
||||||
|
local.tabs.iter().map(|t| t.id).collect::<Vec<_>>(),
|
||||||
|
[left.id, right.id]
|
||||||
|
);
|
||||||
|
assert_eq!(local.active_tab, right.id);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn copies_from_different_views_are_serialized_and_disconnect_completes_waiters() {
|
||||||
|
let upstream = super::super::tests::TestServer::start();
|
||||||
|
let (client, updates) =
|
||||||
|
Transport::connect(&upstream.socket, None, SessionTarget::New { cwd: None }).unwrap();
|
||||||
|
let (frames, receive) = mpsc::channel();
|
||||||
|
thread::spawn(move || {
|
||||||
|
while let Some(update) = updates.recv_blocking() {
|
||||||
|
if frames.send(update).is_err() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
let mut local = session(1);
|
||||||
|
local.new_tab(None).unwrap();
|
||||||
|
let group = reserve(&mut local, 0);
|
||||||
|
let remote = local.remotes.get_mut(&group).unwrap();
|
||||||
|
remote.connection = Some(client);
|
||||||
|
let first = Arc::new(Outbox::default());
|
||||||
|
let second = Arc::new(Outbox::default());
|
||||||
|
remote.copy(1, &first).unwrap();
|
||||||
|
remote.copy(1, &second).unwrap();
|
||||||
|
|
||||||
|
// An ordered rename acts as a fence after the copy commands on the
|
||||||
|
// upstream wire. Only one copy should have reached that server.
|
||||||
|
remote
|
||||||
|
.send(ClientMessage::RenameTab {
|
||||||
|
tab: 2,
|
||||||
|
name: Some("fence".into()),
|
||||||
|
})
|
||||||
|
.unwrap();
|
||||||
|
let mut replies = Vec::new();
|
||||||
|
loop {
|
||||||
|
let update = receive.recv_timeout(Duration::from_secs(5)).unwrap();
|
||||||
|
replies.extend(update.clipboard);
|
||||||
|
if update
|
||||||
|
.snapshot
|
||||||
|
.is_some_and(|snapshot| snapshot.tabs[0].title == "fence")
|
||||||
|
{
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
assert_eq!(replies, [""]);
|
||||||
|
remote
|
||||||
|
.finish_copy("text for the first window".into())
|
||||||
|
.unwrap();
|
||||||
|
assert!(
|
||||||
|
matches!(first.next(), Some(ServerMessage::Clipboard(text)) if text == "text for the first window")
|
||||||
|
);
|
||||||
|
let mut remote_replied = false;
|
||||||
|
while !remote_replied {
|
||||||
|
let update = receive.recv_timeout(Duration::from_secs(5)).unwrap();
|
||||||
|
remote_replied = !update.clipboard.is_empty();
|
||||||
|
}
|
||||||
|
// An SSH disconnect while the second result is in flight must never
|
||||||
|
// direct the first window's clipboard into the second window.
|
||||||
|
local.remove_remote(group);
|
||||||
|
assert!(matches!(second.next(), Some(ServerMessage::Clipboard(text)) if text.is_empty()));
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn failed_cancelled_and_recursive_attachments_preserve_the_origin() {
|
||||||
|
let mut local = session(7);
|
||||||
|
local.new_tab(None).unwrap();
|
||||||
|
let anchor = local.active_tab;
|
||||||
|
let group = reserve(&mut local, 0);
|
||||||
|
let cancelled = local.remotes[&group].cancelled.clone();
|
||||||
|
let own_snapshot = local.snapshot();
|
||||||
|
assert!(
|
||||||
|
apply(&mut local, group, own_snapshot)
|
||||||
|
.unwrap_err()
|
||||||
|
.to_string()
|
||||||
|
.contains("inside itself")
|
||||||
|
);
|
||||||
|
local.cancel_pending_tab(group).unwrap();
|
||||||
|
assert!(cancelled.load(Ordering::Acquire));
|
||||||
|
assert_eq!(local.active_tab, anchor);
|
||||||
|
assert_eq!(local.tabs.len(), 1);
|
||||||
|
|
||||||
|
let mut upstream = session(8);
|
||||||
|
upstream.new_tab(None).unwrap();
|
||||||
|
let group = reserve(&mut local, 0);
|
||||||
|
apply(&mut local, group, upstream.snapshot()).unwrap();
|
||||||
|
assert_eq!(local.lineage(), [local.identity, upstream.identity]);
|
||||||
|
let mut cyclic = upstream.snapshot();
|
||||||
|
cyclic.lineage.push(local.identity);
|
||||||
|
assert!(apply(&mut local, group, cyclic).is_err());
|
||||||
|
let before = local.tabs.clone();
|
||||||
|
let mut broken = upstream.snapshot();
|
||||||
|
broken.tabs[0].active_pane = u64::MAX;
|
||||||
|
assert!(apply(&mut local, group, broken).is_err());
|
||||||
|
assert_eq!(local.tabs, before);
|
||||||
|
local.remove_remote(group);
|
||||||
|
assert_eq!(local.lineage(), [local.identity]);
|
||||||
|
assert_eq!(local.active_tab, anchor);
|
||||||
|
}
|
||||||
|
}
|
||||||
+112
-14
@@ -8,7 +8,9 @@ mod macos;
|
|||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
use macos::MacProcess;
|
use macos::MacProcess;
|
||||||
|
|
||||||
|
use crate::protocol::{PaneId, SessionIdentity};
|
||||||
use std::collections::HashMap;
|
use std::collections::HashMap;
|
||||||
|
use std::path::PathBuf;
|
||||||
use std::sync::Arc;
|
use std::sync::Arc;
|
||||||
use std::sync::atomic::{AtomicBool, Ordering};
|
use std::sync::atomic::{AtomicBool, Ordering};
|
||||||
use std::thread::{self, JoinHandle};
|
use std::thread::{self, JoinHandle};
|
||||||
@@ -19,7 +21,7 @@ use alacritty_terminal::grid::Dimensions;
|
|||||||
use alacritty_terminal::sync::FairMutex;
|
use alacritty_terminal::sync::FairMutex;
|
||||||
use alacritty_terminal::term::{Config, Term};
|
use alacritty_terminal::term::{Config, Term};
|
||||||
use alacritty_terminal::tty::{self, Options, Shell};
|
use alacritty_terminal::tty::{self, Options, Shell};
|
||||||
use anyhow::{Context, Result};
|
use anyhow::{Context, Result, ensure};
|
||||||
|
|
||||||
#[derive(Clone)]
|
#[derive(Clone)]
|
||||||
pub struct EventProxy {
|
pub struct EventProxy {
|
||||||
@@ -67,6 +69,77 @@ impl Dimensions for GridSize {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// The route inherited by a shell and its children, scoped to the spawning daemon.
|
||||||
|
pub(crate) struct PaneContext {
|
||||||
|
pub socket: PathBuf,
|
||||||
|
pub session: SessionIdentity,
|
||||||
|
pub pane: PaneId,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl PaneContext {
|
||||||
|
const ENV: &str = "PSYTERM_PANE";
|
||||||
|
|
||||||
|
fn encode(&self) -> Result<String> {
|
||||||
|
let socket = self
|
||||||
|
.socket
|
||||||
|
.to_str()
|
||||||
|
.context("psyTerm socket must have a UTF-8 path")?;
|
||||||
|
Ok(format!(
|
||||||
|
"{:032x}:{}:{}:{}",
|
||||||
|
u128::from_be_bytes(self.session.server),
|
||||||
|
self.session.session,
|
||||||
|
self.pane,
|
||||||
|
socket
|
||||||
|
))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn from_env() -> Result<Option<Self>> {
|
||||||
|
std::env::var_os(Self::ENV)
|
||||||
|
.map(|value| Self::decode(value.to_str().context("expected UTF-8")?))
|
||||||
|
.transpose()
|
||||||
|
.context("invalid PSYTERM_PANE")
|
||||||
|
}
|
||||||
|
|
||||||
|
fn decode(value: &str) -> Result<Self> {
|
||||||
|
let mut parts = value.splitn(4, ':');
|
||||||
|
let server =
|
||||||
|
u128::from_str_radix(parts.next().context("missing server ID")?, 16)?.to_be_bytes();
|
||||||
|
let session = parts.next().context("missing session ID")?.parse()?;
|
||||||
|
let pane = parts.next().context("missing pane ID")?.parse()?;
|
||||||
|
let socket = PathBuf::from(parts.next().context("missing socket path")?);
|
||||||
|
ensure!(socket.is_absolute(), "expected an absolute socket path");
|
||||||
|
Ok(Self {
|
||||||
|
socket,
|
||||||
|
session: SessionIdentity { server, session },
|
||||||
|
pane,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Allow a shell opened from Finder or a development build to invoke the CLI
|
||||||
|
/// by name. Shell startup files still run normally and can customize this PATH.
|
||||||
|
fn shell_path_with_cli() -> Option<String> {
|
||||||
|
use std::os::unix::fs::PermissionsExt;
|
||||||
|
|
||||||
|
let executable = std::env::current_exe().ok()?;
|
||||||
|
let directory = executable.parent()?;
|
||||||
|
if executable.file_name()? != "psyterm" {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
let path = std::env::var_os("PATH").unwrap_or_else(|| "/usr/bin:/bin".into());
|
||||||
|
let mut entries: Vec<_> = std::env::split_paths(&path).collect();
|
||||||
|
let resolved = entries.iter().map(|dir| dir.join("psyterm")).find(|file| {
|
||||||
|
file.metadata()
|
||||||
|
.is_ok_and(|meta| meta.is_file() && meta.permissions().mode() & 0o111 != 0)
|
||||||
|
});
|
||||||
|
if resolved.and_then(|file| file.canonicalize().ok()) == executable.canonicalize().ok() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
entries.retain(|entry| entry != directory);
|
||||||
|
entries.insert(0, directory.to_owned());
|
||||||
|
std::env::join_paths(entries).ok()?.into_string().ok()
|
||||||
|
}
|
||||||
|
|
||||||
pub struct Session {
|
pub struct Session {
|
||||||
pub term: Arc<FairMutex<Term<EventProxy>>>,
|
pub term: Arc<FairMutex<Term<EventProxy>>>,
|
||||||
sender: EventLoopSender,
|
sender: EventLoopSender,
|
||||||
@@ -85,24 +158,26 @@ pub struct Session {
|
|||||||
|
|
||||||
impl Session {
|
impl Session {
|
||||||
pub fn in_directory(
|
pub fn in_directory(
|
||||||
directory: Option<std::path::PathBuf>,
|
directory: Option<PathBuf>,
|
||||||
|
context: &PaneContext,
|
||||||
) -> Result<(Self, async_channel::Receiver<Event>)> {
|
) -> Result<(Self, async_channel::Receiver<Event>)> {
|
||||||
let program = std::env::var("SHELL").ok().filter(|s| !s.is_empty());
|
let program = std::env::var("SHELL").ok().filter(|s| !s.is_empty());
|
||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
let shell = macos::login_shell(program);
|
let shell = macos::login_shell(program);
|
||||||
#[cfg(not(target_os = "macos"))]
|
#[cfg(not(target_os = "macos"))]
|
||||||
let shell = Shell::new(program.unwrap_or_else(|| "/bin/sh".into()), Vec::new());
|
let shell = Shell::new(program.unwrap_or_else(|| "/bin/sh".into()), Vec::new());
|
||||||
Self::with_shell_and_directory(shell, directory)
|
Self::with_shell_and_directory(shell, directory, Some(context))
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
fn with_shell(shell: Shell) -> Result<(Self, async_channel::Receiver<Event>)> {
|
fn with_shell(shell: Shell) -> Result<(Self, async_channel::Receiver<Event>)> {
|
||||||
Self::with_shell_and_directory(shell, None)
|
Self::with_shell_and_directory(shell, None, None)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub(crate) fn with_shell_and_directory(
|
pub(crate) fn with_shell_and_directory(
|
||||||
shell: Shell,
|
shell: Shell,
|
||||||
working_directory: Option<std::path::PathBuf>,
|
working_directory: Option<PathBuf>,
|
||||||
|
context: Option<&PaneContext>,
|
||||||
) -> Result<(Self, async_channel::Receiver<Event>)> {
|
) -> Result<(Self, async_channel::Receiver<Event>)> {
|
||||||
let size = WindowSize {
|
let size = WindowSize {
|
||||||
num_cols: 80,
|
num_cols: 80,
|
||||||
@@ -118,15 +193,22 @@ impl Session {
|
|||||||
&GridSize(size),
|
&GridSize(size),
|
||||||
proxy.clone(),
|
proxy.clone(),
|
||||||
)));
|
)));
|
||||||
|
let mut env = HashMap::from([
|
||||||
|
("TERM".into(), "xterm-256color".into()),
|
||||||
|
("COLORTERM".into(), "truecolor".into()),
|
||||||
|
]);
|
||||||
|
if let Some(context) = context {
|
||||||
|
env.insert(PaneContext::ENV.into(), context.encode()?);
|
||||||
|
if let Some(path) = shell_path_with_cli() {
|
||||||
|
env.insert("PATH".into(), path);
|
||||||
|
}
|
||||||
|
}
|
||||||
let options = Options {
|
let options = Options {
|
||||||
shell: Some(shell),
|
shell: Some(shell),
|
||||||
// None preserves the directory from which the application launched.
|
// None preserves the directory from which the application launched.
|
||||||
working_directory,
|
working_directory,
|
||||||
drain_on_exit: true,
|
drain_on_exit: true,
|
||||||
env: HashMap::from([
|
env,
|
||||||
("TERM".into(), "xterm-256color".into()),
|
|
||||||
("COLORTERM".into(), "truecolor".into()),
|
|
||||||
]),
|
|
||||||
};
|
};
|
||||||
let pty = tty::new(&options, size, 0).context("Could not start the shell PTY")?;
|
let pty = tty::new(&options, size, 0).context("Could not start the shell PTY")?;
|
||||||
#[cfg(target_os = "linux")]
|
#[cfg(target_os = "linux")]
|
||||||
@@ -530,11 +612,20 @@ mod tests {
|
|||||||
#[test]
|
#[test]
|
||||||
fn real_pty_transports_input_resize_environment_and_exit() {
|
fn real_pty_transports_input_resize_environment_and_exit() {
|
||||||
// Reading first lets the test resize before the child examines its TTY.
|
// Reading first lets the test resize before the child examines its TTY.
|
||||||
let script = "read value; printf '\\033[2J\\033[H%s %s %s ' \"$value\" \"$TERM\" \"$COLORTERM\"; stty size";
|
let script = r#"read value; printf '\033[2J\033[H%s %s %s ' "$value" "$TERM" "$COLORTERM"; stty size; printf '%s' "$PSYTERM_PANE""#;
|
||||||
let (mut session, events) = Session::with_shell(Shell::new(
|
let context = PaneContext {
|
||||||
"/bin/sh".into(),
|
socket: PathBuf::from("/tmp/pty:example/socket"),
|
||||||
vec!["-c".into(), script.into()],
|
session: SessionIdentity {
|
||||||
))
|
server: [23; 16],
|
||||||
|
session: 11,
|
||||||
|
},
|
||||||
|
pane: 23,
|
||||||
|
};
|
||||||
|
let (mut session, events) = Session::with_shell_and_directory(
|
||||||
|
Shell::new("/bin/sh".into(), vec!["-c".into(), script.into()]),
|
||||||
|
None,
|
||||||
|
Some(&context),
|
||||||
|
)
|
||||||
.expect("start real PTY");
|
.expect("start real PTY");
|
||||||
session.resize(100, 30, 9, 18);
|
session.resize(100, 30, 9, 18);
|
||||||
session.write(b"PTY_OK\n".to_vec());
|
session.write(b"PTY_OK\n".to_vec());
|
||||||
@@ -562,6 +653,13 @@ mod tests {
|
|||||||
first_line.contains("PTY_OK xterm-256color truecolor 30 100"),
|
first_line.contains("PTY_OK xterm-256color truecolor 30 100"),
|
||||||
"{first_line:?}"
|
"{first_line:?}"
|
||||||
);
|
);
|
||||||
|
let env_line: String = (0..term.columns())
|
||||||
|
.map(|column| term.grid()[Point::new(Line(1), Column(column))].c)
|
||||||
|
.collect();
|
||||||
|
let inherited = PaneContext::decode(env_line.trim_end()).unwrap();
|
||||||
|
assert_eq!(inherited.session, context.session);
|
||||||
|
assert_eq!(inherited.pane, context.pane);
|
||||||
|
assert_eq!(inherited.socket, context.socket);
|
||||||
assert_eq!((term.columns(), term.screen_lines()), (100, 30));
|
assert_eq!((term.columns(), term.screen_lines()), (100, 30));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|||||||
+76
-15
@@ -54,12 +54,12 @@ pub struct Workspace {
|
|||||||
}
|
}
|
||||||
impl Workspace {
|
impl Workspace {
|
||||||
fn begin_tab_rename(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
fn begin_tab_rename(&mut self, window: &mut Window, cx: &mut Context<Self>) {
|
||||||
let Some(tab) = self.snapshot.as_ref().and_then(|snapshot| {
|
let Some(tab) = self
|
||||||
snapshot
|
.snapshot
|
||||||
.tabs
|
.as_deref()
|
||||||
.iter()
|
.and_then(Snapshot::active_tab)
|
||||||
.find(|tab| tab.id == snapshot.active_tab)
|
.filter(|tab| !tab.is_connecting())
|
||||||
}) else {
|
else {
|
||||||
return;
|
return;
|
||||||
};
|
};
|
||||||
let id = tab.id;
|
let id = tab.id;
|
||||||
@@ -166,6 +166,7 @@ impl Workspace {
|
|||||||
if !matches!(
|
if !matches!(
|
||||||
action,
|
action,
|
||||||
CommandAction::TogglePalette
|
CommandAction::TogglePalette
|
||||||
|
| CommandAction::NewWindow
|
||||||
| CommandAction::IncreaseFontSize
|
| CommandAction::IncreaseFontSize
|
||||||
| CommandAction::DecreaseFontSize
|
| CommandAction::DecreaseFontSize
|
||||||
) && (self.palette.is_some()
|
) && (self.palette.is_some()
|
||||||
@@ -180,6 +181,30 @@ impl Workspace {
|
|||||||
cx.stop_propagation();
|
cx.stop_propagation();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn open_window(&self, cx: &mut Context<Self>) {
|
||||||
|
let client = self.client.clone();
|
||||||
|
let cwd = self
|
||||||
|
.focused_pane()
|
||||||
|
.map(|pane| pane.read(cx).data().cwd.clone());
|
||||||
|
let active_tab = self.snapshot.as_deref().and_then(Snapshot::active_tab);
|
||||||
|
let remote = client
|
||||||
|
.remote()
|
||||||
|
.or_else(|| active_tab?.remote.as_deref())
|
||||||
|
.map(str::to_owned);
|
||||||
|
let launch = cx
|
||||||
|
.background_executor()
|
||||||
|
.spawn(async move { client.open_window(remote, cwd) });
|
||||||
|
cx.spawn(async move |view, cx| {
|
||||||
|
if let Err(error) = launch.await {
|
||||||
|
let _ = view.update(cx, |view, cx| {
|
||||||
|
view.error = Some(format!("Could not open a new window: {error:#}"));
|
||||||
|
cx.notify();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
})
|
||||||
|
.detach();
|
||||||
|
}
|
||||||
|
|
||||||
fn execute(&mut self, action: CommandAction, window: &mut Window, cx: &mut Context<Self>) {
|
fn execute(&mut self, action: CommandAction, window: &mut Window, cx: &mut Context<Self>) {
|
||||||
use CommandAction::*;
|
use CommandAction::*;
|
||||||
let pane = self.focused_pane();
|
let pane = self.focused_pane();
|
||||||
@@ -189,6 +214,10 @@ impl Workspace {
|
|||||||
self.open_palette(window, cx);
|
self.open_palette(window, cx);
|
||||||
None
|
None
|
||||||
}
|
}
|
||||||
|
NewWindow => {
|
||||||
|
self.open_window(cx);
|
||||||
|
None
|
||||||
|
}
|
||||||
IncreaseFontSize | DecreaseFontSize => {
|
IncreaseFontSize | DecreaseFontSize => {
|
||||||
let delta = if matches!(action, IncreaseFontSize) {
|
let delta = if matches!(action, IncreaseFontSize) {
|
||||||
1.
|
1.
|
||||||
@@ -225,7 +254,13 @@ impl Workspace {
|
|||||||
Direction::Down
|
Direction::Down
|
||||||
},
|
},
|
||||||
}),
|
}),
|
||||||
ClosePane => pane_id.map(|pane| ClientMessage::ClosePane { pane }),
|
ClosePane => pane_id
|
||||||
|
.map(|pane| ClientMessage::ClosePane { pane })
|
||||||
|
.or_else(|| {
|
||||||
|
let tab = self.snapshot.as_deref()?.active_tab()?;
|
||||||
|
tab.is_connecting()
|
||||||
|
.then_some(ClientMessage::ClosePendingTab { tab: tab.id })
|
||||||
|
}),
|
||||||
ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }),
|
ResetPaneName => pane_id.map(|pane| ClientMessage::RenamePane { pane, name: None }),
|
||||||
ResetTabName => self
|
ResetTabName => self
|
||||||
.snapshot
|
.snapshot
|
||||||
@@ -307,7 +342,8 @@ impl Workspace {
|
|||||||
if cx
|
if cx
|
||||||
.update(|window, cx| {
|
.update(|window, cx| {
|
||||||
view.update(cx, |view, cx| {
|
view.update(cx, |view, cx| {
|
||||||
for text in update.clipboard {
|
for text in update.clipboard.into_iter().filter(|text| !text.is_empty())
|
||||||
|
{
|
||||||
cx.write_to_clipboard(ClipboardItem::new_string(text));
|
cx.write_to_clipboard(ClipboardItem::new_string(text));
|
||||||
}
|
}
|
||||||
if let Some(error) = update.error {
|
if let Some(error) = update.error {
|
||||||
@@ -535,12 +571,18 @@ impl Render for Workspace {
|
|||||||
if let Some(snapshot) = &self.snapshot {
|
if let Some(snapshot) = &self.snapshot {
|
||||||
incoming = pane_scene(snapshot, &self.panes, incoming_offset, Some(&self.client));
|
incoming = pane_scene(snapshot, &self.panes, incoming_offset, Some(&self.client));
|
||||||
if snapshot.panes.is_empty() {
|
if snapshot.panes.is_empty() {
|
||||||
incoming = incoming.child(
|
let status = match snapshot.active_tab() {
|
||||||
div()
|
Some(tab) if tab.is_connecting() => tab
|
||||||
.p_4()
|
.remote
|
||||||
.text_color(rgb(chrome::MUTED))
|
.as_ref()
|
||||||
.child("No sessions. Use + to open a terminal."),
|
.map(|host| format!("Connecting to {host}…")),
|
||||||
);
|
Some(_) => None, // The selected tab's grid is still in transit.
|
||||||
|
None => Some("No sessions. Use + to open a terminal.".to_owned()),
|
||||||
|
};
|
||||||
|
if let Some(status) = status {
|
||||||
|
incoming =
|
||||||
|
incoming.child(div().p_4().text_color(rgb(chrome::MUTED)).child(status));
|
||||||
|
}
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
incoming = incoming.child(
|
incoming = incoming.child(
|
||||||
@@ -561,15 +603,34 @@ impl Render for Workspace {
|
|||||||
.bg(rgb(chrome::APP_BACKGROUND))
|
.bg(rgb(chrome::APP_BACKGROUND))
|
||||||
.child(header)
|
.child(header)
|
||||||
.child(body);
|
.child(body);
|
||||||
|
#[cfg(target_os = "macos")]
|
||||||
|
{
|
||||||
|
root = root.on_action(cx.listener(|view, _: &crate::NewWindow, _, cx| {
|
||||||
|
view.open_window(cx);
|
||||||
|
}));
|
||||||
|
}
|
||||||
if let Some(error) = &self.error {
|
if let Some(error) = &self.error {
|
||||||
root = root.child(
|
root = root.child(
|
||||||
div()
|
div()
|
||||||
|
.flex()
|
||||||
|
.items_center()
|
||||||
.px_3()
|
.px_3()
|
||||||
.py_1()
|
.py_1()
|
||||||
.text_size(px(12.))
|
.text_size(px(12.))
|
||||||
.text_color(rgb(chrome::TEXT))
|
.text_color(rgb(chrome::TEXT))
|
||||||
.bg(rgb(chrome::BORDER))
|
.bg(rgb(chrome::BORDER))
|
||||||
.child(error.clone()),
|
.child(div().flex_1().min_w_0().child(error.clone()))
|
||||||
|
.child(
|
||||||
|
div()
|
||||||
|
.id("dismiss-error")
|
||||||
|
.px_2()
|
||||||
|
.cursor_pointer()
|
||||||
|
.child("Dismiss")
|
||||||
|
.on_click(cx.listener(|view, _, _, cx| {
|
||||||
|
view.error = None;
|
||||||
|
cx.notify();
|
||||||
|
})),
|
||||||
|
),
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
if let Some(palette) = &self.palette {
|
if let Some(palette) = &self.palette {
|
||||||
|
|||||||
@@ -115,6 +115,7 @@ mod tests {
|
|||||||
fn stack(ids: &[u64], active: u64) -> crate::protocol::TabInfo {
|
fn stack(ids: &[u64], active: u64) -> crate::protocol::TabInfo {
|
||||||
crate::protocol::TabInfo {
|
crate::protocol::TabInfo {
|
||||||
id: 1,
|
id: 1,
|
||||||
|
remote: None,
|
||||||
title: String::new(),
|
title: String::new(),
|
||||||
manual_title: None,
|
manual_title: None,
|
||||||
panes: ids.to_vec(),
|
panes: ids.to_vec(),
|
||||||
|
|||||||
Reference in New Issue
Block a user