Unify shell opacity and add native authentication and system controls

shell/ferese-polkit-agent/src/prompt.rs

@@ -0,0 +1,489 @@
+use crate::PromptEvent;
+use cosmic::{
+    Element,
+    app::{Core, Settings, Task},
+    iced::{Alignment, Background, Border, Color, Length, Size, Subscription, window},
+    theme,
+    widget::{self, button, column, container, row, text},
+};
+use std::{
+    collections::VecDeque,
+    io::{BufRead, BufReader, Write},
+    sync::{Arc, Mutex},
+    time::Duration,
+};
+use zeroize::{Zeroize, Zeroizing};
+
+#[derive(Clone)]
+struct Appearance {
+    surface: Color,
+    translucent: bool,
+    text: Color,
+    muted: Color,
+    accent: Color,
+    radius: f32,
+    font: cosmic::font::Font,
+}
+
+impl Appearance {
+    fn load() -> Self {
+        let document = ferese_config::config_path()
+            .and_then(|path| std::fs::read_to_string(path).ok())
+            .and_then(|source| ferese_config::Document::parse(&source).ok());
+        let setting = |key: &str, fallback: &str| {
+            document
+                .as_ref()
+                .and_then(|doc| doc.get(key))
+                .and_then(|value| value.as_str())
+                .unwrap_or(fallback)
+                .to_owned()
+        };
+        let color = |key, fallback| parse_color(&setting(key, fallback), fallback);
+        let family: &'static str =
+            Box::leak(setting("theme.typography.font_family", "Inter").into_boxed_str());
+        let translucent = setting("theme.material.style", "solid") == "translucent";
+        let shell_opacity = document
+            .as_ref()
+            .and_then(|doc| doc.get("theme.material.opacity"))
+            .and_then(|value| value.as_f64())
+            .unwrap_or(ferese_config::DEFAULT_MATERIAL_OPACITY)
+            .clamp(0., 1.) as f32;
+        let mut surface = color("theme.colors.surface_base", "#111821");
+        surface.a = if translucent { shell_opacity } else { 1. };
+
+        Self {
+            surface,
+            translucent,
+            text: color("theme.colors.text_primary", "#F4F7FB"),
+            muted: color("theme.colors.text_muted", "#8793A2"),
+            accent: color("theme.colors.accent", "#3D7BE6"),
+            radius: document
+                .as_ref()
+                .and_then(|doc| doc.get("theme.geometry.shell_radius"))
+                .and_then(|value| value.as_f64())
+                .unwrap_or(14.)
+                .clamp(8., 36.) as f32,
+            font: cosmic::font::Font {
+                family: cosmic::iced::font::Family::Name(family),
+                ..cosmic::font::default()
+            },
+        }
+    }
+
+    fn theme(&self) -> cosmic::Theme {
+        use cosmic::cosmic_theme::{ThemeBuilder, palette::Srgba};
+
+        let rgba = |color: Color| Srgba::new(color.r, color.g, color.b, color.a);
+        let builder = if self.surface.r + self.surface.g + self.surface.b > 1.5 {
+            ThemeBuilder::light()
+        } else {
+            ThemeBuilder::dark()
+        };
+
+        let mut corners = cosmic::cosmic_theme::CornerRadii::default();
+        corners.radius_xs = [self.radius.min(4.); 4];
+        corners.radius_s = [self.radius.min(8.); 4];
+        corners.radius_m = [self.radius; 4];
+        corners.radius_l = [self.radius; 4];
+        corners.radius_xl = [self.radius; 4];
+
+        cosmic::Theme::custom(Arc::new(
+            builder
+                .corner_radii(corners)
+                .bg_color(rgba(Color {
+                    a: if self.translucent { 0. } else { 1. },
+                    ..self.surface
+                }))
+                .primary_container_bg(rgba(self.surface))
+                .text_tint(rgba(self.text).color)
+                .accent(rgba(self.accent).color)
+                .build(),
+        ))
+    }
+}
+
+fn parse_color(input: &str, fallback: &str) -> Color {
+    let parse = |source: &str| {
+        let value = u32::from_str_radix(source.strip_prefix('#')?, 16).ok()?;
+        (source.len() == 7)
+            .then(|| Color::from_rgb8((value >> 16) as u8, (value >> 8) as u8, value as u8))
+    };
+    parse(input)
+        .or_else(|| parse(fallback))
+        .unwrap_or(Color::BLACK)
+}
+
+#[derive(Clone)]
+enum Message {
+    Tick,
+    Input(String),
+    Submit,
+    Cancel,
+}
+
+impl std::fmt::Debug for Message {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str("AuthenticationPromptMessage")
+    }
+}
+
+struct Prompt {
+    core: Core,
+    appearance: Appearance,
+    incoming: Arc<Mutex<VecDeque<PromptEvent>>>,
+    description: String,
+    user: String,
+    question: String,
+    echo: bool,
+    answer: Zeroizing<String>,
+    waiting: bool,
+    error: Option<String>,
+    info: Option<String>,
+    height: f32,
+}
+
+fn content_height(description: &str, status: Option<&str>) -> f32 {
+    let lines: usize = description
+        .lines()
+        .map(|line| line.chars().count().div_ceil(48).max(1))
+        .sum();
+    let status_height = status.map_or(0, |message| {
+        14 + 18 * message.chars().count().div_ceil(48).clamp(1, 3)
+    });
+    (214 + 18 * lines.saturating_sub(1) + status_height).min(360) as f32
+}
+
+fn input_style(palette: &Appearance) -> theme::TextInput {
+    let text = palette.text;
+    let muted = palette.muted;
+    let accent = palette.accent;
+    let radius = palette.radius.min(10.);
+    let appearance = move |focused: bool| widget::text_input::Appearance {
+        background: Color::from_rgba(text.r, text.g, text.b, 0.045).into(),
+        border_radius: radius.into(),
+        border_width: 1.,
+        border_offset: None,
+        border_color: if focused {
+            accent.scale_alpha(0.82)
+        } else {
+            muted.scale_alpha(0.26)
+        },
+        icon_color: Some(muted),
+        text_color: Some(text),
+        placeholder_color: muted,
+        selected_text_color: text,
+        selected_fill: accent.scale_alpha(0.35),
+        label_color: text,
+    };
+    theme::TextInput::Custom {
+        active: Box::new(move |_| appearance(false)),
+        hovered: Box::new(move |_| appearance(true)),
+        focused: Box::new(move |_| appearance(true)),
+        error: Box::new(move |_| appearance(false)),
+        disabled: Box::new(move |_| appearance(false)),
+    }
+}
+
+pub fn run() -> Result<(), Box<dyn std::error::Error>> {
+    let stdin = std::io::stdin();
+    let mut lines = BufReader::new(stdin).lines();
+    let Some(Ok(first)) = lines.next() else {
+        return Err("Missing authentication request".into());
+    };
+    let PromptEvent::Start { message, user } = serde_json::from_str(&first)? else {
+        return Err("Invalid authentication request".into());
+    };
+    let incoming = Arc::new(Mutex::new(VecDeque::new()));
+    let queue = incoming.clone();
+    std::thread::spawn(move || {
+        for line in lines {
+            let Ok(line) = line else { break };
+            if let Ok(event) = serde_json::from_str(&line) {
+                queue.lock().unwrap().push_back(event);
+            }
+        }
+        queue.lock().unwrap().push_back(PromptEvent::Cancel);
+    });
+    let appearance = Appearance::load();
+    let height = content_height(&message, None);
+    cosmic::app::run::<Prompt>(
+        Settings::default()
+            .size(Size::new(434., height))
+            .client_decorations(false)
+            .transparent(true)
+            .theme(appearance.theme())
+            .default_font(appearance.font)
+            .default_text_size(14.)
+            .antialiasing(true),
+        (incoming, message, user, appearance),
+    )?;
+    Ok(())
+}
+
+fn reply(mut event: PromptEvent) {
+    if let Ok(mut line) = serde_json::to_string(&event) {
+        let mut stdout = std::io::stdout().lock();
+        let _ = writeln!(stdout, "{line}");
+        let _ = stdout.flush();
+        line.zeroize();
+    }
+    if let PromptEvent::Response { value } = &mut event {
+        value.zeroize();
+    }
+}
+
+fn focus() -> Task<Message> {
+    widget::text_input::focus(widget::Id::new("auth-response"))
+}
+
+impl Prompt {
+    fn resize_to_content(&mut self) -> Task<Message> {
+        let height = content_height(
+            &self.description,
+            self.error.as_deref().or(self.info.as_deref()),
+        );
+        if (height - self.height).abs() < 1.0 {
+            return Task::none();
+        }
+        self.height = height;
+        self.core
+            .main_window_id()
+            .map(|id| window::resize(id, Size::new(434., height)))
+            .unwrap_or_else(Task::none)
+    }
+}
+
+impl cosmic::Application for Prompt {
+    type Executor = cosmic::executor::Default;
+    type Flags = (
+        Arc<Mutex<VecDeque<PromptEvent>>>,
+        String,
+        String,
+        Appearance,
+    );
+    type Message = Message;
+    const APP_ID: &'static str = "dev.ferese.Authentication";
+
+    fn core(&self) -> &Core {
+        &self.core
+    }
+
+    fn core_mut(&mut self) -> &mut Core {
+        &mut self.core
+    }
+
+    fn init(
+        mut core: Core,
+        (incoming, description, user, appearance): Self::Flags,
+    ) -> (Self, Task<Message>) {
+        core.window.show_headerbar = false;
+        let height = content_height(&description, None);
+        let bounds = core
+            .main_window_id()
+            .map(|id| window::set_max_size(id, Some(Size::new(434., 360.))))
+            .unwrap_or_else(Task::none);
+        (
+            Self {
+                core,
+                appearance,
+                incoming,
+                description,
+                user,
+                question: "Waiting for authentication…".into(),
+                echo: false,
+                answer: Zeroizing::new(String::new()),
+                waiting: true,
+                error: None,
+                info: None,
+                height,
+            },
+            Task::batch([focus(), bounds]),
+        )
+    }
+
+    fn subscription(&self) -> Subscription<Message> {
+        cosmic::iced::time::every(Duration::from_millis(30)).map(|_| Message::Tick)
+    }
+
+    fn update(&mut self, message: Message) -> Task<Message> {
+        match message {
+            Message::Tick => {
+                let events: Vec<_> = self.incoming.lock().unwrap().drain(..).collect();
+                let mut refocus = false;
+                for event in events {
+                    match event {
+                        PromptEvent::Request { prompt, echo } => {
+                            self.answer.zeroize();
+                            self.question = prompt;
+                            self.echo = echo;
+                            self.waiting = false;
+                            refocus = true;
+                        }
+                        PromptEvent::Info { text } => self.info = Some(text),
+                        PromptEvent::Error { text } => self.error = Some(text),
+                        PromptEvent::Cancel => return cosmic::iced::exit(),
+                        _ => {}
+                    }
+                }
+                let resize = self.resize_to_content();
+                if refocus {
+                    return Task::batch([resize, focus()]);
+                }
+                return resize;
+            }
+            Message::Input(mut value) => {
+                if !self.waiting && value.len() <= 4096 {
+                    self.answer.zeroize();
+                    *self.answer = std::mem::take(&mut value);
+                    self.error = None;
+                }
+                value.zeroize();
+            }
+            Message::Submit if !self.waiting && !self.answer.is_empty() => {
+                let value = std::mem::take(&mut *self.answer);
+                reply(PromptEvent::Response { value });
+                self.waiting = true;
+            }
+            Message::Cancel => {
+                self.answer.zeroize();
+                reply(PromptEvent::Cancel);
+                return cosmic::iced::exit();
+            }
+            _ => {}
+        }
+        Task::none()
+    }
+
+    fn on_escape(&mut self) -> Task<Message> {
+        self.update(Message::Cancel)
+    }
+
+    fn view(&self) -> Element<'_, Message> {
+        let palette = &self.appearance;
+        let mut input = widget::text_input(&self.question, self.answer.as_str())
+            .id(widget::Id::new("auth-response"))
+            .font(palette.font)
+            .padding([7, 12])
+            .style(input_style(palette));
+        if !self.echo {
+            input = input.password();
+        }
+        if !self.waiting {
+            input = input.on_input(Message::Input).on_submit(|mut value| {
+                value.zeroize();
+                Message::Submit
+            });
+        }
+        let action = button::custom(text("Authenticate").font(palette.font).size(13))
+            .class(theme::Button::Suggested)
+            .height(Length::Fixed(36.))
+            .padding([8, 16])
+            .on_press_maybe((!self.waiting && !self.answer.is_empty()).then_some(Message::Submit));
+        let lock_svg = std::str::from_utf8(include_bytes!(
+            "../../ferese-shell/assets/icons/status/lock.svg"
+        ))
+        .expect("embedded lock icon is valid UTF-8")
+        .replace(
+            "currentColor",
+            &format!(
+                "#{:02x}{:02x}{:02x}",
+                (palette.accent.r * 255.) as u8,
+                (palette.accent.g * 255.) as u8,
+                (palette.accent.b * 255.) as u8,
+            ),
+        );
+        let lock_icon = widget::icon::from_svg_bytes(lock_svg.into_bytes())
+            .symbolic(false)
+            .icon()
+            .size(20);
+        let heading = row![
+            container(lock_icon)
+                .width(40)
+                .height(40)
+                .center_x(40)
+                .center_y(40)
+                .class(theme::Container::custom(move |_| {
+                    widget::container::Style {
+                        background: Some(Background::Color(palette.accent.scale_alpha(0.13))),
+                        border: Border {
+                            radius: 12.0.into(),
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    }
+                })),
+            column![
+                text("Authentication required").font(palette.font).size(18),
+                text(format!("Confirm as {}", self.user))
+                    .font(palette.font)
+                    .size(12)
+                    .class(theme::Text::Color(palette.muted)),
+            ]
+            .spacing(2),
+        ]
+        .spacing(12)
+        .align_y(Alignment::Center);
+        let mut body = column![
+            heading,
+            text(&self.description).font(palette.font).size(13),
+            input
+        ]
+        .spacing(14)
+        .width(Length::Fill);
+        if let Some(error) = &self.error {
+            body = body.push(
+                text(error)
+                    .font(palette.font)
+                    .size(12)
+                    .class(theme::Text::Color(Color::from_rgb8(235, 98, 98))),
+            );
+        } else if let Some(info) = &self.info {
+            body = body.push(
+                text(info)
+                    .font(palette.font)
+                    .size(12)
+                    .class(theme::Text::Color(palette.muted)),
+            );
+        }
+        body = body.push(
+            row![
+                button::custom(text("Cancel").font(palette.font).size(13))
+                    .class(theme::Button::Text)
+                    .padding([8, 14])
+                    .on_press(Message::Cancel),
+                action
+            ]
+            .spacing(8)
+            .align_y(Alignment::Center),
+        );
+        container(body)
+            .padding(20)
+            .width(Length::Fill)
+            .height(Length::Fill)
+            .class(theme::Container::custom(move |_| {
+                widget::container::Style {
+                    background: Some(Background::Color(palette.surface)),
+                    text_color: Some(palette.text),
+                    border: Border {
+                        radius: palette.radius.into(),
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                }
+            }))
+            .into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::content_height;
+
+    #[test]
+    fn dialog_grows_for_long_messages_and_caps_its_height() {
+        assert_eq!(content_height("Short request", None), 214.);
+        assert!(content_height(&"Long message ".repeat(20), None) > 214.);
+        assert_eq!(content_height(&"Long message ".repeat(100), None), 360.);
+        assert!(content_height("Short request", Some("Password not accepted")) > 214.);
+    }
+}