summaryrefslogtreecommitdiff
path: root/src/browser.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/browser.rs')
-rw-r--r--src/browser.rs302
1 files changed, 302 insertions, 0 deletions
diff --git a/src/browser.rs b/src/browser.rs
new file mode 100644
index 0000000..187b535
--- /dev/null
+++ b/src/browser.rs
@@ -0,0 +1,302 @@
+use std::path::PathBuf;
+use std::time::{Duration, Instant};
+
+use anyhow::{anyhow, bail, Context, Result};
+use chromiumoxide::browser::{Browser, BrowserConfig};
+use chromiumoxide::page::Page;
+use futures::StreamExt;
+use serde::Deserialize;
+use tokio::time::sleep;
+
+use crate::config::{notes_url, Paths};
+use crate::helpers::{format_note_text, looks_logged_out, LoggedOutSignals};
+
+#[derive(Debug, Deserialize)]
+struct ReadyFlag {
+ ready: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct SignalsJson {
+ body_text: String,
+ has_password_field: bool,
+ has_sign_in_control: bool,
+ has_notes_app: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct CreatedNote {
+ title: String,
+ #[serde(default)]
+ record_name: String,
+}
+
+fn find_chrome() -> Result<PathBuf> {
+ if let Ok(p) = std::env::var("ICLOUD_NOTES_CHROME") {
+ let pb = PathBuf::from(&p);
+ if pb.is_file() {
+ return Ok(pb);
+ }
+ bail!("ICLOUD_NOTES_CHROME not a file: {p}");
+ }
+ let home = dirs::home_dir().unwrap_or_else(|| PathBuf::from("/tmp"));
+ let candidates = [
+ home.join(".cache/ms-playwright/chromium-1248/chrome-linux64/chrome"),
+ PathBuf::from("/usr/bin/chromium"),
+ PathBuf::from("/usr/bin/chromium-browser"),
+ PathBuf::from("/usr/bin/google-chrome"),
+ PathBuf::from("/usr/bin/google-chrome-stable"),
+ ];
+ for c in candidates {
+ if c.is_file() {
+ return Ok(c);
+ }
+ }
+ // glob playwright chromium
+ let pw = home.join(".cache/ms-playwright");
+ if pw.is_dir() {
+ if let Ok(entries) = std::fs::read_dir(&pw) {
+ for ent in entries.flatten() {
+ let name = ent.file_name().to_string_lossy().to_string();
+ if name.starts_with("chromium-") {
+ let chrome = ent.path().join("chrome-linux64/chrome");
+ if chrome.is_file() {
+ return Ok(chrome);
+ }
+ }
+ }
+ }
+ }
+ bail!(
+ "No Chrome/Chromium found. Set ICLOUD_NOTES_CHROME or install Chromium. \
+ Tip: run scripts/setup.sh (uses Playwright Chromium under ~/.cache/ms-playwright)."
+ )
+}
+
+async fn launch(paths: &Paths, headed: bool) -> Result<(Browser, tokio::task::JoinHandle<()>)> {
+ paths.ensure()?;
+ let chrome = find_chrome()?;
+ let mut builder = BrowserConfig::builder()
+ .chrome_executable(chrome)
+ .user_data_dir(&paths.profile_dir)
+ .arg("--disable-blink-features=AutomationControlled")
+ .arg("--no-first-run")
+ .arg("--no-default-browser-check");
+ builder = if headed {
+ builder.with_head()
+ } else {
+ builder
+ .new_headless_mode()
+ .arg("--ozone-platform=headless")
+ };
+ let cfg = builder.build().map_err(|e| anyhow!(e))?;
+ let (browser, mut handler) = Browser::launch(cfg).await.context("launch Chrome")?;
+ let handle = tokio::spawn(async move {
+ while let Some(h) = handler.next().await {
+ if h.is_err() {
+ break;
+ }
+ }
+ });
+ Ok((browser, handle))
+}
+
+async fn page_looks_logged_out(page: &Page) -> Result<bool> {
+ let url = page.url().await?.unwrap_or_default();
+ let signals: SignalsJson = page
+ .evaluate(
+ r#"() => {
+ const t = (document.body?.innerText || "").slice(0, 4000);
+ const hasPasswordField = Boolean(
+ document.querySelector(
+ 'input[type="password"], #password_text_field, #account_name_text_field'
+ )
+ );
+ const hasSignInControl = [...document.querySelectorAll("a,button,div[role='button']")]
+ .some((el) => /^sign in$/i.test((el.textContent || "").trim()));
+ const hasNotesApp = Boolean(
+ document.querySelector("iframe")?.contentWindow?.NotesApp?.dataManager
+ );
+ return {
+ body_text: t,
+ has_password_field: hasPasswordField,
+ has_sign_in_control: hasSignInControl,
+ has_notes_app: hasNotesApp
+ };
+ }"#,
+ )
+ .await?
+ .into_value()
+ .unwrap_or(SignalsJson {
+ body_text: String::new(),
+ has_password_field: false,
+ has_sign_in_control: false,
+ has_notes_app: false,
+ });
+ Ok(looks_logged_out(&LoggedOutSignals {
+ url,
+ body_text: signals.body_text,
+ has_password_field: signals.has_password_field,
+ has_sign_in_control: signals.has_sign_in_control,
+ has_notes_app: signals.has_notes_app,
+ }))
+}
+
+async fn notes_ready(page: &Page) -> Result<bool> {
+ let flag: ReadyFlag = page
+ .evaluate(
+ r#"() => {
+ const iframe = document.querySelector("iframe");
+ const w = iframe?.contentWindow;
+ const dm = w?.NotesApp?.dataManager;
+ if (!dm) return { ready: false };
+ const notes = dm.allNotes || dm.__CW__allNotes;
+ const folders = dm.allFolders || dm.__CW__allFolders || dm.folders;
+ const n = notes?.length || 0;
+ const f = folders?.length || 0;
+ return { ready: n > 0 || f > 0 };
+ }"#,
+ )
+ .await?
+ .into_value()
+ .unwrap_or(ReadyFlag { ready: false });
+ Ok(flag.ready)
+}
+
+async fn wait_for_notes_app(page: &Page, timeout: Duration, allow_login_wait: bool) -> Result<()> {
+ page.goto(notes_url()).await.context("goto Notes")?;
+ let deadline = Instant::now() + timeout;
+ let mut saw_login = false;
+ while Instant::now() < deadline {
+ if notes_ready(page).await? {
+ return Ok(());
+ }
+ if page_looks_logged_out(page).await? {
+ saw_login = true;
+ if !allow_login_wait {
+ bail!("Not signed in. Run: icloud-note login");
+ }
+ }
+ sleep(Duration::from_secs(1)).await;
+ }
+ if saw_login {
+ bail!("Login did not finish. Complete Apple ID sign-in in the browser window.");
+ }
+ bail!("NotesApp did not become ready. Run: icloud-note login");
+}
+
+async fn create_via_notes_app(page: &Page, title: &str, body: &str) -> Result<CreatedNote> {
+ let full = format_note_text(title, body);
+ // Pass text via JSON.stringify embedded in JS to avoid injection issues
+ let text_js = serde_json::to_string(&full)?;
+ let expr = format!(
+ r#"async () => {{
+ const text = {text_js};
+ const iframe = document.querySelector("iframe");
+ const w = iframe?.contentWindow;
+ const app = w?.NotesApp;
+ if (!app?.dataManager) throw new Error("NotesApp unavailable");
+ const dataManager = app.dataManager;
+ const mv = app.mainViewModel;
+ const noteList = dataManager.allNotes || dataManager.__CW__allNotes;
+ const sample =
+ mv?.selectedNote ||
+ (noteList?.objectAt ? noteList.objectAt(0) : noteList?.[0]) ||
+ null;
+ const Note = sample?.constructor;
+ if (!Note?.createNoteWithTitleText && !Note?.createEmptyNote) {{
+ throw new Error("Could not find Note.createNoteWithTitleText — UI may have changed");
+ }}
+ const folderList =
+ dataManager.allFolders || dataManager.__CW__allFolders || dataManager.folders;
+ const folder =
+ mv?.selectedFolder ||
+ dataManager.defaultFolder ||
+ dataManager.inboxFolder ||
+ (folderList?.objectAt ? folderList.objectAt(0) : folderList?.[0]) ||
+ null;
+ if (!folder) throw new Error("Could not resolve a Notes folder");
+ let note;
+ if (typeof Note.createNoteWithTitleText === "function") {{
+ note = Note.createNoteWithTitleText(text, folder);
+ }} else {{
+ note = Note.createEmptyNote(folder);
+ note.userDidChangeTopoText?.(text);
+ if (note.Title !== undefined) note.Title = text.split("\n")[0] || "Note";
+ }}
+ if (typeof dataManager.userDidCreateNote === "function") {{
+ dataManager.userDidCreateNote(note);
+ }}
+ await note.save(true);
+ return {{
+ title: String(note.Title || text.split("\n")[0] || "(untitled)"),
+ record_name: String(note.recordName || note.id || "")
+ }};
+ }}"#
+ );
+ let note: CreatedNote = page.evaluate(expr).await?.into_value()?;
+ Ok(note)
+}
+
+fn mark_session(paths: &Paths) -> Result<()> {
+ std::fs::write(&paths.marker_path, b"ok\n")?;
+ #[cfg(unix)]
+ {
+ use std::os::unix::fs::PermissionsExt;
+ let _ = std::fs::set_permissions(&paths.marker_path, std::fs::Permissions::from_mode(0o600));
+ }
+ Ok(())
+}
+
+pub async fn cmd_login(paths: &Paths) -> Result<()> {
+ if std::env::var_os("DISPLAY").is_none() && std::env::var_os("WAYLAND_DISPLAY").is_none() {
+ bail!("login needs a graphical session (DISPLAY or WAYLAND_DISPLAY).");
+ }
+ eprintln!("Opening Chromium for Apple ID sign-in (one-time)…");
+ eprintln!("Sign in, complete 2FA, wait until Notes loads.");
+ let (mut browser, handle) = launch(paths, true).await?;
+ let page = browser.new_page(notes_url()).await?;
+ wait_for_notes_app(&page, Duration::from_secs(600), true).await?;
+ mark_session(paths)?;
+ println!("ok: session saved under {}", paths.profile_dir.display());
+ println!("ok: create/status will run headless (no window)");
+ browser.close().await?;
+ let _ = handle.await;
+ Ok(())
+}
+
+pub async fn cmd_status(paths: &Paths) -> Result<()> {
+ if !paths.has_session() {
+ bail!("No saved session. Run: icloud-note login");
+ }
+ let (mut browser, handle) = launch(paths, false).await?;
+ let page = browser.new_page("about:blank").await?;
+ wait_for_notes_app(&page, Duration::from_secs(20), false).await?;
+ println!("ok: logged in to icloud.com/notes (headless)");
+ browser.close().await?;
+ let _ = handle.await;
+ Ok(())
+}
+
+pub async fn cmd_create(paths: &Paths, title: &str, body: &str) -> Result<()> {
+ if !paths.has_session() {
+ bail!("No saved session. Run: icloud-note login");
+ }
+ let (mut browser, handle) = launch(paths, false).await?;
+ let page = browser.new_page("about:blank").await?;
+ wait_for_notes_app(&page, Duration::from_secs(90), false).await?;
+ let note = create_via_notes_app(&page, title, body)
+ .await
+ .context("create note via NotesApp")?;
+ sleep(Duration::from_secs(2)).await;
+ mark_session(paths)?;
+ if note.record_name.is_empty() {
+ println!("created: {}", note.title);
+ } else {
+ println!("created: {} ({})", note.title, note.record_name);
+ }
+ browser.close().await?;
+ let _ = handle.await;
+ Ok(())
+}
+