diff options
| author | Aram Drevekenin <aram@poor.dev> | 2025-06-23 19:19:37 +0200 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2025-06-23 19:19:37 +0200 |
| commit | c5ac7968809ddb1033b625562eae22019cccc2f4 (patch) | |
| tree | 932cf07d898dfbcc6ec6a9d4cf5353c06a47accc /default-plugins/share/src/main.rs | |
| parent | feat(ui): add optional tooltip with key hints to the compact bar (#4225) (diff) | |
| download | sl0ppij-c5ac7968809ddb1033b625562eae22019cccc2f4.tar.gz sl0ppij-c5ac7968809ddb1033b625562eae22019cccc2f4.tar.xz sl0ppij-c5ac7968809ddb1033b625562eae22019cccc2f4.zip | |
Feature: web-client/server to share your sessions in the browser (#4242)
* work
* moar work
* notes
* work
* separate to terminal and control channels
* stdin working
* serve html web client initial
* serve static assets loaded with include_dir
* merge
* enable_web_server config parameter
* compile time flag to disable web server capability
* rustfmt
* add license to all xterm.js assets
* mouse working except copy/paste
* helpful comment
* web client improvements
- move script to js file
- add favicon
- add nerd font
- change title
TODO: investigate if font license embedded in otf is sufficient
* get mouse to work properly
* kitty keyboard support initial
* fix wrong type in preload link
* wip axum websocket handlers
- upgrade axum to v0.8.1, enable ws feature
- begin setup of websocket handlers
- tidy up imports
* replace control listener
* handle terminal websocket with axum
* cleanup Cargo.toml
* kitty fixes and bracketed paste
* fix(mouse): pane not found crash
* initial session switching infra
* add `web_client_font` option
* session switching, creation and resurrection working through the session manager
* move session module to zellij-utils and share logic with web-client
* some cleanups
* require restart for enable-web-server
* use session name from router
* write config to disk and watch for config changes
* rename session name to ipc path
* add basic panic handler, make render_to_client exit on channel close
* use while let instead of loop
* handle websocket close
* add mouse motions
* make clipboard work
* add weblink handling and webgl rendering
* add todo
* fix: use session name instead of patch on session switch
* use "default" layout for new sessions
* ui indication for session being shared
* share this session ui
* plugin assets
* Fix process crash on mac with notify watcher.
Use poll watcher instead of recommended as a workaround.
* make url session switching and creation work
* start welcome screen on root url
* scaffold control messages, set font from config
* set dimensions on session start
* bring back session name from url
* send bytes on terminal websocket instead of json
- create web client os input and id before websocket connection
* draft ui
* work
* refactor ui
* remove otf font, remove margins to avoid scrollbar
* version query endpoint for server status
* web session info query endpoint
* refactor: move stuff around
* add web client info to session metadata
* make tests pass
* populate real data in session list
* remove unnecessary endpoint
* add web_client node to config, add font option
* remove web_client_font
* allow disabling the web session through the config - WIP
* formalize sharing/not-sharing configuration
* fix tests
* allow shutting down web server
* display error when web clients are forbidden to attach
* only show sessions that allow web clients if this is a web client
* style(fmt): rustfmt
* fix: query web server from Zellij rather than from each plugin
* remove log spam
* handle some error paths better in the web client
* allow controlling the web server through the cli
* allow configuring the web server's ip/port
* fix tests and format code
* use direct WebServerStatus event instead of piggy-backing on SessionInfo
* plugin revamp initial
* make plugin responsive
* adjust plugin title
* refactor: share plugin
* refactor: share plugin
* add cors middleware
* some fixes for running without a compiled web server capability
* display error when starting the share plugin without web server support
* clarify config
* add pipelines to compile zellij without web support
* display error when unable to start web server
* only query web server when share plugin is running
* refactor(web-client): connection table
* give zellij_server_listener access to the control channel
* fixes and clarifications
* refactor: consolidate generate_unique_session_name
* give proper error when trying to attach to a forbidden session
* change browser URL when switching sessions
* add keyboard shortcut
* enforce https when bound to non-loopback ip
* initial authentication token implementation
* background color from theme
* initial web client theme config
* basic token generation ui
* refactor set config message creation
* also set body background
* allow editing scrollback for plugins too
* set scrollback to 0
* properly parse colors in config
* generate token from plugin
* nice login modals
* initial token management screen
* implement token authentication
* refactor(share): token management screen
* style(fmt): rustfmt
* fix(plugin): some minor bugs
* refactor(share): main screen
* refactor(share): token screen
* refactor(share): main
* refactor(share): ui components
* fix(responsiveness): properly send usage_width to the render function
* fix cli commands and add some verbosity
* add support for settings ansi and selection colors
* add cursor and cursor accent
* basic web client tests
* fix tests
* refactor: web client
* use session tokens for authentication
* improve modals
* move shutdown to ipc
* refactor: ipc logic
* serialize theme config for web client
* update tests
* refactor: move some stuff around to prepare for config hot reload
* config live reloading for the web clients
* change remember-me UI wording
* improve xterm.js link handling
* make sure terminal is focused on mousemove
* remove deprecated sharing indication from compact-bar
* gate deps and functionality behind the web_server_compatibility feature
* feat(build): add --no-web flag in all the places
* fix some other build flows
* add new assets
* update CI for no-web (untested)
* make more dependencies optional
* update axum-extra
* add web client configuration options
* gracefully close connections on server exit
* tests for graceful connection closing
* handle client-side reconnect when server is down
* fix: make sure ipc bus folder exists before starting
* add commands to manage login tokens from the cli
* style(fmt): rustfmt
* some cleanups
* fix(ux): allow alt-right-click on the web client without opening the context menu
* fix: prevent attaching to welcome screen
* fix: reload config issues
* fix long socket path on macos
* normalize config conversion and fix color gap in browser
* revoke session_token cookie if it is not valid
* fix: visual bug with multiple clients in extremely small screen sizes
* fix: only include rusqlite for the web server capability builds
* update e2e snapshots
* refactor(web): client side js
* some cleanups
* moar cleanups
* fix(tests): wait for server instead of using a fixed timeout
* debug CI
* fix(tests): use spawn_blocking for running the test web server
* fix(tests): wait for http rather than tcp port
* fix(tests): properly pass config path - hopefully this is the issue...
* success! bring back the rest of the tests
* attempt to fix the macos CI issue
* docs(changelog): add PR
---------
Co-authored-by: Thomas Linford <linford.t@gmail.com>
Diffstat (limited to 'default-plugins/share/src/main.rs')
| -rw-r--r-- | default-plugins/share/src/main.rs | 647 |
1 files changed, 647 insertions, 0 deletions
diff --git a/default-plugins/share/src/main.rs b/default-plugins/share/src/main.rs new file mode 100644 index 00000000..1708e495 --- /dev/null +++ b/default-plugins/share/src/main.rs @@ -0,0 +1,647 @@ +mod main_screen; +mod token_management_screen; +mod token_screen; +mod ui_components; + +use std::net::IpAddr; +use zellij_tile::prelude::*; + +use std::collections::{BTreeMap, HashMap}; + +use main_screen::MainScreen; +use token_management_screen::TokenManagementScreen; +use token_screen::TokenScreen; + +static WEB_SERVER_QUERY_DURATION: f64 = 0.4; // Doherty threshold + +#[derive(Debug, Default)] +struct App { + web_server: WebServerState, + ui: UIState, + tokens: TokenManager, + state: AppState, +} + +register_plugin!(App); + +impl ZellijPlugin for App { + fn load(&mut self, _configuration: BTreeMap<String, String>) { + self.initialize(); + } + + fn update(&mut self, event: Event) -> bool { + if !self.web_server.capability && !matches!(event, Event::ModeUpdate(_)) { + return false; + } + + match event { + Event::Timer(_) => self.handle_timer(), + Event::ModeUpdate(mode_info) => self.handle_mode_update(mode_info), + Event::WebServerStatus(status) => self.handle_web_server_status(status), + Event::Key(key) => self.handle_key_input(key), + Event::Mouse(mouse_event) => self.handle_mouse_event(mouse_event), + Event::RunCommandResult(exit_code, _stdout, _stderr, context) => { + self.handle_command_result(exit_code, context) + }, + Event::FailedToStartWebServer(error) => self.handle_web_server_error(error), + _ => false, + } + } + + fn render(&mut self, rows: usize, cols: usize) { + if !self.web_server.capability { + self.render_no_capability_message(rows, cols); + return; + } + + self.ui.reset_render_state(); + match &self.state.current_screen { + Screen::Main => self.render_main_screen(rows, cols), + Screen::Token(token) => self.render_token_screen(rows, cols, token), + Screen::ManageTokens => self.render_manage_tokens_screen(rows, cols), + } + } +} + +impl App { + fn initialize(&mut self) { + self.subscribe_to_events(); + self.state.own_plugin_id = Some(get_plugin_ids().plugin_id); + self.retrieve_token_list(); + self.query_link_executable(); + self.set_plugin_title(); + } + + fn subscribe_to_events(&self) { + subscribe(&[ + EventType::Key, + EventType::ModeUpdate, + EventType::WebServerStatus, + EventType::Mouse, + EventType::RunCommandResult, + EventType::FailedToStartWebServer, + EventType::Timer, + ]); + } + + fn set_plugin_title(&self) { + if let Some(plugin_id) = self.state.own_plugin_id { + rename_plugin_pane(plugin_id, "Share Session"); + } + } + + fn handle_timer(&mut self) -> bool { + query_web_server_status(); + self.retrieve_token_list(); + set_timeout(WEB_SERVER_QUERY_DURATION); + false + } + + fn handle_mode_update(&mut self, mode_info: ModeInfo) -> bool { + let mut should_render = false; + + self.state.session_name = mode_info.session_name; + + if let Some(web_clients_allowed) = mode_info.web_clients_allowed { + self.web_server.clients_allowed = web_clients_allowed; + should_render = true; + } + + if let Some(web_sharing) = mode_info.web_sharing { + self.web_server.sharing = web_sharing; + should_render = true; + } + + if let Some(web_server_ip) = mode_info.web_server_ip { + self.web_server.ip = Some(web_server_ip); + should_render = true; + } + + if let Some(web_server_port) = mode_info.web_server_port { + self.web_server.port = Some(web_server_port); + should_render = true; + } + + if let Some(web_server_capability) = mode_info.web_server_capability { + self.web_server.capability = web_server_capability; + if self.web_server.capability && !self.state.timer_running { + self.state.timer_running = true; + set_timeout(WEB_SERVER_QUERY_DURATION); + } + should_render = true; + } + + should_render + } + + fn handle_web_server_status(&mut self, status: WebServerStatus) -> bool { + match status { + WebServerStatus::Online(base_url) => { + self.web_server.base_url = base_url; + self.web_server.started = true; + self.web_server.different_version_error = None; + }, + WebServerStatus::Offline => { + self.web_server.started = false; + self.web_server.different_version_error = None; + }, + WebServerStatus::DifferentVersion(version) => { + self.web_server.started = false; + self.web_server.different_version_error = Some(version); + }, + } + true + } + + fn handle_key_input(&mut self, key: KeyWithModifier) -> bool { + if self.clear_error_or_info() { + return true; + } + + match self.state.current_screen { + Screen::Main => self.handle_main_screen_keys(key), + Screen::Token(_) => self.handle_token_screen_keys(key), + Screen::ManageTokens => self.handle_manage_tokens_keys(key), + } + } + + fn clear_error_or_info(&mut self) -> bool { + self.web_server.error.take().is_some() || self.state.info.take().is_some() + } + + fn handle_main_screen_keys(&mut self, key: KeyWithModifier) -> bool { + match key.bare_key { + BareKey::Enter if key.has_no_modifiers() && !self.web_server.started => { + start_web_server(); + false + }, + BareKey::Char('c') if key.has_modifiers(&[KeyModifier::Ctrl]) => { + stop_web_server(); + false + }, + BareKey::Char(' ') if key.has_no_modifiers() => { + self.toggle_session_sharing(); + false + }, + BareKey::Char('t') if key.has_no_modifiers() => { + self.handle_token_action(); + true + }, + BareKey::Esc if key.has_no_modifiers() => { + close_self(); + false + }, + _ => false, + } + } + + fn toggle_session_sharing(&self) { + match self.web_server.sharing { + WebSharing::Disabled => {}, + WebSharing::On => stop_sharing_current_session(), + WebSharing::Off => share_current_session(), + } + } + + fn handle_token_action(&mut self) { + if self.tokens.list.is_empty() { + self.generate_new_token(None); + } else { + self.change_to_manage_tokens_screen(); + } + } + + fn handle_token_screen_keys(&mut self, key: KeyWithModifier) -> bool { + match key.bare_key { + BareKey::Esc if key.has_no_modifiers() => { + self.change_to_previous_screen(); + true + }, + _ => false, + } + } + + fn handle_manage_tokens_keys(&mut self, key: KeyWithModifier) -> bool { + if self.tokens.handle_text_input(&key) { + return true; + } + + match key.bare_key { + BareKey::Esc if key.has_no_modifiers() => self.handle_escape_key(), + BareKey::Down if key.has_no_modifiers() => self.tokens.navigate_down(), + BareKey::Up if key.has_no_modifiers() => self.tokens.navigate_up(), + BareKey::Char('n') if key.has_no_modifiers() => { + self.tokens.start_new_token_input(); + true + }, + BareKey::Enter if key.has_no_modifiers() => self.handle_enter_key(), + BareKey::Char('r') if key.has_no_modifiers() => { + self.tokens.start_rename_input(); + true + }, + BareKey::Char('x') if key.has_no_modifiers() => self.revoke_selected_token(), + BareKey::Char('x') if key.has_modifiers(&[KeyModifier::Ctrl]) => { + self.revoke_all_tokens(); + true + }, + _ => false, + } + } + + fn handle_escape_key(&mut self) -> bool { + let was_editing = self.tokens.cancel_input(); + + if !was_editing { + self.change_to_main_screen(); + } + true + } + + fn handle_enter_key(&mut self) -> bool { + if let Some(token_name) = self.tokens.finish_new_token_input() { + self.generate_new_token(token_name); + return true; + } + + if let Some(new_name) = self.tokens.finish_rename_input() { + self.rename_current_token(new_name); + return true; + } + + false + } + + fn generate_new_token(&mut self, name: Option<String>) { + match generate_web_login_token(name) { + Ok(token) => self.change_to_token_screen(token), + Err(e) => self.web_server.error = Some(e), + } + } + + fn rename_current_token(&mut self, new_name: String) { + if let Some(current_token) = self.tokens.get_selected_token() { + match rename_web_token(¤t_token.0, &new_name) { + Ok(_) => { + self.retrieve_token_list(); + if self.tokens.adjust_selection_after_list_change() { + self.change_to_main_screen(); + } + }, + Err(e) => self.web_server.error = Some(e), + } + } + } + + fn revoke_selected_token(&mut self) -> bool { + if let Some(token) = self.tokens.get_selected_token() { + match revoke_web_login_token(&token.0) { + Ok(_) => { + self.retrieve_token_list(); + if self.tokens.adjust_selection_after_list_change() { + self.change_to_main_screen(); + } + self.state.info = Some("Revoked. Connected clients not affected.".to_owned()); + }, + Err(e) => self.web_server.error = Some(e), + } + return true; + } + false + } + + fn revoke_all_tokens(&mut self) { + match revoke_all_web_tokens() { + Ok(_) => { + self.retrieve_token_list(); + if self.tokens.adjust_selection_after_list_change() { + self.change_to_main_screen(); + } + self.state.info = Some("Revoked. Connected clients not affected.".to_owned()); + }, + Err(e) => self.web_server.error = Some(e), + } + } + + fn handle_mouse_event(&mut self, event: Mouse) -> bool { + match event { + Mouse::LeftClick(line, column) => self.handle_link_click(line, column), + Mouse::Hover(line, column) => { + self.ui.hover_coordinates = Some((column, line as usize)); + true + }, + _ => false, + } + } + + fn handle_link_click(&mut self, line: isize, column: usize) -> bool { + for (coordinates, url) in &self.ui.clickable_urls { + if coordinates.contains(column, line as usize) { + if let Some(executable) = self.ui.link_executable { + run_command(&[executable, url], Default::default()); + } + return true; + } + } + false + } + + fn handle_command_result( + &mut self, + exit_code: Option<i32>, + context: BTreeMap<String, String>, + ) -> bool { + if context.contains_key("xdg_open_cli") && exit_code == Some(0) { + self.ui.link_executable = Some("xdg-open"); + } else if context.contains_key("open_cli") && exit_code == Some(0) { + self.ui.link_executable = Some("open"); + } + false + } + + fn handle_web_server_error(&mut self, error: String) -> bool { + self.web_server.error = Some(error); + true + } + + fn query_link_executable(&self) { + let mut xdg_context = BTreeMap::new(); + xdg_context.insert("xdg_open_cli".to_owned(), String::new()); + run_command(&["xdg-open", "--help"], xdg_context); + + let mut open_context = BTreeMap::new(); + open_context.insert("open_cli".to_owned(), String::new()); + run_command(&["open", "--help"], open_context); + } + + fn render_no_capability_message(&self, rows: usize, cols: usize) { + let full_text = "This version of Zellij was compiled without web sharing capabilities"; + let short_text = "No web server capabilities"; + let text = if cols >= full_text.chars().count() { + full_text + } else { + short_text + }; + + let text_element = Text::new(text).color_range(3, ..); + let text_x = cols.saturating_sub(text.chars().count()) / 2; + let text_y = rows / 2; + print_text_with_coordinates(text_element, text_x, text_y, None, None); + } + + fn change_to_token_screen(&mut self, token: String) { + self.retrieve_token_list(); + set_self_mouse_selection_support(true); + self.state.previous_screen = Some(self.state.current_screen.clone()); + self.state.current_screen = Screen::Token(token); + } + + fn change_to_manage_tokens_screen(&mut self) { + self.retrieve_token_list(); + set_self_mouse_selection_support(false); + self.tokens.selected_index = Some(0); + self.state.previous_screen = None; + self.state.current_screen = Screen::ManageTokens; + } + + fn change_to_main_screen(&mut self) { + self.retrieve_token_list(); + set_self_mouse_selection_support(false); + self.state.previous_screen = None; + self.state.current_screen = Screen::Main; + } + + fn change_to_previous_screen(&mut self) { + self.retrieve_token_list(); + match self.state.previous_screen.take() { + Some(Screen::ManageTokens) => self.change_to_manage_tokens_screen(), + _ => self.change_to_main_screen(), + } + } + + fn render_main_screen(&mut self, rows: usize, cols: usize) { + let state_changes = MainScreen::new( + self.tokens.list.is_empty(), + self.web_server.started, + &self.web_server.error, + &self.web_server.different_version_error, + &self.web_server.base_url, + self.web_server.ip, + self.web_server.port, + &self.state.session_name, + self.web_server.sharing, + self.ui.hover_coordinates, + &self.state.info, + &self.ui.link_executable, + ) + .render(rows, cols); + + self.ui.currently_hovering_over_link = state_changes.currently_hovering_over_link; + self.ui.currently_hovering_over_unencrypted = + state_changes.currently_hovering_over_unencrypted; + self.ui.clickable_urls = state_changes.clickable_urls; + } + + fn render_token_screen(&self, rows: usize, cols: usize, token: &str) { + let token_screen = + TokenScreen::new(token.to_string(), self.web_server.error.clone(), rows, cols); + token_screen.render(); + } + + fn render_manage_tokens_screen(&self, rows: usize, cols: usize) { + TokenManagementScreen::new( + &self.tokens.list, + self.tokens.selected_index, + &self.tokens.renaming_token, + &self.tokens.entering_new_name, + &self.web_server.error, + &self.state.info, + rows, + cols, + ) + .render(); + } + + fn retrieve_token_list(&mut self) { + if let Err(e) = self.tokens.retrieve_list() { + self.web_server.error = Some(e); + } + } +} + +#[derive(Debug, Default)] +struct WebServerState { + started: bool, + sharing: WebSharing, + clients_allowed: bool, + error: Option<String>, + different_version_error: Option<String>, + ip: Option<IpAddr>, + port: Option<u16>, + base_url: String, + capability: bool, +} + +#[derive(Debug, Default)] +struct UIState { + hover_coordinates: Option<(usize, usize)>, + clickable_urls: HashMap<CoordinatesInLine, String>, + link_executable: Option<&'static str>, + currently_hovering_over_link: bool, + currently_hovering_over_unencrypted: bool, +} + +impl UIState { + fn reset_render_state(&mut self) { + self.currently_hovering_over_link = false; + self.clickable_urls.clear(); + } +} + +#[derive(Debug, Default)] +struct TokenManager { + list: Vec<(String, String)>, + selected_index: Option<usize>, + entering_new_name: Option<String>, + renaming_token: Option<String>, +} + +impl TokenManager { + fn retrieve_list(&mut self) -> Result<(), String> { + match list_web_login_tokens() { + Ok(tokens) => { + self.list = tokens; + Ok(()) + }, + Err(e) => Err(format!("Failed to retrieve login tokens: {}", e)), + } + } + + fn get_selected_token(&self) -> Option<&(String, String)> { + self.selected_index.and_then(|i| self.list.get(i)) + } + + fn adjust_selection_after_list_change(&mut self) -> bool { + if self.list.is_empty() { + self.selected_index = None; + true // indicates should change to main screen + } else if self.selected_index >= Some(self.list.len()) { + self.selected_index = Some(self.list.len().saturating_sub(1)); + false + } else { + false + } + } + + fn navigate_down(&mut self) -> bool { + if let Some(ref mut index) = self.selected_index { + *index = if *index < self.list.len().saturating_sub(1) { + *index + 1 + } else { + 0 + }; + return true; + } + false + } + + fn navigate_up(&mut self) -> bool { + if let Some(ref mut index) = self.selected_index { + *index = if *index == 0 { + self.list.len().saturating_sub(1) + } else { + *index - 1 + }; + return true; + } + false + } + + fn start_new_token_input(&mut self) { + self.entering_new_name = Some(String::new()); + } + + fn start_rename_input(&mut self) { + self.renaming_token = Some(String::new()); + } + + fn handle_text_input(&mut self, key: &KeyWithModifier) -> bool { + match key.bare_key { + BareKey::Char(c) if key.has_no_modifiers() => { + if let Some(ref mut name) = self.entering_new_name { + name.push(c); + return true; + } + if let Some(ref mut name) = self.renaming_token { + name.push(c); + return true; + } + }, + BareKey::Backspace if key.has_no_modifiers() => { + if let Some(ref mut name) = self.entering_new_name { + name.pop(); + return true; + } + if let Some(ref mut name) = self.renaming_token { + name.pop(); + return true; + } + }, + _ => {}, + } + false + } + + fn finish_new_token_input(&mut self) -> Option<Option<String>> { + self.entering_new_name + .take() + .map(|name| if name.is_empty() { None } else { Some(name) }) + } + + fn finish_rename_input(&mut self) -> Option<String> { + self.renaming_token.take() + } + + fn cancel_input(&mut self) -> bool { + self.entering_new_name.take().is_some() || self.renaming_token.take().is_some() + } +} + +#[derive(Debug, Default)] +struct AppState { + session_name: Option<String>, + own_plugin_id: Option<u32>, + timer_running: bool, + current_screen: Screen, + previous_screen: Option<Screen>, + info: Option<String>, +} + +#[derive(Debug, Clone)] +enum Screen { + Main, + Token(String), + ManageTokens, +} + +impl Default for Screen { + fn default() -> Self { + Screen::Main + } +} + +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct CoordinatesInLine { + x: usize, + y: usize, + width: usize, +} + +impl CoordinatesInLine { + pub fn new(x: usize, y: usize, width: usize) -> Self { + CoordinatesInLine { x, y, width } + } + + pub fn contains(&self, x: usize, y: usize) -> bool { + x >= self.x && x <= self.x + self.width && self.y == y + } +} |
