@psnext/slingcli 2.4.20260509-2 → 2.4.20260516-1

package/node_modules/@earendil-works/pi-ai/dist/providers/anthropic.js

@@ -108,9 +108,14 @@ function convertContentBlocks(content) {
 const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
 const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
 function getAnthropicCompat(model) {
+    // Auto-detect session affinity and cache control support from provider
+    const isFireworks = model.provider === "fireworks";
+    const isCloudflareAiGatewayAnthropic = model.provider === "cloudflare-ai-gateway" && model.baseUrl.includes("anthropic");
     return {
-        supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? true,
-        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+        supportsEagerToolInputStreaming: model.compat?.supportsEagerToolInputStreaming ?? !isFireworks,
+        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? !isFireworks,
+        sendSessionAffinityHeaders: model.compat?.sendSessionAffinityHeaders ?? !!(isFireworks || isCloudflareAiGatewayAnthropic),
+        supportsCacheControlOnTools: model.compat?.supportsCacheControlOnTools ?? !isFireworks,
     };
 }
 function mergeHeaders(...headerSources) {
@@ -310,7 +315,9 @@ export const streamAnthropic = (model, context, options) => {
                         hasImages,
                     });
                 }
-                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders);
+                const cacheRetention = options?.cacheRetention ?? resolveCacheRetention();
+                const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+                const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, context), options?.headers, copilotDynamicHeaders, cacheSessionId);
                 client = created.client;
                 isOAuth = created.isOAuthToken;
             }
@@ -582,7 +589,7 @@ export const streamSimpleAnthropic = (model, context, options) => {
 function isOAuthToken(apiKey) {
     return apiKey.includes("sk-ant-oat");
 }
-function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders) {
+function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStreamingBeta, optionsHeaders, dynamicHeaders, sessionId) {
     // Adaptive thinking models (Opus 4.6, Sonnet 4.6) have interleaved thinking built-in.
     // The beta header is deprecated on Opus 4.6 and redundant on Sonnet 4.6, so skip it.
     const needsInterleavedBeta = interleavedThinking && !supportsAdaptiveThinking(model.id);
@@ -643,6 +650,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
         return { client, isOAuthToken: true };
     }
     // API key auth
+    const sessionAffinityHeaders = sessionId && getAnthropicCompat(model).sendSessionAffinityHeaders ? { "x-session-affinity": sessionId } : {};
     const client = new Anthropic({
         apiKey,
         baseURL: model.baseUrl,
@@ -651,7 +659,7 @@ function createClient(model, apiKey, interleavedThinking, useFineGrainedToolStre
             accept: "application/json",
             "anthropic-dangerous-direct-browser-access": "true",
             ...(betaFeatures.length > 0 ? { "anthropic-beta": betaFeatures.join(",") } : {}),
-        }, model.headers, optionsHeaders),
+        }, sessionAffinityHeaders, model.headers, optionsHeaders),
     });
     return { client, isOAuthToken: false };
 }
@@ -695,7 +703,8 @@ function buildParams(model, context, isOAuthToken, options) {
         params.temperature = options.temperature;
     }
     if (context.tools && context.tools.length > 0) {
-        params.tools = convertTools(context.tools, isOAuthToken, getAnthropicCompat(model).supportsEagerToolInputStreaming, cacheControl);
+        const compat = getAnthropicCompat(model);
+        params.tools = convertTools(context.tools, isOAuthToken, compat.supportsEagerToolInputStreaming, compat.supportsCacheControlOnTools ? cacheControl : undefined);
     }
     // Configure thinking mode: adaptive (Opus 4.6+ and Sonnet 4.6),
     // budget-based (older models), or explicitly disabled.

package/node_modules/@earendil-works/pi-ai/dist/providers/openai-codex-responses.js

@@ -503,7 +503,31 @@ function recordWebSocketFailure(sessionId, error) {
     stats.lastWebSocketError = formatThrownValue(error);
     stats.websocketFallbackActive = true;
 }
-function getWebSocketConstructor() {
+let _cachedWebsocket = null;
+async function getWebSocketConstructor() {
+    if (_cachedWebsocket)
+        return _cachedWebsocket;
+    // bun doesn't respect http proxy envs, ref: https://github.com/oven-sh/bun/issues/15489
+    // TODO: remove this when bun supports proxy envs in websocket.
+    if (process?.versions?.bun &&
+        (process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy)) {
+        const m = await dynamicImport("proxy-from-env");
+        const getProxyForUrl = m.getProxyForUrl;
+        _cachedWebsocket = class extends WebSocket {
+            constructor(url, options) {
+                let _opts = {};
+                if (Array.isArray(options) || typeof options === "string") {
+                    _opts = { protocols: options };
+                }
+                else {
+                    _opts = { ...options };
+                }
+                const proxy = getProxyForUrl(url.toString().replace(/^wss:/, "https:").replace(/^ws:/, "http:"));
+                super(url, { ..._opts, ...(proxy ? { proxy } : {}) });
+            }
+        };
+        return _cachedWebsocket;
+    }
     const ctor = globalThis.WebSocket;
     if (typeof ctor !== "function")
         return null;
@@ -548,7 +572,7 @@ function scheduleSessionWebSocketExpiry(sessionId, entry) {
     }, SESSION_WEBSOCKET_CACHE_TTL_MS);
 }
 async function connectWebSocket(url, headers, signal) {
-    const WebSocketCtor = getWebSocketConstructor();
+    const WebSocketCtor = await getWebSocketConstructor();
     if (!WebSocketCtor) {
         throw new Error("WebSocket transport is not available in this runtime");
     }

package/node_modules/@earendil-works/pi-ai/package.json

@@ -73,11 +73,12 @@
 		"@aws-sdk/client-bedrock-runtime": "^3.1030.0",
 		"@google/genai": "^1.40.0",
 		"@mistralai/mistralai": "^2.2.0",
-		"typebox": "^1.1.24",
 		"chalk": "^5.6.2",
 		"openai": "6.26.0",
 		"partial-json": "^0.1.7",
 		"proxy-agent": "^6.5.0",
+		"proxy-from-env": "^1.1.0",
+		"typebox": "^1.1.24",
 		"undici": "^7.19.1",
 		"zod-to-json-schema": "^3.24.6"
 	},

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/dark.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "https://raw.githubusercontent.com/earendil-works/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
 	"name": "dark",
 	"vars": {
 		"cyan": "#00d7ff",

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/light.json

@@ -1,5 +1,5 @@
 {
-	"$schema": "https://raw.githubusercontent.com/earendil-works/pi-mono/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+	"$schema": "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
 	"name": "light",
 	"vars": {
 		"teal": "#5a8080",

package/node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/theme.js

@@ -527,6 +527,7 @@ function getDefaultTheme() {
 // ============================================================================
 // Use globalThis to share theme across module loaders (tsx + jiti in dev mode)
 const THEME_KEY = Symbol.for("@earendil-works/pi-coding-agent:theme");
+const THEME_KEY_OLD = Symbol.for("@mariozechner/pi-coding-agent:theme");
 // Export theme as a getter that reads from globalThis
 // This ensures all module instances (tsx, jiti) see the same theme
 export const theme = new Proxy({}, {
@@ -539,6 +540,7 @@ export const theme = new Proxy({}, {
 });
 function setGlobalTheme(t) {
     globalThis[THEME_KEY] = t;
+    globalThis[THEME_KEY_OLD] = t;
 }
 let currentThemeName;
 let themeWatcher;

package/node_modules/@earendil-works/pi-coding-agent/package.json

@@ -6,7 +6,6 @@
 	"piConfig": {
 		"configDir": ".sling",
     "name":"sling"
-
 	},
 	"bin": {
 		"pi": "dist/cli.js"

package/node_modules/@mariozechner/clipboard/Cargo.toml

@@ -6,17 +6,36 @@ version = "0.0.0"
 [lib]
 crate-type = ["cdylib"]
 
+[features]
+default = ["image"]
+image = ["dep:image"]
+wayland = ["dep:wl-clipboard-rs"]
+
 [dependencies]
 base64 = "0.22.0"
-clipboard-rs = "0.2.4"
 futures = "0.3.30"
 # Pin image to version compatible with older Rust in CI Docker images
-image = "=0.25.5"
+image = { version = "=0.25.5", features = ["png", "jpeg"], optional = true, default-features = false }
 # Default enable napi4 feature, see https://nodejs.org/api/n-api.html#node-api-version-matrix
 napi = { version = "2.12.2", default-features = false, features = ["napi4", "tokio_rt"] }
 napi-derive = "2.12.2"
 tokio = "1.36.0"
 
+[target.'cfg(all(unix, not(any(target_os="macos", target_os="android", target_os="ios", target_os="emscripten"))))'.dependencies]
+wl-clipboard-rs = { version = "0.9", optional = true }
+x11rb = { version = "0.13.2", features = ["xfixes"] }
+
+[target.'cfg(target_os = "macos")'.dependencies]
+image = { version = "=0.25.5", features = ["tiff", "png", "jpeg"], optional = true, default-features = false }
+objc2 = "0.6.3"
+objc2-app-kit = { version = "0.3.2", features = ["NSPasteboard", "NSPasteboardItem", "NSImage"] }
+objc2-foundation = { version = "0.3.2", features = ["NSArray", "NSString", "NSEnumerator"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+clipboard-win = { version = "5.4.1", features = ["monitor"] }
+image = { version = "=0.25.5", features = ["bmp", "png", "jpeg"], optional = true, default-features = false }
+windows = { version = "0.59.0", features = ["Win32_Foundation", "Win32_Graphics_Gdi", "Win32_System_DataExchange"] }
+
 [build-dependencies]
 # Pin to version that works with older Rust in Docker images
 napi-build = "=2.1.3"

package/node_modules/@mariozechner/clipboard/README.md

@@ -56,3 +56,5 @@ Everything is done with GitHub Action.
 
 Run `npm version patch` to bump the version.
 Then `git push --follow-tags` to push the changes and tags to GitHub. GitHub Action will automatically build and publish.
+
+The GitHub Actions `NPM_TOKEN` repository secret is a granular npm token with publish access to `@mariozechner/clipboard` and all `@mariozechner/clipboard-*` platform packages. npm granular access tokens expire after 90 days, so this secret must be rotated before expiry.

package/node_modules/@mariozechner/clipboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mariozechner/clipboard",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
@@ -42,15 +42,15 @@
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@mariozechner/clipboard-darwin-arm64": "0.3.2",
-    "@mariozechner/clipboard-darwin-universal": "0.3.2",
-    "@mariozechner/clipboard-darwin-x64": "0.3.2",
-    "@mariozechner/clipboard-linux-arm64-gnu": "0.3.2",
-    "@mariozechner/clipboard-linux-arm64-musl": "0.3.2",
-    "@mariozechner/clipboard-linux-riscv64-gnu": "0.3.2",
-    "@mariozechner/clipboard-linux-x64-gnu": "0.3.2",
-    "@mariozechner/clipboard-linux-x64-musl": "0.3.2",
-    "@mariozechner/clipboard-win32-arm64-msvc": "0.3.2",
-    "@mariozechner/clipboard-win32-x64-msvc": "0.3.2"
+    "@mariozechner/clipboard-darwin-arm64": "0.3.6",
+    "@mariozechner/clipboard-darwin-universal": "0.3.6",
+    "@mariozechner/clipboard-darwin-x64": "0.3.6",
+    "@mariozechner/clipboard-linux-arm64-gnu": "0.3.6",
+    "@mariozechner/clipboard-linux-arm64-musl": "0.3.6",
+    "@mariozechner/clipboard-linux-riscv64-gnu": "0.3.6",
+    "@mariozechner/clipboard-linux-x64-gnu": "0.3.6",
+    "@mariozechner/clipboard-linux-x64-musl": "0.3.6",
+    "@mariozechner/clipboard-win32-arm64-msvc": "0.3.6",
+    "@mariozechner/clipboard-win32-x64-msvc": "0.3.6"
   }
 }

package/node_modules/@mariozechner/clipboard/src/clipboard_rs/common.rs

@@ -0,0 +1,307 @@
+#[cfg(feature = "image")]
+use image::imageops::FilterType;
+#[cfg(feature = "image")]
+use image::{ColorType, DynamicImage, GenericImageView, ImageFormat, RgbaImage};
+use std::error::Error;
+use std::io::Cursor;
+pub type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync + 'static>>;
+
+pub trait ContentData {
+  fn get_format(&self) -> ContentFormat;
+
+  fn as_bytes(&self) -> &[u8];
+
+  fn as_str(&self) -> Result<&str>;
+}
+
+pub trait ClipboardHandler {
+  fn on_clipboard_change(&mut self);
+}
+
+pub enum ClipboardContent {
+  Text(String),
+  Rtf(String),
+  Html(String),
+  #[cfg(feature = "image")]
+  Image(RustImageData),
+  Files(Vec<String>),
+  Other(String, Vec<u8>),
+}
+
+impl ContentData for ClipboardContent {
+  fn get_format(&self) -> ContentFormat {
+    match self {
+      ClipboardContent::Text(_) => ContentFormat::Text,
+      ClipboardContent::Rtf(_) => ContentFormat::Rtf,
+      ClipboardContent::Html(_) => ContentFormat::Html,
+      #[cfg(feature = "image")]
+      ClipboardContent::Image(_) => ContentFormat::Image,
+      ClipboardContent::Files(_) => ContentFormat::Files,
+      ClipboardContent::Other(format, _) => ContentFormat::Other(format.clone()),
+    }
+  }
+
+  fn as_bytes(&self) -> &[u8] {
+    match self {
+      ClipboardContent::Text(data) => data.as_bytes(),
+      ClipboardContent::Rtf(data) => data.as_bytes(),
+      ClipboardContent::Html(data) => data.as_bytes(),
+      // dynamic image is not supported to as bytes
+      #[cfg(feature = "image")]
+      ClipboardContent::Image(_) => &[],
+      ClipboardContent::Files(data) => {
+        // use first file path as data
+        if let Some(path) = data.first() {
+          path.as_bytes()
+        } else {
+          &[]
+        }
+      }
+      ClipboardContent::Other(_, data) => data.as_slice(),
+    }
+  }
+
+  fn as_str(&self) -> Result<&str> {
+    match self {
+      ClipboardContent::Text(data) => Ok(data),
+      ClipboardContent::Rtf(data) => Ok(data),
+      ClipboardContent::Html(data) => Ok(data),
+      #[cfg(feature = "image")]
+      ClipboardContent::Image(_) => Err("can't convert image to string".into()),
+      ClipboardContent::Files(data) => {
+        // use first file path as data
+        if let Some(path) = data.first() {
+          Ok(path)
+        } else {
+          Err("content is empty".into())
+        }
+      }
+      ClipboardContent::Other(_, data) => std::str::from_utf8(data).map_err(|e| e.into()),
+    }
+  }
+}
+
+#[derive(Clone)]
+pub enum ContentFormat {
+  Text,
+  Rtf,
+  Html,
+  #[cfg(feature = "image")]
+  Image,
+  Files,
+  Other(String),
+}
+
+#[cfg(feature = "image")]
+pub struct RustImageData {
+  width: u32,
+  height: u32,
+  data: Option<DynamicImage>,
+}
+
+/// 此处的 `RustImageBuffer` 已经是带有图片格式的字节流，例如 png,jpeg;
+#[cfg(feature = "image")]
+pub struct RustImageBuffer(Vec<u8>);
+
+#[cfg(feature = "image")]
+pub trait RustImage: Sized {
+  /// create an empty image
+  fn empty() -> Self;
+
+  fn is_empty(&self) -> bool;
+
+  /// Read image from file path
+  fn from_path(path: &str) -> Result<Self>;
+
+  /// Create a new image from a byte slice
+  fn from_bytes(bytes: &[u8]) -> Result<Self>;
+
+  fn from_dynamic_image(image: DynamicImage) -> Self;
+
+  /// width and height
+  fn get_size(&self) -> (u32, u32);
+
+  /// Scale this image down to fit within a specific size.
+  /// Returns a new image. The image's aspect ratio is preserved.
+  /// The image is scaled to the maximum possible size that fits
+  /// within the bounds specified by `nwidth` and `nheight`.
+  ///
+  /// This method uses a fast integer algorithm where each source
+  /// pixel contributes to exactly one target pixel.
+  /// May give aliasing artifacts if new size is close to old size.
+  fn thumbnail(&self, width: u32, height: u32) -> Result<Self>;
+
+  /// en: Adjust the size of the image without retaining the aspect ratio
+  /// zh: 调整图片大小，不保留长宽比
+  fn resize(&self, width: u32, height: u32, filter: FilterType) -> Result<Self>;
+
+  fn encode_image(
+    &self,
+    target_color_type: ColorType,
+    format: ImageFormat,
+  ) -> Result<RustImageBuffer>;
+
+  fn to_jpeg(&self) -> Result<RustImageBuffer>;
+
+  /// en: Convert to png format, the returned image is a new image, and the data itself will not be modified
+  /// zh: 转为 png 格式,返回的为新的图片，本身数据不会修改
+  fn to_png(&self) -> Result<RustImageBuffer>;
+
+  #[cfg(target_os = "windows")]
+  fn to_bitmap(&self) -> Result<RustImageBuffer>;
+
+  fn save_to_path(&self, path: &str) -> Result<()>;
+
+  fn get_dynamic_image(&self) -> Result<DynamicImage>;
+
+  fn to_rgba8(&self) -> Result<RgbaImage>;
+}
+
+#[cfg(feature = "image")]
+impl RustImage for RustImageData {
+  fn empty() -> Self {
+    RustImageData {
+      width: 0,
+      height: 0,
+      data: None,
+    }
+  }
+
+  fn is_empty(&self) -> bool {
+    self.data.is_none()
+  }
+
+  fn from_path(path: &str) -> Result<Self> {
+    let image = image::open(path)?;
+    let (width, height) = image.dimensions();
+    Ok(RustImageData {
+      width,
+      height,
+      data: Some(image),
+    })
+  }
+
+  fn from_bytes(bytes: &[u8]) -> Result<Self> {
+    let image = image::load_from_memory(bytes)?;
+    let (width, height) = image.dimensions();
+    Ok(RustImageData {
+      width,
+      height,
+      data: Some(image),
+    })
+  }
+
+  fn from_dynamic_image(image: DynamicImage) -> Self {
+    let (width, height) = image.dimensions();
+    RustImageData {
+      width,
+      height,
+      data: Some(image),
+    }
+  }
+
+  fn get_size(&self) -> (u32, u32) {
+    (self.width, self.height)
+  }
+
+  fn thumbnail(&self, width: u32, height: u32) -> Result<Self> {
+    match &self.data {
+      Some(image) => {
+        let resized = image.thumbnail(width, height);
+        Ok(RustImageData {
+          width: resized.width(),
+          height: resized.height(),
+          data: Some(resized),
+        })
+      }
+      None => Err("image is empty".into()),
+    }
+  }
+
+  fn resize(&self, width: u32, height: u32, filter: FilterType) -> Result<Self> {
+    match &self.data {
+      Some(image) => {
+        let resized = image.resize_exact(width, height, filter);
+        Ok(RustImageData {
+          width: resized.width(),
+          height: resized.height(),
+          data: Some(resized),
+        })
+      }
+      None => Err("image is empty".into()),
+    }
+  }
+
+  fn save_to_path(&self, path: &str) -> Result<()> {
+    match &self.data {
+      Some(image) => {
+        image.save(path)?;
+        Ok(())
+      }
+      None => Err("image is empty".into()),
+    }
+  }
+
+  fn get_dynamic_image(&self) -> Result<DynamicImage> {
+    match &self.data {
+      Some(image) => Ok(image.clone()),
+      None => Err("image is empty".into()),
+    }
+  }
+
+  fn to_rgba8(&self) -> Result<RgbaImage> {
+    match &self.data {
+      Some(image) => Ok(image.to_rgba8()),
+      None => Err("image is empty".into()),
+    }
+  }
+
+  // 私有辅助函数，处理图像格式转换和编码
+  fn encode_image(
+    &self,
+    target_color_type: ColorType,
+    format: ImageFormat,
+  ) -> Result<RustImageBuffer> {
+    let image = self.data.as_ref().ok_or("image is empty")?;
+
+    let mut bytes = Vec::new();
+    match (image.color(), target_color_type) {
+      (ColorType::Rgba8, ColorType::Rgb8) => image
+        .to_rgb8()
+        .write_to(&mut Cursor::new(&mut bytes), format)?,
+      (_, ColorType::Rgba8) => image
+        .to_rgba8()
+        .write_to(&mut Cursor::new(&mut bytes), format)?,
+      _ => image.write_to(&mut Cursor::new(&mut bytes), format)?,
+    };
+    Ok(RustImageBuffer(bytes))
+  }
+
+  fn to_jpeg(&self) -> Result<RustImageBuffer> {
+    // JPEG 需要 RGB 格式（不支持 alpha 通道）
+    self.encode_image(ColorType::Rgb8, ImageFormat::Jpeg)
+  }
+
+  fn to_png(&self) -> Result<RustImageBuffer> {
+    // PNG 使用 RGBA 格式以支持透明度
+    self.encode_image(ColorType::Rgba8, ImageFormat::Png)
+  }
+
+  #[cfg(target_os = "windows")]
+  fn to_bitmap(&self) -> Result<RustImageBuffer> {
+    // BMP 使用 RGBA 格式
+    self.encode_image(ColorType::Rgba8, ImageFormat::Bmp)
+  }
+}
+
+#[cfg(feature = "image")]
+impl RustImageBuffer {
+  pub fn get_bytes(&self) -> &[u8] {
+    &self.0
+  }
+
+  pub fn save_to_path(&self, path: &str) -> Result<()> {
+    std::fs::write(path, &self.0)?;
+    Ok(())
+  }
+}

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

@@ -0,0 +1,93 @@
+pub mod common;
+mod platform;
+#[cfg(feature = "image")]
+pub use common::RustImageData;
+pub use common::{ClipboardContent, ClipboardHandler, ContentFormat, Result};
+#[cfg(feature = "image")]
+pub use image::imageops::FilterType;
+#[cfg(target_os = "linux")]
+pub use platform::ClipboardContextX11Options;
+pub use platform::{ClipboardContext, ClipboardWatcherContext, WatcherShutdown};
+
+pub trait Clipboard: Send {
+  /// zh: 获得剪切板当前内容的所有格式
+  /// en: Get all formats of the current content in the clipboard
+  fn available_formats(&self) -> Result<Vec<String>>;
+
+  fn has(&self, format: ContentFormat) -> bool;
+
+  /// zh: 清空剪切板
+  /// en: clear clipboard
+  fn clear(&self) -> Result<()>;
+
+  /// zh: 获得指定格式的数据，以字节数组形式返回
+  /// en: Get the data in the specified format in the clipboard as a byte array
+  fn get_buffer(&self, format: &str) -> Result<Vec<u8>>;
+
+  /// zh: 仅获得无格式纯文本，以字符串形式返回
+  /// en: Get plain text content in the clipboard as string
+  fn get_text(&self) -> Result<String>;
+
+  /// zh: 获得剪贴板中的富文本内容，以字符串形式返回
+  /// en: Get the rich text content in the clipboard as string
+  fn get_rich_text(&self) -> Result<String>;
+
+  /// zh: 获得剪贴板中的html内容，以字符串形式返回
+  /// en: Get the html format content in the clipboard as string
+  fn get_html(&self) -> Result<String>;
+
+  #[cfg(feature = "image")]
+  fn get_image(&self) -> Result<RustImageData>;
+
+  fn get_files(&self) -> Result<Vec<String>>;
+
+  fn get(&self, formats: &[ContentFormat]) -> Result<Vec<ClipboardContent>>;
+
+  fn set_buffer(&self, format: &str, buffer: Vec<u8>) -> Result<()>;
+
+  fn set_text(&self, text: String) -> Result<()>;
+
+  fn set_rich_text(&self, text: String) -> Result<()>;
+
+  fn set_html(&self, html: String) -> Result<()>;
+
+  #[cfg(feature = "image")]
+  fn set_image(&self, image: RustImageData) -> Result<()>;
+
+  fn set_files(&self, files: Vec<String>) -> Result<()>;
+
+  /// set image will clear clipboard
+  fn set(&self, contents: Vec<ClipboardContent>) -> Result<()>;
+}
+
+pub trait ClipboardWatcher<T: ClipboardHandler>: Send {
+  /// zh: 添加一个剪切板变化处理器，可以添加多个处理器，处理器需要实现 [`ClipboardHandler`] 这个trait
+  /// en: Add a clipboard change handler, you can add multiple handlers, the handler needs to implement the trait [`ClipboardHandler`]
+  fn add_handler(&mut self, handler: T) -> &mut Self;
+
+  /// zh: 开始监视剪切板变化，这是一个阻塞方法，直到监视结束，或者调用了stop方法，所以建议在单独的线程中调用
+  /// en: Start monitoring clipboard changes, this is a blocking method, until the monitoring ends, or the stop method is called, so it is recommended to call it in a separate thread
+  fn start_watch(&mut self);
+
+  /// zh: 获得停止监视的通道，可以通过这个通道停止监视
+  /// en: Get the channel to stop monitoring, you can stop monitoring through this channel
+  fn get_shutdown_channel(&self) -> WatcherShutdown;
+}
+
+#[cfg(not(all(
+  unix,
+  not(any(
+    target_os = "macos",
+    target_os = "ios",
+    target_os = "android",
+    target_os = "emscripten"
+  ))
+)))]
+impl WatcherShutdown {
+  /// zh: 停止监视
+  ///
+  /// en: stop watching
+  pub fn stop(self) {
+    drop(self);
+  }
+}