@valni/cli-darwin-x64 0.0.0-stage → 0.1.2

package/runtime/node_modules/@mariozechner/clipboard/src/clipboard_rs/platform/mod.rs

@@ -0,0 +1,252 @@
+#[cfg(target_os = "ios")]
+mod ios;
+#[cfg(target_os = "ios")]
+pub use ios::{ClipboardContext, ClipboardWatcherContext, WatcherShutdown};
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(target_os = "macos")]
+pub use macos::{ClipboardContext, ClipboardWatcherContext, WatcherShutdown};
+#[cfg(target_os = "windows")]
+mod win;
+#[cfg(target_os = "windows")]
+pub use win::{ClipboardContext, ClipboardWatcherContext, WatcherShutdown};
+
+// Linux: runtime detection between Wayland and X11
+#[cfg(all(
+  unix,
+  not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "emscripten"
+  ))
+))]
+mod x11;
+
+#[cfg(all(
+  unix,
+  not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "emscripten"
+  )),
+  feature = "wayland"
+))]
+mod wayland;
+
+#[cfg(all(
+  unix,
+  not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "emscripten"
+  ))
+))]
+pub use x11::ClipboardContextX11Options;
+
+#[cfg(all(
+  unix,
+  not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "emscripten"
+  ))
+))]
+mod linux_clipboard {
+  use crate::clipboard_rs::{
+    common::Result, Clipboard, ClipboardContent, ClipboardHandler, ContentFormat,
+  };
+  #[cfg(feature = "image")]
+  use crate::RustImageData;
+
+  pub enum ClipboardContext {
+    X11(super::x11::ClipboardContext),
+    #[cfg(feature = "wayland")]
+    Wayland(super::wayland::ClipboardContext),
+  }
+
+  impl ClipboardContext {
+    pub fn new() -> Result<Self> {
+      #[cfg(feature = "wayland")]
+      {
+        if std::env::var_os("WAYLAND_DISPLAY").is_some() {
+          match super::wayland::ClipboardContext::new() {
+            Ok(ctx) => return Ok(Self::Wayland(ctx)),
+            Err(e) => {
+              eprintln!("Wayland clipboard init failed, falling back to X11: {}", e);
+            }
+          }
+        }
+      }
+      Ok(Self::X11(super::x11::ClipboardContext::new()?))
+    }
+  }
+
+  macro_rules! dispatch {
+		($self:expr, $method:ident $(, $arg:expr)*) => {
+			match $self {
+				ClipboardContext::X11(ctx) => ctx.$method($($arg),*),
+				#[cfg(feature = "wayland")]
+				ClipboardContext::Wayland(ctx) => ctx.$method($($arg),*),
+			}
+		};
+	}
+
+  impl Clipboard for ClipboardContext {
+    fn available_formats(&self) -> Result<Vec<String>> {
+      dispatch!(self, available_formats)
+    }
+
+    fn has(&self, format: ContentFormat) -> bool {
+      dispatch!(self, has, format)
+    }
+
+    fn clear(&self) -> Result<()> {
+      dispatch!(self, clear)
+    }
+
+    fn get_buffer(&self, format: &str) -> Result<Vec<u8>> {
+      dispatch!(self, get_buffer, format)
+    }
+
+    fn get_text(&self) -> Result<String> {
+      dispatch!(self, get_text)
+    }
+
+    fn get_rich_text(&self) -> Result<String> {
+      dispatch!(self, get_rich_text)
+    }
+
+    fn get_html(&self) -> Result<String> {
+      dispatch!(self, get_html)
+    }
+
+    #[cfg(feature = "image")]
+    fn get_image(&self) -> Result<RustImageData> {
+      dispatch!(self, get_image)
+    }
+
+    fn get_files(&self) -> Result<Vec<String>> {
+      dispatch!(self, get_files)
+    }
+
+    fn get(&self, formats: &[ContentFormat]) -> Result<Vec<ClipboardContent>> {
+      dispatch!(self, get, formats)
+    }
+
+    fn set_buffer(&self, format: &str, buffer: Vec<u8>) -> Result<()> {
+      dispatch!(self, set_buffer, format, buffer)
+    }
+
+    fn set_text(&self, text: String) -> Result<()> {
+      dispatch!(self, set_text, text)
+    }
+
+    fn set_rich_text(&self, text: String) -> Result<()> {
+      dispatch!(self, set_rich_text, text)
+    }
+
+    fn set_html(&self, html: String) -> Result<()> {
+      dispatch!(self, set_html, html)
+    }
+
+    #[cfg(feature = "image")]
+    fn set_image(&self, image: RustImageData) -> Result<()> {
+      dispatch!(self, set_image, image)
+    }
+
+    fn set_files(&self, files: Vec<String>) -> Result<()> {
+      dispatch!(self, set_files, files)
+    }
+
+    fn set(&self, contents: Vec<ClipboardContent>) -> Result<()> {
+      dispatch!(self, set, contents)
+    }
+  }
+
+  unsafe impl Send for ClipboardContext {}
+
+  pub enum ClipboardWatcherContext<T: ClipboardHandler> {
+    X11(super::x11::ClipboardWatcherContext<T>),
+    #[cfg(feature = "wayland")]
+    Wayland(super::wayland::ClipboardWatcherContext<T>),
+  }
+
+  impl<T: ClipboardHandler> ClipboardWatcherContext<T> {
+    pub fn new() -> Result<Self> {
+      #[cfg(feature = "wayland")]
+      {
+        if std::env::var_os("WAYLAND_DISPLAY").is_some() {
+          match super::wayland::ClipboardWatcherContext::new() {
+            Ok(ctx) => return Ok(Self::Wayland(ctx)),
+            Err(e) => {
+              eprintln!("Wayland watcher init failed, falling back to X11: {}", e);
+            }
+          }
+        }
+      }
+      Ok(Self::X11(super::x11::ClipboardWatcherContext::new()?))
+    }
+  }
+
+  impl<T: ClipboardHandler + Send> crate::ClipboardWatcher<T> for ClipboardWatcherContext<T> {
+    fn add_handler(&mut self, f: T) -> &mut Self {
+      match self {
+        Self::X11(ctx) => {
+          ctx.handlers.push(f);
+        }
+        #[cfg(feature = "wayland")]
+        Self::Wayland(ctx) => {
+          ctx.handlers.push(f);
+        }
+      }
+      self
+    }
+
+    fn start_watch(&mut self) {
+      match self {
+        Self::X11(ctx) => ctx.start_watch_inner(),
+        #[cfg(feature = "wayland")]
+        Self::Wayland(ctx) => ctx.start_watch_inner(),
+      }
+    }
+
+    fn get_shutdown_channel(&self) -> WatcherShutdown {
+      match self {
+        Self::X11(ctx) => WatcherShutdown {
+          _shutdown: Box::new(ctx.get_shutdown_channel()),
+        },
+        #[cfg(feature = "wayland")]
+        Self::Wayland(ctx) => WatcherShutdown {
+          _shutdown: Box::new(ctx.get_shutdown_channel()),
+        },
+      }
+    }
+  }
+
+  unsafe impl<T: ClipboardHandler + Send> Send for ClipboardWatcherContext<T> {}
+
+  pub struct WatcherShutdown {
+    _shutdown: Box<dyn std::any::Any + Send>,
+  }
+
+  impl WatcherShutdown {
+    pub fn stop(self) {
+      drop(self);
+    }
+  }
+}
+
+#[cfg(all(
+  unix,
+  not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "emscripten"
+  ))
+))]
+pub use linux_clipboard::{ClipboardContext, ClipboardWatcherContext, WatcherShutdown};

package/runtime/node_modules/@mariozechner/clipboard/src/clipboard_rs/platform/wayland.rs

@@ -0,0 +1,431 @@
+use crate::clipboard_rs::{
+  common::Result, Clipboard, ClipboardContent, ClipboardHandler, ContentFormat,
+};
+
+#[cfg(feature = "image")]
+use crate::clipboard_rs::{common::RustImage, RustImageData};
+
+use std::io::Read;
+use std::sync::mpsc::{self, Receiver, Sender};
+use std::time::Duration;
+use wl_clipboard_rs::{
+  copy::{self, MimeSource, MimeType, Options, Source},
+  paste::{self, get_contents, get_mime_types, ClipboardType, Seat},
+  utils::is_primary_selection_supported,
+};
+
+const MIME_HTML: &str = "text/html";
+const MIME_RTF: &str = "text/rtf";
+#[cfg(feature = "image")]
+const MIME_PNG: &str = "image/png";
+const MIME_URI_LIST: &str = "text/uri-list";
+const FILE_PATH_PREFIX: &str = "file://";
+
+fn read_wayland_clipboard(mime: paste::MimeType) -> Result<Vec<u8>> {
+  let result = get_contents(ClipboardType::Regular, Seat::Unspecified, mime);
+  match result {
+    Ok((mut pipe, _)) => {
+      let mut buffer = vec![];
+      pipe
+        .read_to_end(&mut buffer)
+        .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })?;
+      Ok(buffer)
+    }
+    Err(paste::Error::ClipboardEmpty) | Err(paste::Error::NoMimeType) => {
+      Err("Clipboard is empty or content type not available".into())
+    }
+    Err(e) => Err(e.to_string().into()),
+  }
+}
+
+fn write_wayland_clipboard(sources: Vec<MimeSource>) -> Result<()> {
+  let mut opts = Options::new();
+  opts.foreground(false);
+  opts.clipboard(copy::ClipboardType::Regular);
+  opts
+    .copy_multi(sources)
+    .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })?;
+  Ok(())
+}
+
+fn get_offered_mime_types() -> Result<std::collections::HashSet<String>> {
+  get_mime_types(ClipboardType::Regular, Seat::Unspecified)
+    .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })
+}
+
+pub struct ClipboardContext;
+
+impl ClipboardContext {
+  pub fn new() -> Result<Self> {
+    match is_primary_selection_supported() {
+      Ok(_) => Ok(Self),
+      Err(e) => Err(e.to_string().into()),
+    }
+  }
+}
+
+impl Clipboard for ClipboardContext {
+  fn available_formats(&self) -> Result<Vec<String>> {
+    let mime_types = get_offered_mime_types()?;
+    Ok(mime_types.into_iter().collect())
+  }
+
+  fn has(&self, format: ContentFormat) -> bool {
+    #[allow(unreachable_patterns)]
+    let mime_to_check = match format {
+      ContentFormat::Text => "text/plain",
+      ContentFormat::Html => MIME_HTML,
+      ContentFormat::Rtf => MIME_RTF,
+      #[cfg(feature = "image")]
+      ContentFormat::Image => MIME_PNG,
+      ContentFormat::Files => MIME_URI_LIST,
+      ContentFormat::Other(ref s) => s.as_str(),
+      #[cfg(not(feature = "image"))]
+      _ => return false,
+    };
+    if let Ok(mime_types) = get_offered_mime_types() {
+      // For text, also check text/plain;charset=utf-8
+      if mime_to_check == "text/plain" {
+        mime_types.iter().any(|m| m.starts_with("text/plain"))
+      } else {
+        mime_types.contains(mime_to_check)
+      }
+    } else {
+      false
+    }
+  }
+
+  fn clear(&self) -> Result<()> {
+    copy::clear(copy::ClipboardType::Regular, copy::Seat::All)
+      .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })?;
+    Ok(())
+  }
+
+  fn get_buffer(&self, format: &str) -> Result<Vec<u8>> {
+    read_wayland_clipboard(paste::MimeType::Specific(format))
+  }
+
+  fn get_text(&self) -> Result<String> {
+    let bytes = read_wayland_clipboard(paste::MimeType::Text)?;
+    String::from_utf8(bytes)
+      .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })
+  }
+
+  fn get_rich_text(&self) -> Result<String> {
+    let bytes = read_wayland_clipboard(paste::MimeType::Specific(MIME_RTF))?;
+    String::from_utf8(bytes)
+      .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })
+  }
+
+  fn get_html(&self) -> Result<String> {
+    let bytes = read_wayland_clipboard(paste::MimeType::Specific(MIME_HTML))?;
+    String::from_utf8(bytes)
+      .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })
+  }
+
+  #[cfg(feature = "image")]
+  fn get_image(&self) -> Result<RustImageData> {
+    let bytes = read_wayland_clipboard(paste::MimeType::Specific(MIME_PNG))?;
+    RustImageData::from_bytes(&bytes)
+  }
+
+  fn get_files(&self) -> Result<Vec<String>> {
+    let bytes = read_wayland_clipboard(paste::MimeType::Specific(MIME_URI_LIST))?;
+    let text = String::from_utf8(bytes)
+      .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })?;
+    Ok(
+      text
+        .lines()
+        .map(|line| line.trim_end_matches('\r'))
+        .filter(|line| {
+          !line.starts_with('#') && !line.is_empty() && line.starts_with(FILE_PATH_PREFIX)
+        })
+        .map(|line| line.to_string())
+        .collect(),
+    )
+  }
+
+  fn get(&self, formats: &[ContentFormat]) -> Result<Vec<ClipboardContent>> {
+    let mut contents = Vec::new();
+    for format in formats {
+      #[allow(unreachable_patterns)]
+      match format {
+        ContentFormat::Text => {
+          if let Ok(text) = self.get_text() {
+            contents.push(ClipboardContent::Text(text));
+          }
+        }
+        ContentFormat::Html => {
+          if let Ok(html) = self.get_html() {
+            contents.push(ClipboardContent::Html(html));
+          }
+        }
+        ContentFormat::Rtf => {
+          if let Ok(rtf) = self.get_rich_text() {
+            contents.push(ClipboardContent::Rtf(rtf));
+          }
+        }
+        #[cfg(feature = "image")]
+        ContentFormat::Image => {
+          if let Ok(image) = self.get_image() {
+            contents.push(ClipboardContent::Image(image));
+          }
+        }
+        ContentFormat::Files => {
+          if let Ok(files) = self.get_files() {
+            contents.push(ClipboardContent::Files(files));
+          }
+        }
+        ContentFormat::Other(mime) => {
+          if let Ok(data) = self.get_buffer(mime) {
+            contents.push(ClipboardContent::Other(mime.clone(), data));
+          }
+        }
+        #[cfg(not(feature = "image"))]
+        _ => {}
+      }
+    }
+    Ok(contents)
+  }
+
+  fn set_buffer(&self, format: &str, buffer: Vec<u8>) -> Result<()> {
+    write_wayland_clipboard(vec![MimeSource {
+      source: Source::Bytes(buffer.into_boxed_slice()),
+      mime_type: MimeType::Specific(format.to_string()),
+    }])
+  }
+
+  fn set_text(&self, text: String) -> Result<()> {
+    write_wayland_clipboard(vec![MimeSource {
+      source: Source::Bytes(text.into_bytes().into_boxed_slice()),
+      mime_type: MimeType::Text,
+    }])
+  }
+
+  fn set_rich_text(&self, text: String) -> Result<()> {
+    write_wayland_clipboard(vec![MimeSource {
+      source: Source::Bytes(text.into_bytes().into_boxed_slice()),
+      mime_type: MimeType::Specific(MIME_RTF.to_string()),
+    }])
+  }
+
+  fn set_html(&self, html: String) -> Result<()> {
+    write_wayland_clipboard(vec![MimeSource {
+      source: Source::Bytes(html.into_bytes().into_boxed_slice()),
+      mime_type: MimeType::Specific(MIME_HTML.to_string()),
+    }])
+  }
+
+  #[cfg(feature = "image")]
+  fn set_image(&self, image: RustImageData) -> Result<()> {
+    let bytes = image.to_png()?;
+    write_wayland_clipboard(vec![MimeSource {
+      source: Source::Bytes(bytes.get_bytes().into()),
+      mime_type: MimeType::Specific(MIME_PNG.to_string()),
+    }])
+  }
+
+  fn set_files(&self, files: Vec<String>) -> Result<()> {
+    // Normalize paths to file:// URIs and use CRLF for text/uri-list
+    let uri_list: Vec<String> = files
+      .into_iter()
+      .map(|f| {
+        if f.starts_with(FILE_PATH_PREFIX) {
+          f
+        } else {
+          format!("{FILE_PATH_PREFIX}{f}")
+        }
+      })
+      .collect();
+    let data = uri_list.join("\r\n");
+    write_wayland_clipboard(vec![MimeSource {
+      source: Source::Bytes(data.into_bytes().into_boxed_slice()),
+      mime_type: MimeType::Specific(MIME_URI_LIST.to_string()),
+    }])
+  }
+
+  fn set(&self, contents: Vec<ClipboardContent>) -> Result<()> {
+    let mut sources = Vec::new();
+    for content in contents {
+      #[allow(unreachable_patterns)]
+      match content {
+        ClipboardContent::Text(text) => {
+          sources.push(MimeSource {
+            source: Source::Bytes(text.into_bytes().into_boxed_slice()),
+            mime_type: MimeType::Text,
+          });
+        }
+        ClipboardContent::Html(html) => {
+          sources.push(MimeSource {
+            source: Source::Bytes(html.into_bytes().into_boxed_slice()),
+            mime_type: MimeType::Specific(MIME_HTML.to_string()),
+          });
+        }
+        ClipboardContent::Rtf(rtf) => {
+          sources.push(MimeSource {
+            source: Source::Bytes(rtf.into_bytes().into_boxed_slice()),
+            mime_type: MimeType::Specific(MIME_RTF.to_string()),
+          });
+        }
+        #[cfg(feature = "image")]
+        ClipboardContent::Image(image) => {
+          let bytes = image.to_png()?;
+          sources.push(MimeSource {
+            source: Source::Bytes(bytes.get_bytes().into()),
+            mime_type: MimeType::Specific(MIME_PNG.to_string()),
+          });
+        }
+        ClipboardContent::Files(files) => {
+          let uri_list: Vec<String> = files
+            .into_iter()
+            .map(|f| {
+              if f.starts_with(FILE_PATH_PREFIX) {
+                f
+              } else {
+                format!("{FILE_PATH_PREFIX}{f}")
+              }
+            })
+            .collect();
+          let data = uri_list.join("\r\n");
+          sources.push(MimeSource {
+            source: Source::Bytes(data.into_bytes().into_boxed_slice()),
+            mime_type: MimeType::Specific(MIME_URI_LIST.to_string()),
+          });
+        }
+        ClipboardContent::Other(mime, data) => {
+          sources.push(MimeSource {
+            source: Source::Bytes(data.into_boxed_slice()),
+            mime_type: MimeType::Specific(mime),
+          });
+        }
+        #[cfg(not(feature = "image"))]
+        _ => {}
+      }
+    }
+    write_wayland_clipboard(sources)
+  }
+}
+
+unsafe impl Send for ClipboardContext {}
+
+// Polling-based clipboard watcher for Wayland
+pub struct ClipboardWatcherContext<T: ClipboardHandler> {
+  pub(crate) handlers: Vec<T>,
+  pub(crate) stop_signal: Sender<()>,
+  stop_receiver: Receiver<()>,
+}
+
+unsafe impl<T: ClipboardHandler + Send> Send for ClipboardWatcherContext<T> {}
+
+impl<T: ClipboardHandler> ClipboardWatcherContext<T> {
+  pub fn new() -> Result<Self> {
+    // Verify data-control protocol is available (same check as ClipboardContext)
+    is_primary_selection_supported()
+      .map_err(|e| -> Box<dyn std::error::Error + Send + Sync> { e.to_string().into() })?;
+    let (tx, rx) = mpsc::channel();
+    Ok(Self {
+      handlers: Vec::new(),
+      stop_signal: tx,
+      stop_receiver: rx,
+    })
+  }
+}
+
+impl<T: ClipboardHandler> ClipboardWatcherContext<T> {
+  pub(crate) fn get_shutdown_channel(&self) -> WatcherShutdown {
+    WatcherShutdown {
+      sender: self.stop_signal.clone(),
+    }
+  }
+
+  pub(crate) fn start_watch_inner(&mut self) {
+    let mut last_mime_types: Vec<String> = Vec::new();
+    let mut last_text = String::new();
+
+    // Get initial clipboard state
+    if let Ok(types) = get_offered_mime_types() {
+      last_mime_types = {
+        let mut v: Vec<String> = types.into_iter().collect();
+        v.sort();
+        v
+      };
+    }
+    if let Ok(text) = read_wayland_clipboard(paste::MimeType::Text) {
+      if let Ok(s) = String::from_utf8(text) {
+        last_text = s;
+      }
+    }
+
+    loop {
+      if self
+        .stop_receiver
+        .recv_timeout(Duration::from_millis(500))
+        .is_ok()
+      {
+        break;
+      }
+
+      let changed = if let Ok(types) = get_offered_mime_types() {
+        let mut current_types: Vec<String> = types.into_iter().collect();
+        current_types.sort();
+
+        if current_types != last_mime_types {
+          // MIME types changed, clipboard definitely changed
+          last_mime_types = current_types;
+          // Update text cache too
+          if let Ok(bytes) = read_wayland_clipboard(paste::MimeType::Text) {
+            if let Ok(s) = String::from_utf8(bytes) {
+              last_text = s;
+            }
+          } else {
+            last_text.clear();
+          }
+          true
+        } else if let Ok(bytes) = read_wayland_clipboard(paste::MimeType::Text) {
+          // Same MIME types, check if text content changed
+          if let Ok(current) = String::from_utf8(bytes) {
+            if current != last_text {
+              last_text = current;
+              true
+            } else {
+              false
+            }
+          } else {
+            false
+          }
+        } else if !last_text.is_empty() {
+          last_text.clear();
+          true
+        } else {
+          false
+        }
+      } else {
+        // No clipboard content available
+        if !last_mime_types.is_empty() {
+          last_mime_types.clear();
+          last_text.clear();
+          true
+        } else {
+          false
+        }
+      };
+
+      if changed {
+        self
+          .handlers
+          .iter_mut()
+          .for_each(|handler| handler.on_clipboard_change());
+      }
+    }
+  }
+}
+
+pub struct WatcherShutdown {
+  pub(crate) sender: Sender<()>,
+}
+
+impl Drop for WatcherShutdown {
+  fn drop(&mut self) {
+    let _ = self.sender.send(());
+  }
+}