akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/native/desktop/src/win/autostart.rs

@@ -0,0 +1,77 @@
+//! Launch at login on Windows (autostart plugin, plugins.md §5): a value under
+//! HKCU\Software\Microsoft\Windows\CurrentVersion\Run that starts this .exe. The ops and answers
+//! are macOS's (autostart.rs), so the plugin's desktop.ts stays one file:
+//!   autostart.status        {id} → {"status"}
+//!   autostart.enable        {id} → {"status","error"}
+//!   autostart.disable       {id} → {"status","error"}
+//!   autostart.openSettings       → null   Settings › Apps › Startup
+//! `id` (the app id) names the value. status: enabled | notRegistered | requiresApproval.
+//! error: null, or {"reason":"other","code":<Win32 error>,"domain":"Win32","message"}.
+//!
+//! Task Manager's and Settings' Startup switch lives in
+//! ...\Explorer\StartupApproved\Run: a REG_BINARY value of the same name whose first byte is odd
+//! when the user switched the app off (03, with the time it happened in the last 8 bytes) and even
+//! when it is on (02), or no value at all (on). Electron reads the first byte the same way
+//! (electron/shell/browser/browser_win.cc GetLoginItemSettingsHelper); auto-launch 0.5, which
+//! Tauri's plugin uses, overwrites it with "on" at every enable
+//! (auto-launch src/windows.rs:37-57). Like macOS's requiresApproval, the shell leaves the user's
+//! choice alone: enable() then reports it, and openSettings() opens the page to switch it back on.
+//! disable() removes both values, so that a later enable() starts over.
+//! The exe path is quoted, as Electron's FormatCommandLineString does (auto-launch does not, which
+//! breaks paths with spaces).
+
+use super::registry::{self, HKEY_CURRENT_USER};
+use crate::json;
+
+const RUN: &str = r"Software\Microsoft\Windows\CurrentVersion\Run";
+const APPROVED: &str = r"Software\Microsoft\Windows\CurrentVersion\Explorer\StartupApproved\Run";
+
+fn status(id: &str) -> Result<&'static str, String> {
+  let describe = |e| format!("INTERNAL: cannot read the Run key: {}", registry::describe(e));
+  if registry::read_string(HKEY_CURRENT_USER, RUN, id).map_err(describe)?.is_none() {
+    return Ok("notRegistered");
+  }
+  let approved = registry::read_binary(HKEY_CURRENT_USER, APPROVED, id).unwrap_or(None);
+  Ok(if approved.and_then(|b| b.first().copied()).is_some_and(|b| b & 1 == 1) { "requiresApproval" } else { "enabled" })
+}
+
+fn command_line() -> Result<String, String> {
+  let exe = std::env::current_exe().map_err(|e| format!("INTERNAL: the app's path is unknown: {e}"))?;
+  Ok(format!("\"{}\"", exe.display()))
+}
+
+fn error_json(code: windows::Win32::Foundation::WIN32_ERROR) -> String {
+  let message = windows::core::Error::from(code.to_hresult()).message();
+  format!(r#"{{"reason":"other","code":{},"domain":"Win32","message":{}}}"#, code.0, json::quote(&message))
+}
+
+fn change(op: &str, id: &str) -> Result<String, String> {
+  let result = match op {
+    "autostart.enable" if status(id)? == "requiresApproval" => Ok(()), // the user's choice (see above)
+    "autostart.enable" => registry::write_string(HKEY_CURRENT_USER, RUN, id, &command_line()?),
+    _ => registry::delete_value(HKEY_CURRENT_USER, RUN, id).and_then(|()| registry::delete_value(HKEY_CURRENT_USER, APPROVED, id)),
+  };
+  let error = result.err().map_or_else(|| "null".to_string(), error_json);
+  Ok(format!(r#"{{"status":"{}","error":{error}}}"#, status(id)?))
+}
+
+/// `autostart.*` ops; None for other ops.
+pub fn shell_op(op: &str, cmd: &json::V) -> Option<Result<String, String>> {
+  if !op.starts_with("autostart.") {
+    return None;
+  }
+  if op == "autostart.openSettings" {
+    // Settings › Apps › Startup (ms-settings:startupapps, Windows 10 1803 and later).
+    return Some(if super::open_url("ms-settings:startupapps") { Ok("null".into()) } else { Err("INTERNAL: cannot open Settings".into()) });
+  }
+  let id = match cmd.get("id").and_then(|v| v.as_str()) {
+    // The value name: no path separators (a backslash would name a subkey in some APIs).
+    Some(id) if !id.is_empty() && !id.contains(['\\', '/']) && !id.chars().any(char::is_control) => id,
+    _ => return Some(Err("id must be the app id".into())),
+  };
+  Some(match op {
+    "autostart.status" => status(id).map(|s| format!(r#"{{"status":"{s}"}}"#)),
+    "autostart.enable" | "autostart.disable" => change(op, id),
+    _ => Err(format!("unknown op {op}")),
+  })
+}

package/vendor/@akanjs/native/native/desktop/src/win/camera.rs

@@ -0,0 +1,34 @@
+//! Camera permission for the camera plugin on Windows, answered like macOS's camera.rs with an
+//! AVAuthorizationStatus number (0 notDetermined, 1 restricted, 2 denied, 3 authorized):
+//!   camera.status  → {"status"}
+//!   camera.request → {"status"}   the same: desktop apps have no system prompt to show
+//! The switches of Settings › Privacy & security › Camera are the capability consent store,
+//! ...\CapabilityAccessManager\ConsentStore\webcam, whose "Value" is "Allow" or "Deny":
+//!   HKLM webcam            "Camera access" for the whole device (an administrator) → 1
+//!   HKCU webcam            "Camera access" for this user                           → 2
+//!   HKCU webcam\NonPackaged "Let desktop apps access your camera"                  → 2
+//! Otherwise WebView2 asks the user itself at getUserMedia and remembers the answer per origin
+//! (lib.rs permission handler), so the state is "prompt" (0) until then.
+
+use super::registry::{self, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE};
+
+const STORE: &str = r"Software\Microsoft\Windows\CurrentVersion\CapabilityAccessManager\ConsentStore\webcam";
+
+fn denied(root: windows::Win32::System::Registry::HKEY, key: &str) -> bool {
+  registry::read_string(root, key, "Value").ok().flatten().is_some_and(|v| v.eq_ignore_ascii_case("Deny"))
+}
+
+pub fn status() -> u32 {
+  if denied(HKEY_LOCAL_MACHINE, STORE) {
+    1
+  } else if denied(HKEY_CURRENT_USER, STORE) || denied(HKEY_CURRENT_USER, &format!(r"{STORE}\NonPackaged")) {
+    2
+  } else {
+    0
+  }
+}
+
+/// `camera.*` ops; None for other ops.
+pub fn shell_op(op: &str) -> Option<Result<String, String>> {
+  matches!(op, "camera.status" | "camera.request").then(|| Ok(format!(r#"{{"status":{}}}"#, status())))
+}

package/vendor/@akanjs/native/native/desktop/src/win/clipboard.rs

@@ -0,0 +1,106 @@
+//! Plain text on the Windows clipboard (clipboard plugin), on the main thread.
+//!   clipboard.writeText {text} → null
+//!   clipboard.readText         → {"text"}   "" when the clipboard holds no text
+//! CF_UNICODETEXT (UTF-16; Windows converts to and from CF_TEXT for older readers). Learned from
+//! arboard's Windows backend (src/platform/windows.rs: open with retries, a few ms apart, because
+//! another app may hold the clipboard for a moment) and electrobun's
+//! (package/src/native/win/nativeWrapper.cpp:12549-12625: the system owns the memory only after
+//! SetClipboardData succeeded). The calling window owns what the app copies: Microsoft documents
+//! that SetClipboardData fails after EmptyClipboard of a clipboard opened without an owner.
+
+use windows::Win32::Foundation::{GlobalFree, HANDLE, HGLOBAL, HWND};
+use windows::Win32::System::DataExchange::{CloseClipboard, EmptyClipboard, GetClipboardData, IsClipboardFormatAvailable, OpenClipboard, SetClipboardData};
+use windows::Win32::System::Memory::{GlobalAlloc, GlobalLock, GlobalSize, GlobalUnlock, GMEM_MOVEABLE};
+use windows::Win32::System::Ole::CF_UNICODETEXT;
+
+use crate::json;
+
+const ATTEMPTS: u32 = 10;
+
+/// Opens the clipboard and closes it when dropped.
+struct Open;
+
+impl Open {
+  fn new(owner: HWND) -> Result<Open, String> {
+    let mut last = String::new();
+    for attempt in 0..ATTEMPTS {
+      match unsafe { OpenClipboard(Some(owner)) } {
+        Ok(()) => return Ok(Open),
+        Err(e) => last = e.message(),
+      }
+      if attempt + 1 < ATTEMPTS {
+        std::thread::sleep(std::time::Duration::from_millis(5));
+      }
+    }
+    Err(format!("INTERNAL: another app holds the clipboard: {last}"))
+  }
+}
+
+impl Drop for Open {
+  fn drop(&mut self) {
+    unsafe {
+      let _ = CloseClipboard();
+    }
+  }
+}
+
+fn read(owner: HWND) -> Result<String, String> {
+  let format = CF_UNICODETEXT.0 as u32;
+  let _open = Open::new(owner)?;
+  if unsafe { IsClipboardFormatAvailable(format) }.is_err() {
+    return Ok(String::new()); // an image, files, or nothing
+  }
+  let handle = unsafe { GetClipboardData(format) }.map_err(|e| format!("INTERNAL: GetClipboardData failed: {}", e.message()))?;
+  let memory = HGLOBAL(handle.0);
+  let data = unsafe { GlobalLock(memory) } as *const u16;
+  if data.is_null() {
+    return Err("INTERNAL: the clipboard's text cannot be read".into());
+  }
+  // Up to the terminating NUL, never past the block.
+  let units = unsafe { GlobalSize(memory) } / 2;
+  let wide = unsafe { std::slice::from_raw_parts(data, units) };
+  let end = wide.iter().position(|&c| c == 0).unwrap_or(units);
+  let text = String::from_utf16_lossy(&wide[..end]);
+  unsafe {
+    let _ = GlobalUnlock(memory); // "fails" with NO_ERROR once unlocked
+  }
+  Ok(text)
+}
+
+fn write(owner: HWND, text: &str) -> Result<(), String> {
+  let wide: Vec<u16> = text.encode_utf16().chain(std::iter::once(0)).collect();
+  let memory = unsafe { GlobalAlloc(GMEM_MOVEABLE, wide.len() * 2) }.map_err(|e| format!("INTERNAL: GlobalAlloc failed: {}", e.message()))?;
+  unsafe {
+    let data = GlobalLock(memory) as *mut u16;
+    if data.is_null() {
+      let _ = GlobalFree(Some(memory));
+      return Err("INTERNAL: GlobalLock failed".into());
+    }
+    std::ptr::copy_nonoverlapping(wide.as_ptr(), data, wide.len());
+    let _ = GlobalUnlock(memory);
+  }
+  let result = Open::new(owner).and_then(|_open| {
+    unsafe { EmptyClipboard() }.map_err(|e| format!("INTERNAL: EmptyClipboard failed: {}", e.message()))?;
+    unsafe { SetClipboardData(CF_UNICODETEXT.0 as u32, Some(HANDLE(memory.0))) }.map_err(|e| format!("INTERNAL: SetClipboardData failed: {}", e.message()))?;
+    Ok(())
+  });
+  if result.is_err() {
+    unsafe {
+      let _ = GlobalFree(Some(memory)); // still ours
+    }
+  }
+  result
+}
+
+/// `clipboard.*` ops with the calling window as the owner; None for other ops.
+pub fn window_op(op: &str, cmd: &json::V, hwnd: isize) -> Option<Result<String, String>> {
+  let owner = HWND(hwnd as *mut _);
+  match op {
+    "clipboard.readText" => Some(read(owner).map(|text| format!(r#"{{"text":{}}}"#, json::quote(&text)))),
+    "clipboard.writeText" => Some(match cmd.get("text").and_then(|v| v.as_str()) {
+      Some(text) => write(owner, text).map(|()| "null".into()),
+      None => Err("text must be a string".into()),
+    }),
+    _ => None,
+  }
+}

package/vendor/@akanjs/native/native/desktop/src/win/device.rs

@@ -0,0 +1,80 @@
+//! What the device plugin reads on Windows through native code.
+//!   device.info     → {"manufacturer","model"}   the BIOS's SMBIOS names (HKLM\HARDWARE\DESCRIPTION\System\BIOS)
+//!   device.language → {"tag"}                   the first display language, GetUserPreferredUILanguages
+//!                                               (MUI_LANGUAGE_NAME), as sys-locale does for the Tauri os plugin
+//!   device.battery  → {"level","charging"}      GetSystemPowerStatus
+//!   webview.version → {"version"}               the WebView2 runtime, as wry's webview_version
+//!                                               (wry/src/webview2/mod.rs:1927-1931; gated behind a Linux feature)
+//! Unknown values are null.
+
+use webview2_com::Microsoft::Web::WebView2::Win32::GetAvailableCoreWebView2BrowserVersionString;
+use windows::core::{PCWSTR, PWSTR};
+use windows::Win32::Globalization::{GetUserPreferredUILanguages, MUI_LANGUAGE_NAME};
+use windows::Win32::System::Power::{GetSystemPowerStatus, SYSTEM_POWER_STATUS};
+
+use super::registry::{self, HKEY_LOCAL_MACHINE};
+use crate::json;
+
+const BIOS: &str = r"HARDWARE\DESCRIPTION\System\BIOS";
+
+fn quoted(value: Option<String>) -> String {
+  value.map(|v| v.trim().to_string()).filter(|v| !v.is_empty()).map_or_else(|| "null".into(), |v| json::quote(&v))
+}
+
+fn info() -> String {
+  let read = |name| registry::read_string(HKEY_LOCAL_MACHINE, BIOS, name).ok().flatten();
+  format!(r#"{{"manufacturer":{},"model":{}}}"#, quoted(read("SystemManufacturer")), quoted(read("SystemProductName")))
+}
+
+/// The user's display languages, most preferred first ("ko-KR", "en-US").
+fn languages() -> Vec<String> {
+  let (mut count, mut size) = (0u32, 0u32);
+  if unsafe { GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &mut count, None, &mut size) }.is_err() || size == 0 {
+    return Vec::new();
+  }
+  let mut buffer = vec![0u16; size as usize];
+  if unsafe { GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &mut count, Some(PWSTR(buffer.as_mut_ptr())), &mut size) }.is_err() {
+    return Vec::new();
+  }
+  // A double-NUL-terminated list.
+  buffer.split(|&c| c == 0).filter(|s| !s.is_empty()).map(String::from_utf16_lossy).collect()
+}
+
+/// SYSTEM_POWER_STATUS: BatteryFlag 128 = no system battery, 255 = unknown; BatteryLifePercent
+/// 255 = unknown; ACLineStatus 0 offline, 1 online, 255 unknown (WinBase.h).
+pub fn battery_json(status: &SYSTEM_POWER_STATUS) -> String {
+  if status.BatteryFlag == 255 || status.BatteryFlag & 128 != 0 {
+    return r#"{"level":null,"charging":null}"#.into();
+  }
+  let level = if status.BatteryLifePercent <= 100 { format!("{}", f64::from(status.BatteryLifePercent) / 100.0) } else { "null".into() };
+  let charging = match status.ACLineStatus {
+    0 => "false",
+    1 => "true",
+    _ => "null",
+  };
+  format!(r#"{{"level":{level},"charging":{charging}}}"#)
+}
+
+fn battery() -> Result<String, String> {
+  let mut status = SYSTEM_POWER_STATUS::default();
+  unsafe { GetSystemPowerStatus(&mut status) }.map_err(|e| format!("INTERNAL: GetSystemPowerStatus failed: {}", e.message()))?;
+  Ok(battery_json(&status))
+}
+
+/// The installed WebView2 runtime's version, e.g. "140.0.3485.54".
+pub(crate) fn webview_version() -> Option<String> {
+  let mut version = PWSTR::null();
+  unsafe { GetAvailableCoreWebView2BrowserVersionString(PCWSTR::null(), &mut version) }.ok()?;
+  Some(webview2_com::take_pwstr(version))
+}
+
+/// `device.*` and `webview.version`; None for other ops.
+pub fn shell_op(op: &str) -> Option<Result<String, String>> {
+  Some(match op {
+    "device.info" => Ok(info()),
+    "device.language" => Ok(format!(r#"{{"tag":{}}}"#, quoted(languages().into_iter().next()))),
+    "device.battery" => battery(),
+    "webview.version" => Ok(format!(r#"{{"version":{}}}"#, quoted(webview_version()))),
+    _ => return None,
+  })
+}