daniel.w
/
AnyBot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
AnyBot/src/botbrowser.rs

1023 lines
48 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// AnyBot's own browser window, like Grok Bot's own browser: a separate Chrome-family profile that
// AnyBot starts and talks to directly (Chrome's DevTools protocol on a local port), so reading
// and opening pages needs no browser setting ("允許來自 Apple 事件的 JavaScript") and no macOS
// "control this app" prompt. The person logs in to sites in this window once; the profile keeps it.
//
// Profiles (設定檔): the person's own Chrome profiles can't be used (macOS refuses other apps
// Chrome's data folder, and Chrome refuses remote control of its normal folder), so AnyBot's
// browser keeps its own: 「預設」 plus any the person or the bot adds (工作, 私人…). Each is its own
// browser folder and window with its own logins; switching picks which one the bot uses.
//
// Firefox works too (through WebDriver BiDi, bidi.rs): it runs AnyBot's own profiles on a
// computer without a Chrome-family browser, and the person's own Firefox profiles are choices
// as well (「阿金（Firefox）」, with their logins). Firefox can't be taken over once it's open, so
// AnyBot opens such a profile itself (the person closes its everyday window first).
use serde_json::Value;
use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::time::{Duration, Instant};
/// Local port for talking to the bot's browser (estimated; any free local port works).
pub const PORT: u16 = 9333;
/// How long to wait for the browser to come up (estimated).
const START_TIMEOUT_SECS: u64 = 20;
/// Firefox from a Snap can take much longer the first time after the computer starts (estimated).
const FIREFOX_START_TIMEOUT_SECS: u64 = 60;
/// The first profile: the browser folder made before profiles existed (its logins stay).
pub const DEFAULT_PROFILE: &str = "預設";
/// The person's own browser (read through accessibility, like Grok Bot's Computer Use helper):
/// whichever Chrome profile they have open there is the one read.
pub const PERSON_PROFILE: &str = "你的瀏覽器";
/// Other ways people name their own browser.
const PERSON_ALIASES: [&str; 6] = ["你的 chrome", "我的 chrome", "我的瀏覽器", "你的chrome", "我的chrome", "my chrome"];
/// Longest profile name (estimated).
pub const PROFILE_NAME_MAX_CHARS: usize = 30;
/// File Chrome writes into its folder with the port it chose (`--remote-debugging-port=0`).
const ACTIVE_PORT_FILE: &str = "DevToolsActivePort";
/// Chrome-family browsers that can be started as AnyBot's own window.
#[cfg(target_os = "macos")]
const CANDIDATES: &[(&str, &str)] = &[
("Google Chrome", "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
("Brave Browser", "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"),
("Microsoft Edge", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
("Chromium", "/Applications/Chromium.app/Contents/MacOS/Chromium"),
];
/// Linux: the usual install places (distribution packages, the vendors' .deb/.rpm, Snap, Flatpak).
#[cfg(not(target_os = "macos"))]
const CANDIDATES: &[(&str, &str)] = &[
("Google Chrome", "/usr/bin/google-chrome-stable"),
("Google Chrome", "/usr/bin/google-chrome"),
("Google Chrome", "/opt/google/chrome/chrome"),
("Brave Browser", "/usr/bin/brave-browser"),
("Brave Browser", "/opt/brave.com/brave/brave"),
("Microsoft Edge", "/usr/bin/microsoft-edge"),
("Chromium", "/usr/bin/chromium"),
("Chromium", "/usr/bin/chromium-browser"),
("Chromium", "/snap/bin/chromium"),
("Chromium", "/var/lib/flatpak/exports/bin/org.chromium.Chromium"),
];
pub fn engine() -> Option<(&'static str, &'static str)> {
CANDIDATES.iter().copied().find(|(_, p)| std::path::Path::new(p).exists())
}
/// Firefox: the usual install places (Snap first: Ubuntu's /usr/bin/firefox only hands over to it).
#[cfg(target_os = "macos")]
const FIREFOX: &[&str] = &["/Applications/Firefox.app/Contents/MacOS/firefox", "/Applications/Firefox Developer Edition.app/Contents/MacOS/firefox", "/Applications/Firefox Nightly.app/Contents/MacOS/firefox"];
#[cfg(not(target_os = "macos"))]
const FIREFOX: &[&str] = &["/snap/bin/firefox", "/usr/bin/firefox", "/usr/lib/firefox/firefox", "/opt/firefox/firefox", "/var/lib/flatpak/exports/bin/org.mozilla.firefox"];
pub fn firefox() -> Option<&'static str> {
FIREFOX.iter().copied().find(|p| std::path::Path::new(p).exists())
}
/// Which protocol a profile's browser speaks.
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum Kind {
/// Chrome, Brave, Edge, Chromium (and the box's Chromium): the DevTools protocol.
Chrome,
/// Firefox: WebDriver BiDi.
Firefox,
}
/// The browser that runs AnyBot's own profiles: a Chrome-family one when there is one, else
/// Firefox. (ANYBOT_BROWSER_ENGINE=firefox picks Firefox anyway, for testing.)
fn own_kind() -> Option<Kind> {
let want_firefox = std::env::var("ANYBOT_BROWSER_ENGINE").map(|e| e.eq_ignore_ascii_case("firefox")).unwrap_or(false);
match (engine().is_some(), firefox().is_some()) {
(_, true) if want_firefox => Some(Kind::Firefox),
(true, _) => Some(Kind::Chrome),
(false, true) => Some(Kind::Firefox),
(false, false) => None,
}
}
pub fn available() -> bool {
if using_box() {
return true;
}
own_kind().is_some()
}
/// How the person's own Firefox profiles are listed: 「阿金（Firefox）」.
pub const FIREFOX_MARK: &str = "（Firefox）";
/// Where Firefox keeps its profiles on this computer (packaged as Snap or Flatpak too).
fn firefox_roots() -> Vec<PathBuf> {
let Some(home) = dirs::home_dir() else { return vec![] };
if cfg!(target_os = "macos") {
vec![home.join("Library/Application Support/Firefox")]
} else {
vec![home.join(".mozilla/firefox"), home.join(".config/mozilla/firefox"), home.join("snap/firefox/common/.mozilla/firefox"), home.join(".var/app/org.mozilla.firefox/.mozilla/firefox")]
}
}
/// profiles.ini's profiles: (name, folder).
fn ini_profiles(root: &std::path::Path, ini: &str) -> Vec<(String, PathBuf)> {
let mut out = vec![];
let (mut name, mut path, mut relative, mut in_profile) = (String::new(), String::new(), true, false);
let mut flush = |name: &mut String, path: &mut String, relative: bool| {
if !name.is_empty() && !path.is_empty() {
out.push((std::mem::take(name), if relative { root.join(&*path) } else { PathBuf::from(&*path) }));
}
name.clear();
path.clear();
};
for line in ini.lines().map(str::trim) {
if line.starts_with('[') {
flush(&mut name, &mut path, relative);
in_profile = line.starts_with("[Profile");
relative = true;
} else if in_profile {
match line.split_once('=') {
Some(("Name", v)) => name = v.to_string(),
Some(("Path", v)) => path = v.to_string(),
Some(("IsRelative", v)) => relative = v != "0",
_ => {}
}
}
}
flush(&mut name, &mut path, relative);
out
}
/// The newer profile switcher's profiles (Firefox 138+): their names live only in
/// 「Profile Groups/<id>.sqlite」. Read from a copy (Firefox keeps the file open and busy).
fn group_profiles(root: &std::path::Path) -> Vec<(String, PathBuf)> {
let Ok(files) = std::fs::read_dir(root.join("Profile Groups")) else { return vec![] };
let mut out = vec![];
for db in files.flatten().map(|e| e.path()).filter(|p| p.extension().and_then(|e| e.to_str()) == Some("sqlite")) {
let tmp = std::env::temp_dir().join(format!("anybot-ff-{}-{}", std::process::id(), crate::httpd::random_hex(4)));
if std::fs::create_dir_all(&tmp).is_err() {
continue;
}
let copy = tmp.join("groups.sqlite");
let read = || -> rusqlite::Result<Vec<(String, String)>> {
let c = rusqlite::Connection::open(&copy)?;
let mut q = c.prepare("SELECT path, name FROM Profiles")?;
let rows = q.query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, String>(1)?)))?;
rows.collect()
};
let copied = std::fs::copy(&db, &copy).is_ok();
// Recent changes may still be in the write-ahead log beside it.
let _ = std::fs::copy(db.with_extension("sqlite-wal"), tmp.join("groups.sqlite-wal"));
for (path, name) in if copied { read().unwrap_or_default() } else { vec![] } {
let p = PathBuf::from(&path);
out.push((name, if p.is_absolute() { p } else { root.join(p) }));
}
let _ = std::fs::remove_dir_all(&tmp);
}
out
}
/// The person's own Firefox profiles (name, folder), as Firefox lists them. Looked up at most
/// every few seconds (the tool list asks for it at every step).
pub fn firefox_profiles() -> Vec<(String, PathBuf)> {
type Found = Vec<(String, PathBuf)>;
static CACHE: std::sync::Mutex<Option<(Instant, Found)>> = std::sync::Mutex::new(None);
let mut c = CACHE.lock().unwrap_or_else(|e| e.into_inner());
if let Some((at, list)) = c.as_ref() {
if at.elapsed() < Duration::from_secs(10) {
return list.clone();
}
}
let mut list: Vec<(String, PathBuf)> = vec![];
for root in firefox_roots().iter().filter(|r| r.is_dir()) {
let ini = std::fs::read_to_string(root.join("profiles.ini")).unwrap_or_default();
// A name from the profile switcher wins over profiles.ini's (often just "default").
for (name, dir) in group_profiles(root).into_iter().chain(ini_profiles(root, &ini)) {
if !dir.is_dir() || list.iter().any(|(_, d)| *d == dir) {
continue;
}
let name = name.trim().to_string();
let mut unique = name.clone();
let mut n = 2;
while list.iter().any(|(m, _)| *m == unique) {
unique = format!("{name} {n}");
n += 1;
}
list.push((unique, dir));
}
}
*c = Some((Instant::now(), list.clone()));
list
}
/// A Snap or Flatpak Firefox only reaches its own corner of the home folder: AnyBot's own
/// Firefox profiles live there.
fn firefox_own_root() -> PathBuf {
let bin = firefox().unwrap_or("");
let home = dirs::home_dir().unwrap_or_default();
if bin.starts_with("/snap/") || (bin == "/usr/bin/firefox" && std::path::Path::new("/snap/bin/firefox").exists()) {
home.join("snap/firefox/common/AnyBot")
} else if bin.contains("flatpak") {
home.join(".var/app/org.mozilla.firefox/AnyBot")
} else {
data_dir().join("firefox-profiles")
}
}
/// Where a profile runs: its browser and its folder.
fn place(name: &str) -> Option<(Kind, PathBuf)> {
if let Some(own) = name.strip_suffix(FIREFOX_MARK) {
return firefox_profiles().into_iter().find(|(n, _)| n == own).map(|(_, d)| (Kind::Firefox, d));
}
match own_kind()? {
Kind::Firefox => Some((Kind::Firefox, firefox_own_root().join(name))),
Kind::Chrome => Some((Kind::Chrome, dir_for(name))),
}
}
/// The protocol of a profile's browser (the box's Chromium is Chrome).
pub fn kind_of(profile: Option<&str>) -> Kind {
if using_box() {
return Kind::Chrome;
}
resolve(profile).ok().and_then(|n| place(&n)).map(|(k, _)| k).unwrap_or(Kind::Chrome)
}
/// Is this Firefox profile open (by anyone)? Firefox holds a lock in it while it runs.
fn firefox_in_use(dir: &std::path::Path) -> bool {
#[cfg(target_os = "linux")]
{
// "lock" → "host:+pid" while it runs (left behind after a crash: then the pid is gone).
std::fs::read_link(dir.join("lock")).ok().and_then(|t| t.to_string_lossy().rsplit('+').next().and_then(|p| p.parse::<u32>().ok())).is_some_and(|pid| std::path::Path::new(&format!("/proc/{pid}")).exists())
}
#[cfg(target_os = "macos")]
{
Command::new("lsof").arg("-t").arg(dir.join(".parentlock")).output().map(|o| !o.stdout.is_empty()).unwrap_or(false)
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
{
let _ = dir;
false
}
}
/// The port AnyBot can drive this Firefox profile on (it was started for AnyBot), if it's open.
fn firefox_port(dir: &std::path::Path) -> Option<u16> {
let v: Value = serde_json::from_str(&std::fs::read_to_string(dir.join(FIREFOX_PORT_FILE)).ok()?).ok()?;
let port = u16::try_from(v["ws_port"].as_u64()?).ok().filter(|p| *p != 0)?;
// The file outlives a crash: only a running profile with that port open counts.
let addr = std::net::SocketAddr::from(([127, 0, 0, 1], port));
(firefox_in_use(dir) && std::net::TcpStream::connect_timeout(&addr, Duration::from_millis(500)).is_ok()).then_some(port)
}
/// File Firefox writes into its profile with the BiDi port it chose (`--remote-debugging-port 0`).
const FIREFOX_PORT_FILE: &str = "WebDriverBiDiServer.json";
fn data_dir() -> PathBuf {
crate::model::State::path().parent().map(PathBuf::from).unwrap_or_else(std::env::temp_dir)
}
/// The 「預設」 profile lives with AnyBot's data (logins stay between runs).
pub fn profile_dir() -> PathBuf {
data_dir().join("browser")
}
fn profiles_root() -> PathBuf {
data_dir().join("browser-profiles")
}
fn dir_for(name: &str) -> PathBuf {
if name == DEFAULT_PROFILE { profile_dir() } else { profiles_root().join(name) }
}
/// All profiles: 「預設」 first, then the added ones by name.
pub fn profiles() -> Vec<String> {
let mut extra: Vec<String> = std::fs::read_dir(profiles_root())
.map(|it| it.flatten().filter(|e| e.path().is_dir()).filter_map(|e| e.file_name().to_str().map(str::to_string)).collect())
.unwrap_or_default();
extra.sort();
let mut all = vec![DEFAULT_PROFILE.to_string()];
all.extend(extra.into_iter().filter(|n| n != DEFAULT_PROFILE));
all
}
fn current_file() -> PathBuf {
data_dir().join("browser-profile.txt")
}
/// Every choice: AnyBot's own profiles, the person's own Firefox profiles, then the person's
/// own browser.
pub fn choices() -> Vec<String> {
let mut all = profiles();
if firefox().is_some() {
all.extend(firefox_profiles().into_iter().map(|(n, _)| format!("{n}{FIREFOX_MARK}")));
}
// Reading the person's own browser goes through macOS accessibility; not on Linux.
if cfg!(target_os = "macos") {
all.push(PERSON_PROFILE.to_string());
}
all
}
/// The profile the bot uses when it isn't told which.
pub fn current() -> String {
let want = std::fs::read_to_string(current_file()).unwrap_or_default().trim().to_string();
match_profile(&choices(), &want).unwrap_or_else(|| DEFAULT_PROFILE.to_string())
}
pub fn set_current(name: &str) -> Result<String, String> {
let name = resolve(Some(name))?;
std::fs::write(current_file(), &name).map_err(|e| format!("存不了設定檔選擇：{e}"))?;
Ok(name)
}
/// Find a profile by name, ignoring case and spaces at the ends.
pub fn match_profile(list: &[String], want: &str) -> Option<String> {
let w = want.trim().to_lowercase();
if w.is_empty() {
return None;
}
if PERSON_ALIASES.contains(&w.as_str()) && list.iter().any(|n| n == PERSON_PROFILE) {
return Some(PERSON_PROFILE.to_string());
}
if let Some(n) = list.iter().find(|n| n.to_lowercase() == w) {
return Some(n.clone());
}
// A Firefox profile by its own name (「阿金」, 「Firefox 阿金」 for 「阿金（Firefox）」), when
// only one has it.
let bare = |s: &str| s.to_lowercase().replace(&FIREFOX_MARK.to_lowercase(), "").replace("(firefox)", "").replace("firefox", "").replace(['：', ':'], "").trim().to_string();
let b = bare(&w);
let hits: Vec<&String> = list.iter().filter(|n| n.ends_with(FIREFOX_MARK) && !b.is_empty() && bare(n) == b).collect();
(hits.len() == 1).then(|| hits[0].clone())
}
/// Which profile a tool call means: the one named, or the current one.
pub fn resolve(requested: Option<&str>) -> Result<String, String> {
if using_box() {
return Ok(DEFAULT_PROFILE.to_string());
}
match requested.map(str::trim).filter(|s| !s.is_empty()) {
None => Ok(current()),
Some(r) => {
let all = choices();
match_profile(&all, r).ok_or_else(|| format!("AnyBot 瀏覽器沒有叫「{r}」的設定檔。現有：{}。要新的可以用 browser_profiles 新增（action: add）。", all.join("、")))
}
}
}
/// A usable profile name: not empty, not too long, no slashes or dots-only names.
pub fn check_name(name: &str) -> Result<String, String> {
let n = name.trim();
if n.is_empty() {
return Err("請給設定檔名稱".into());
}
if n.chars().count() > PROFILE_NAME_MAX_CHARS {
return Err(format!("設定檔名稱最多 {PROFILE_NAME_MAX_CHARS} 個字"));
}
if n == PERSON_PROFILE || PERSON_ALIASES.contains(&n.to_lowercase().as_str()) {
return Err(format!("「{n}」是留給你自己瀏覽器的名字，請換一個"));
}
if n.contains('/') || n.contains(':') || n.starts_with('.') || n.chars().any(char::is_control) {
return Err("設定檔名稱不能有 / 或 : 也不能用 . 開頭".into());
}
if n.to_lowercase().contains("firefox") {
return Err("名字裡有 Firefox 的是你自己的 Firefox 設定檔，請換一個名字".into());
}
Ok(n.to_string())
}
/// Make a new empty profile (its own folder, so its own logins).
pub fn add(name: &str) -> Result<String, String> {
let n = check_name(name)?;
if let Some(have) = match_profile(&profiles(), &n) {
return Ok(have);
}
std::fs::create_dir_all(profiles_root().join(&n)).map_err(|e| format!("建不了設定檔：{e}"))?;
Ok(n)
}
/// Remove an added profile and its logins (the person's choice, from Settings). 「預設」 and the
/// person's own browser can't be removed, and an open window must be closed first.
pub fn remove(name: &str) -> Result<(), String> {
let all = profiles();
let n = match_profile(&all, name).ok_or_else(|| format!("沒有叫「{name}」的設定檔"))?;
if n == DEFAULT_PROFILE || n == PERSON_PROFILE {
return Err(format!("「{n}」不能移除"));
}
if n.ends_with(FIREFOX_MARK) {
return Err(format!("「{n}」是你自己的 Firefox 設定檔，AnyBot 不會移除它（要刪請在 Firefox 裡刪）"));
}
if live_port(&n).is_some() {
return Err(format!("「{n}」的視窗還開著，請先關掉它再移除。"));
}
let dir = profiles_root().join(&n);
// Only ever a folder directly inside AnyBot's browser-profiles folder.
if dir.parent() != Some(profiles_root().as_path()) {
return Err("設定檔位置不對，沒有移除".into());
}
std::fs::remove_dir_all(&dir).map_err(|e| format!("移除不了「{n}」：{e}"))?;
if current() == n || !choices().contains(&current()) {
let _ = std::fs::write(current_file(), DEFAULT_PROFILE);
}
Ok(())
}
pub(crate) fn local() -> ureq::Agent {
ureq::Agent::config_builder().timeout_global(Some(Duration::from_secs(5))).http_status_as_error(false).build().into()
}
/// The fixed port of 「預設」 (`ANYBOT_BROWSER_PORT` overrides it, for testing).
fn default_port() -> u16 {
std::env::var("ANYBOT_BROWSER_PORT").ok().and_then(|p| p.parse().ok()).unwrap_or(PORT)
}
fn endpoint(port: u16, path: &str) -> String {
format!("http://127.0.0.1:{port}{path}")
}
fn alive(port: u16) -> bool {
port != 0 && local().get(&endpoint(port, "/json/version")).call().map(|r| r.status().as_u16() == 200).unwrap_or(false)
}
/// First line of Chrome's DevToolsActivePort file.
pub fn parse_active_port(text: &str) -> Option<u16> {
text.lines().next()?.trim().parse().ok().filter(|p| *p != 0)
}
/// The port a running window of this profile answers on, if any.
fn live_port(name: &str) -> Option<u16> {
if let Some((Kind::Firefox, dir)) = place(name) {
return firefox_port(&dir);
}
let file = std::fs::read_to_string(dir_for(name).join(ACTIVE_PORT_FILE)).ok().and_then(|t| parse_active_port(&t));
let fixed = (name == DEFAULT_PROFILE).then(default_port);
[fixed, file].into_iter().flatten().find(|p| alive(*p))
}
/// Percent-encode a URL so it can ride in `/json/new?<url>`.
pub fn encode_component(s: &str) -> String {
s.bytes()
.map(|b| match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' | b':' | b'/' => (b as char).to_string(),
_ => format!("%{b:02X}"),
})
.collect()
}
thread_local! {
/// Browser steps on this thread go to Bot 的電腦's Chromium (its box), not this computer's.
static IN_BOX: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}
/// Run `f` with the browser steps on Bot 的電腦's own Chromium.
pub fn in_box<T>(f: impl FnOnce() -> T) -> T {
IN_BOX.with(|b| b.set(true));
let r = f();
IN_BOX.with(|b| b.set(false));
r
}
pub fn using_box() -> bool {
IN_BOX.with(|b| b.get())
}
/// The debugging port of a bot browser that is already open (None when it isn't; never starts one).
pub fn running_port(profile: Option<&str>) -> Option<u16> {
if using_box() {
return crate::cloudbox::browser_running().then(crate::cloudbox::browser_port).and_then(Result::ok);
}
live_port(&resolve(profile).ok()?)
}
// ---------- each job its own tabs ----------
// Bots share a browser (the box's Chromium has one profile for all of them). Every step used to
// act on the tab in front, so two jobs at once read and clicked on each other's pages, and one
// finishing closed the other's. A job now owns the tabs it opens or lands on (a popup it clicked
// open too): its steps use the latest of those, and another job's tabs are never used, listed
// or closed by it.
thread_local! {
/// The job whose browser step runs on this thread (empty: not a bot's job).
static JOB: std::cell::RefCell<String> = const { std::cell::RefCell::new(String::new()) };
}
/// (tab id, job) for the tabs running jobs own.
static OWNERS: std::sync::Mutex<Vec<(String, String)>> = std::sync::Mutex::new(Vec::new());
/// Run `f` as a step of job `job` (on its own tabs).
pub fn as_job<T>(job: &str, f: impl FnOnce() -> T) -> T {
let before = JOB.with(|j| std::mem::replace(&mut *j.borrow_mut(), job.to_string()));
let r = f();
JOB.with(|j| *j.borrow_mut() = before);
r
}
pub fn job() -> String {
JOB.with(|j| j.borrow().clone())
}
fn owner(tab: &str) -> Option<String> {
OWNERS.lock().unwrap_or_else(|e| e.into_inner()).iter().find(|(t, _)| t == tab).map(|(_, j)| j.clone())
}
/// Another running job owns this tab.
pub fn others_tab(tab: &str) -> bool {
owner(tab).is_some_and(|j| j != job())
}
/// This step's job takes the tab, when it is nobody's.
pub fn claim(tab: &str) {
let me = job();
if me.is_empty() || tab.is_empty() {
return;
}
let mut o = OWNERS.lock().unwrap_or_else(|e| e.into_inner());
if !o.iter().any(|(t, _)| t == tab) {
o.push((tab.to_string(), me));
}
}
/// The job is over: its tabs are nobody's again (returned).
pub fn release(job: &str) -> Vec<String> {
let mut o = OWNERS.lock().unwrap_or_else(|e| e.into_inner());
let mine = o.iter().filter(|(_, j)| j == job).map(|(t, _)| t.clone()).collect();
o.retain(|(_, j)| j != job);
mine
}
/// The tab of a page list (latest-used first) this step works on: its job's latest own tab, else
/// the latest one no other job owns (a job's first step).
pub fn pick_tab(list: &[Value]) -> Option<&Value> {
let me = job();
let id = |t: &Value| t["id"].as_str().unwrap_or("").to_string();
if !me.is_empty() {
if let Some(t) = list.iter().find(|t| owner(&id(t)).as_deref() == Some(me.as_str())) {
return Some(t);
}
}
list.iter().find(|t| !others_tab(&id(t)))
}
/// The open page tabs' ids (none when the browser isn't open; it isn't started for this).
pub fn tab_ids(profile: Option<&str>) -> Vec<String> {
let Some(port) = running_port(profile) else { return vec![] };
pages_of(kind_of(profile), port).unwrap_or_default().iter().filter_map(|t| t["id"].as_str().map(String::from)).collect()
}
// ---------- tabs, whichever the browser ----------
/// The open page tabs ({id, url, title}), the one in use first.
pub fn pages_of(kind: Kind, port: u16) -> Result<Vec<Value>, String> {
match kind {
Kind::Firefox => crate::bidi::pages(port),
Kind::Chrome => {
let v: Value = local().get(&endpoint(port, "/json/list")).call().map_err(|e| e.to_string())?.into_body().read_json().map_err(|e| e.to_string())?;
Ok(crate::browser::pages(&v))
}
}
}
/// Open a tab at `url`. Returns its id.
pub fn new_tab(kind: Kind, port: u16, url: &str) -> Result<String, String> {
match kind {
Kind::Firefox => crate::bidi::new_tab(port, url),
Kind::Chrome => {
let r = local().put(&endpoint(port, &format!("/json/new?{}", encode_component(url)))).send_empty().map_err(|e| e.to_string())?;
if r.status().as_u16() >= 400 {
return Err(format!("瀏覽器沒辦法開新分頁（{}）", r.status()));
}
let made: Value = r.into_body().read_json().unwrap_or_default();
Ok(made["id"].as_str().unwrap_or("").to_string())
}
}
}
pub fn activate_tab(kind: Kind, port: u16, id: &str) -> Result<(), String> {
match kind {
Kind::Firefox => crate::bidi::activate(port, id),
Kind::Chrome => local().get(&endpoint(port, &format!("/json/activate/{id}"))).call().map(|_| ()).map_err(|e| e.to_string()),
}
}
pub fn close_tab(kind: Kind, port: u16, id: &str) -> Result<(), String> {
match kind {
Kind::Firefox => crate::bidi::close(port, id),
Kind::Chrome => local().get(&endpoint(port, &format!("/json/close/{id}"))).call().map(|_| ()).map_err(|e| e.to_string()),
}
}
/// Tabs that appeared during this step (a popup a click opened) are its job's.
pub fn adopt_new(profile: Option<&str>, before: &[String]) {
if job().is_empty() {
return;
}
for id in tab_ids(profile) {
if !before.contains(&id) {
claim(&id);
}
}
}
/// Start this profile's window if it isn't running. Returns (browser name, port, just started).
pub fn ensure(profile: &str, first_url: Option<&str>) -> Result<(&'static str, u16, bool), String> {
if using_box() {
let fresh = !crate::cloudbox::browser_running();
let port = crate::cloudbox::browser_port()?;
if fresh {
if let Some(u) = first_url {
let _ = local().put(&endpoint(port, &format!("/json/new?{}", encode_component(u)))).send_empty();
}
}
return Ok(("它桌面上的 Chromium", port, fresh && first_url.is_some()));
}
if profile == PERSON_PROFILE {
return Err("「你的瀏覽器」是你自己的視窗，AnyBot 不會另外開。".into());
}
if let Some((Kind::Firefox, dir)) = place(profile) {
return ensure_firefox(profile, &dir, first_url);
}
let Some((name, bin)) = engine() else { return Err("這台電腦沒有 Chrome、Brave、Edge、Chromium 或 Firefox，沒辦法開 AnyBot 自己的瀏覽器。".into()) };
if let Some(p) = live_port(profile) {
return Ok((name, p, false));
}
let dir = dir_for(profile);
let _ = std::fs::create_dir_all(&dir);
let _ = std::fs::remove_file(dir.join(ACTIVE_PORT_FILE));
// 「預設」 keeps its fixed port; other profiles let Chrome pick a free one and read it back.
let launch_port = if profile == DEFAULT_PROFILE { default_port() } else { 0 };
// Defense in depth: this becomes a Chrome launch argument. Every caller normalizes to a
// full URL first; a bare "-…" (a Chrome flag) must never get here from a tool argument.
let url = match first_url {
Some(u) if u.starts_with("http://") || u.starts_with("https://") => u,
Some(_) => return Err("第一個網址必須是 http(s) 網址".into()),
None => "about:blank",
};
let mut c = Command::new(bin);
c.arg(format!("--user-data-dir={}", dir.display()))
.arg(format!("--remote-debugging-port={launch_port}"))
.arg("--remote-allow-origins=http://127.0.0.1")
.arg("--no-first-run")
.arg("--no-default-browser-check")
.arg(url)
.stdin(Stdio::null())
.stdout(Stdio::null())
.stderr(Stdio::null());
#[cfg(unix)]
{
use std::os::unix::process::CommandExt;
c.process_group(0);
}
c.spawn().map_err(|e| format!("打不開 {name}：{e}"))?;
let start = Instant::now();
while start.elapsed() < Duration::from_secs(START_TIMEOUT_SECS) {
if let Some(p) = live_port(profile) {
return Ok((name, p, true));
}
std::thread::sleep(Duration::from_millis(250));
}
Err(format!("{name} 沒有及時打開（AnyBot 瀏覽器，設定檔「{profile}」）。請再試一次。"))
}
/// Start a Firefox profile so AnyBot can drive it (WebDriver BiDi on a port Firefox picks).
fn ensure_firefox(profile: &str, dir: &std::path::Path, first_url: Option<&str>) -> Result<(&'static str, u16, bool), String> {
let bin = firefox().ok_or("這台電腦沒有 Firefox")?;
if let Some(p) = firefox_port(dir) {
return Ok(("Firefox", p, false));
}
// Open the everyday way: Firefox can't be taken over then, and a second copy of the same
// profile won't start.
if firefox_in_use(dir) {
return Err(format!("「{profile}」的 Firefox 視窗已經開著，但不是 AnyBot 打開的，AnyBot 沒辦法操作它。請使用者先關掉這個設定檔的 Firefox 視窗（登入都會留著），再讓 AnyBot 打開它；之後要用這個設定檔時，從 AnyBot 打開（設定 › 瀏覽器設定檔 › 開啟視窗）。"));
}
let _ = std::fs::create_dir_all(dir);
let _ = std::fs::remove_file(dir.join(FIREFOX_PORT_FILE));
// Defense in depth, as for Chrome: never a bare "-…" (a Firefox flag) from a tool argument.
let url = match first_url {
Some(u) if u.starts_with("http://") || u.starts_with("https://") => u,
Some(_) => return Err("第一個網址必須是 http(s) 網址".into()),
None => "about:blank",
};
let mut c = Command::new(bin);
c.arg("--new-instance").arg("--profile").arg(dir).arg("--remote-debugging-port").arg("0");
if std::env::var_os("ANYBOT_FIREFOX_HEADLESS").is_some() {
c.arg("--headless");
}
c.arg(url).stdin(Stdio::null()).stdout(Stdio::null()).stderr(Stdio::null());
#[cfg(unix)]
{
use std::os::unix::process::CommandExt;
c.process_group(0);
}
c.spawn().map_err(|e| format!("打不開 Firefox：{e}"))?;
let start = Instant::now();
while start.elapsed() < Duration::from_secs(FIREFOX_START_TIMEOUT_SECS) {
if let Some(p) = firefox_port(dir) {
return Ok(("Firefox", p, true));
}
std::thread::sleep(Duration::from_millis(250));
}
Err(format!("Firefox 沒有及時打開（設定檔「{profile}」）。請再試一次。"))
}
/// Open a link in a new tab of the bot's browser (in the named profile, which becomes current).
pub fn open(url: &str, profile: Option<&str>) -> Result<String, String> {
let prof = resolve(profile)?;
let _ = set_current(&prof);
let (name, port, fresh) = ensure(&prof, Some(url))?;
if !fresh {
let kind = kind_of(Some(&prof));
let id = new_tab(kind, port, url).map_err(|e| format!("{name} 沒辦法開新分頁：{e}"))?;
// The new tab is this job's (its next steps work there, not on another job's tab).
claim(&id);
close_old_tabs(kind, port);
}
// Back when the page has loaded (not after a fixed 3 s: a slow page was still blank then),
// with what it shows — the same as browser_read, one step fewer for every page.
let loaded = crate::browser::wait_loaded(Some(&prof), OPEN_WAIT_MS);
let page = read(PAGE_CHARS_ON_OPEN, Some(&prof)).unwrap_or_default();
let head = format!("已在 AnyBot 瀏覽器（{name}，設定檔「{prof}」）打開 {url}{}", if loaded { "。" } else { "，還在載入（可以用 browser_wait 等它，再 browser_read）。" });
Ok(if page.is_empty() { head } else { format!("{head}\n\n{page}") })
}
/// Most tabs the bot's browser keeps. Every browser_open is a new tab and nothing closed them:
/// Bot 的電腦 once had 19 Threads pages open and its whole 2 GB in use (estimated).
const MAX_TABS: usize = 6;
/// Close the tabs past MAX_TABS that were used longest ago (the list has the latest first).
fn close_old_tabs(kind: Kind, port: u16) {
let Ok(list) = pages_of(kind, port) else { return };
for id in old_tabs(&Value::Array(list), |id| !others_tab(id)) {
let _ = close_tab(kind, port, &id);
}
}
/// The page tabs past MAX_TABS in a /json/list answer (latest-used first), among those `ours`
/// says may be closed (never another job's).
fn old_tabs(list: &Value, ours: impl Fn(&str) -> bool) -> Vec<String> {
list.as_array().map(|a| a.iter().filter(|t| t["type"] == "page").filter_map(|t| t["id"].as_str()).filter(|id| ours(id)).skip(MAX_TABS).map(String::from).collect()).unwrap_or_default()
}
/// Longest wait for a page browser_open opened (estimated).
const OPEN_WAIT_MS: u64 = 12_000;
/// Text of the page handed back by browser_open (browser_read gives more when asked).
const PAGE_CHARS_ON_OPEN: usize = 12_000;
/// Bring a profile's window up (Settings button): start it, or bring its front tab forward.
pub fn show(profile: &str) -> Result<(), String> {
let (_, port, fresh) = ensure(profile, None)?;
if fresh {
return Ok(());
}
let kind = kind_of(Some(profile));
let list = pages_of(kind, port)?;
match list.first().and_then(|t| t["id"].as_str()) {
Some(id) => activate_tab(kind, port, id),
None => new_tab(kind, port, "about:blank").map(|_| ()),
}
}
/// The browser_profiles tool: list, add or switch profiles.
pub fn profiles_tool(action: &str, name: &str) -> Result<String, String> {
let list_text = || {
let cur = current();
choices().iter().map(|p| if *p == cur { format!("{p}（使用中）") } else { p.clone() }).collect::<Vec<_>>().join("、")
};
match action.trim() {
"" | "list" => Ok(format!(
"AnyBot 瀏覽器的設定檔：{}。每個設定檔有自己的登入。{}{}",
list_text(),
if choices().iter().any(|c| c.ends_with(FIREFOX_MARK)) { format!("名字後面有「{FIREFOX_MARK}」的是使用者自己的 Firefox 設定檔（用使用者的登入），AnyBot 會用可以操作的方式打開它；如果使用者已經用一般方式開著那個設定檔，要先請使用者關掉那個視窗。") } else { String::new() },
if choices().iter().any(|c| c == PERSON_PROFILE) { format!("「{PERSON_PROFILE}」是使用者平常的瀏覽器：使用者在那裡切到哪個 Chrome 設定檔，就讀哪個。") } else { String::new() }
)),
"add" | "create" => {
let n = add(name)?;
set_current(&n)?;
Ok(format!("已新增並切換到設定檔「{n}」（全新的，還沒登入任何網站）。用 browser_open 打開網站後，請使用者在那個視窗登入一次。現在：{}", list_text()))
}
"use" | "switch" => {
let n = set_current(name)?;
let note = if n == PERSON_PROFILE { "（使用者平常的瀏覽器：請使用者在那裡切到想要的 Chrome 設定檔）" } else { "" };
Ok(format!("已切換到「{n}」{note}，之後的 browser_open / browser_read 都用它。現在：{}", list_text()))
}
other => Err(format!("不懂「{other}」，action 請用 list、add 或 use")),
}
}
/// Run JavaScript in the current tab of the bot's browser. Returns (address, result).
pub fn eval_current(profile: Option<&str>, expression: &str) -> Result<(String, Value), String> {
let mut tab = crate::browser::Tab::current(profile)?;
let url = tab.eval("location.href")?.as_str().unwrap_or("").to_string();
let v = tab.eval(expression)?;
Ok((url, v))
}
const READ_EXPR: &str = "JSON.stringify({t:document.title,u:location.href,x:document.body?document.body.innerText:''})";
/// Title, address and visible text of the current tab of the bot's browser.
pub fn read(max_chars: usize, profile: Option<&str>) -> Result<String, String> {
let prof = resolve(profile)?;
let (name, _, _) = ensure(&prof, None)?;
// One connection to the tab for the text and the numbered elements.
let mut tab = crate::browser::Tab::current(Some(&prof))?;
let v = tab.eval(READ_EXPR)?;
let page: Value = v.as_str().and_then(|s| serde_json::from_str(s).ok()).unwrap_or(Value::Null);
let text: String = page["x"].as_str().unwrap_or("").lines().map(str::trim).filter(|l| !l.is_empty()).collect::<Vec<_>>().join("\n");
let title = page["t"].as_str().unwrap_or("").to_string();
let url = page["u"].as_str().unwrap_or("").to_string();
let mut clipped: String = text.chars().take(max_chars).collect();
if text.chars().count() > max_chars {
clipped.push_str("\n…（後面還有，已截斷）");
}
let login_hint = {
let l = clipped.to_lowercase();
(l.contains("log in") || l.contains("sign in") || clipped.contains("登入")) && clipped.chars().count() < 1500
};
let mut out = format!("瀏覽器：AnyBot 瀏覽器（{name}，設定檔「{prof}」）\n標題：{title}\n網址：{url}\n\n{clipped}");
// The links, buttons and fields, numbered for browser_click / browser_type / browser_select.
if let Ok((_, _, list, _)) = crate::browser::elements(&mut tab) {
if !list.is_empty() {
out.push_str("\n\n可以操作的元素（用 browser_click、browser_type、browser_select 等工具的 ref；連結的網址在 → 後面，不要自己猜網址；看不懂時用 browser_screenshot）：\n");
out.push_str(&list.join("\n"));
}
}
if login_hint {
out.push_str("\n\n（這頁看起來要登入。請使用者在 AnyBot 瀏覽器視窗登入一次，之後就會記住。）");
}
// A blank tab says nothing about a site (a bot read one eleven times and called the person
// logged out of Threads without ever opening it).
if url.is_empty() || url == "about:blank" || url.starts_with("chrome://newtab") {
out.push_str("\n\n（這個分頁是空白的，不代表任何網站的狀態。要看哪個網站（例如有沒有登入），就用 browser_open 打開它。）");
}
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
/// Live check against a running Chrome on ANYBOT_BROWSER_PORT (run by hand with --ignored).
#[test]
#[ignore]
fn reads_a_real_page() {
// Opening hands back the loaded page itself (no browser_read needed).
let r = open("https://example.com", None).unwrap();
assert!(r.contains("example.com") && r.contains("Example Domain") && r.contains("[1] 連結"), "{r}");
let page = read(2000, None).unwrap();
assert!(page.contains("Example Domain"), "{page}");
println!("{page}");
}
#[test]
fn only_the_tabs_used_longest_ago_close() {
let mut list: Vec<Value> = (0..9).map(|i| serde_json::json!({"type": "page", "id": format!("p{i}")})).collect();
list.insert(2, serde_json::json!({"type": "browser_ui", "id": "ui"}));
list.insert(4, serde_json::json!({"type": "service_worker", "id": "sw"}));
assert_eq!(old_tabs(&Value::Array(list.clone()), |_| true), vec!["p6", "p7", "p8"]);
// Another job's tabs don't count and are never closed.
assert_eq!(old_tabs(&Value::Array(list.clone()), |id| id != "p0" && id != "p7"), vec!["p8"]);
list.truncate(5);
assert!(old_tabs(&Value::Array(list), |_| true).is_empty());
}
#[test]
fn each_job_works_on_its_own_tabs() {
let page = |id: &str| serde_json::json!({"type": "page", "id": id});
// Latest-used first: B's tab is in front, A's further back.
let list = vec![page("tab-b"), page("tab-a"), page("tab-free")];
as_job("job-a", || claim("tab-a"));
as_job("job-b", || claim("tab-b"));
assert_eq!(as_job("job-a", || pick_tab(&list).map(|t| t["id"].clone())), Some("tab-a".into()));
assert_eq!(as_job("job-b", || pick_tab(&list).map(|t| t["id"].clone())), Some("tab-b".into()));
// A new job starts on the latest tab nobody has; another job's tabs are off limits.
assert_eq!(as_job("job-c", || pick_tab(&list).map(|t| t["id"].clone())), Some("tab-free".into()));
assert!(as_job("job-c", || others_tab("tab-a") && !others_tab("tab-free")));
assert!(as_job("job-a", || !others_tab("tab-a")));
// A claimed tab stays its first owner's.
as_job("job-b", || claim("tab-a"));
assert_eq!(owner("tab-a").as_deref(), Some("job-a"));
// Outside a job nothing is claimed.
claim("tab-free");
assert_eq!(owner("tab-free"), None);
assert_eq!(release("job-a"), vec!["tab-a".to_string()]);
assert_eq!(release("job-b"), vec!["tab-b".to_string()]);
assert_eq!(owner("tab-a"), None);
}
#[test]
fn urls_are_encoded_for_new_tabs() {
assert_eq!(encode_component("https://www.threads.net/@me?x=1&y=2"), "https://www.threads.net/%40me%3Fx%3D1%26y%3D2");
}
#[test]
fn profiles_are_found_by_name() {
let list = vec![DEFAULT_PROFILE.to_string(), "工作".to_string(), "Personal".to_string()];
assert_eq!(match_profile(&list, " personal ").as_deref(), Some("Personal"));
assert_eq!(match_profile(&list, "工作").as_deref(), Some("工作"));
assert_eq!(match_profile(&list, "私人"), None);
assert_eq!(match_profile(&list, ""), None);
let with_person = vec![DEFAULT_PROFILE.to_string(), PERSON_PROFILE.to_string()];
assert_eq!(match_profile(&with_person, "我的 Chrome").as_deref(), Some(PERSON_PROFILE));
assert_eq!(match_profile(&list, "我的 Chrome"), None);
assert!(check_name("我的 Chrome").is_err());
assert!(check_name(PERSON_PROFILE).is_err());
}
#[test]
fn profile_names_are_checked() {
assert_eq!(check_name(" 工作 ").unwrap(), "工作");
assert!(check_name("").is_err());
assert!(check_name("a/b").is_err());
assert!(check_name("..").is_err());
assert!(check_name(&"字".repeat(PROFILE_NAME_MAX_CHARS + 1)).is_err());
assert!(check_name(&"字".repeat(PROFILE_NAME_MAX_CHARS)).is_ok());
}
#[test]
fn the_persons_firefox_profiles_are_found_with_their_names() {
let root = std::env::temp_dir().join(format!("anybot-fxtest-{}", crate::httpd::random_hex(4)));
for d in ["lDxV7bhX.設定檔 1", "3F5mWbNN.設定檔 5", "abc.default-release", "/abs-not-here"] {
let _ = std::fs::create_dir_all(root.join(d.trim_start_matches('/')));
}
let ini = "[General]\nStartWithLastProfile=1\n\n[Profile1]\nName=default-release\nIsRelative=1\nPath=abc.default-release\n\n[Profile0]\nName=default\nIsRelative=1\nPath=3F5mWbNN.設定檔 5\nDefault=1\n\n[Install4F96D1932A9F858E]\nDefault=x\n";
let got = ini_profiles(&root, ini);
assert_eq!(got, vec![("default-release".to_string(), root.join("abc.default-release")), ("default".to_string(), root.join("3F5mWbNN.設定檔 5"))]);
// The newer profile switcher keeps its names in a SQLite file.
std::fs::create_dir_all(root.join("Profile Groups")).unwrap();
let c = rusqlite::Connection::open(root.join("Profile Groups/8d582846.sqlite")).unwrap();
c.execute_batch("CREATE TABLE Profiles (id INTEGER PRIMARY KEY, path TEXT, name TEXT, avatar TEXT); INSERT INTO Profiles (path, name, avatar) VALUES ('lDxV7bhX.設定檔 1', '女生', 'flower'), ('3F5mWbNN.設定檔 5', '阿金', 'hammer');").unwrap();
drop(c);
assert_eq!(group_profiles(&root), vec![("女生".to_string(), root.join("lDxV7bhX.設定檔 1")), ("阿金".to_string(), root.join("3F5mWbNN.設定檔 5"))]);
let _ = std::fs::remove_dir_all(&root);
}
/// The person's own Firefox profile, end to end (headless): listed by its name, refused while
/// it's open the everyday way, then opened by AnyBot and driven. HOME is a scratch folder (a
/// Firefox profile list is made there):
/// HOME=$T ANYBOT_DATA_DIR=$T/data ANYBOT_FIREFOX_HEADLESS=1 <test binary> --ignored a_persons_firefox_profile
#[test]
#[ignore]
fn a_persons_firefox_profile() {
use std::io::{Read, Write};
let bin = firefox().expect("Firefox is installed");
let root = firefox_roots()[0].clone();
assert!(root.starts_with(std::env::var("HOME").unwrap()) && !root.exists(), "run with HOME set to an empty scratch folder");
let dir = root.join("x1.阿金");
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(root.join("profiles.ini"), "[Profile0]\nName=阿金\nIsRelative=1\nPath=x1.阿金\n").unwrap();
assert!(choices().contains(&format!("阿金{FIREFOX_MARK}")), "{:?}", choices());
let l = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
let port = l.local_addr().unwrap().port();
std::thread::spawn(move || {
for mut c in l.incoming().flatten() {
let mut buf = [0u8; 2048];
let _ = c.read(&mut buf);
let body = "<html><head><title>阿金的頁面</title></head><body><button onclick=\"this.innerText='按到了'\">按我</button></body></html>";
let _ = write!(c, "HTTP/1.1 200 OK\r\nContent-Type: text/html; charset=utf-8\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}", body.len());
}
});
let wait_for = |want: bool| {
let t = Instant::now();
while firefox_in_use(&dir) != want && t.elapsed() < Duration::from_secs(15) {
std::thread::sleep(Duration::from_millis(200));
}
assert_eq!(firefox_in_use(&dir), want);
};
// Open the everyday way (nobody can drive it): AnyBot asks for it to be closed first.
let mut everyday = Command::new(bin).args(["--headless", "--new-instance", "--profile"]).arg(&dir).arg("about:blank").stdout(Stdio::null()).stderr(Stdio::null()).spawn().unwrap();
wait_for(true);
let e = open(&format!("http://127.0.0.1:{port}/"), Some("阿金")).unwrap_err();
assert!(e.contains("先關掉"), "{e}");
let _ = everyday.kill();
let _ = everyday.wait();
wait_for(false);
// Now AnyBot opens it itself and drives it like any of its own.
let go = || -> Result<(), String> {
let r = open(&format!("http://127.0.0.1:{port}/"), Some("阿金"))?;
assert!(r.contains("Firefox") && r.contains("阿金（Firefox）") && r.contains("按我"), "{r}");
let (t, _) = crate::browser::run("browser_click", &serde_json::json!({"text": "按我", "profile": "阿金"}))?;
assert!(t.contains("按到了"), "{t}");
Ok(())
};
let r = go();
let _ = Command::new("pkill").arg("-f").arg(dir.display().to_string()).status();
r.unwrap();
}
#[test]
fn a_firefox_profile_answers_to_its_own_name() {
let list = vec![DEFAULT_PROFILE.to_string(), "工作".to_string(), format!("阿金{FIREFOX_MARK}"), format!("Sunny{FIREFOX_MARK}")];
for want in ["阿金", "阿金（Firefox）", "Firefox 阿金", "firefox:阿金", "阿金 (firefox)"] {
assert_eq!(match_profile(&list, want).as_deref(), Some("阿金（Firefox）"), "{want}");
}
assert_eq!(match_profile(&list, "sunny").as_deref(), Some("Sunny（Firefox）"));
// AnyBot's own profile of the same name wins; "Firefox" alone means none of them.
let both = vec!["阿金".to_string(), format!("阿金{FIREFOX_MARK}")];
assert_eq!(match_profile(&both, "阿金").as_deref(), Some("阿金"));
assert_eq!(match_profile(&list, "firefox"), None);
assert!(check_name("我的 Firefox").is_err());
}
#[test]
fn chosen_port_is_read_back() {
assert_eq!(parse_active_port("53211\n/devtools/browser/abc\n"), Some(53211));
assert_eq!(parse_active_port("0\n"), None);
assert_eq!(parse_active_port(""), None);
}
}
Reference in New Issue View Git Blame Copy Permalink