From 5c61196f27b9342e5f25414c11df5710f956f406 Mon Sep 17 00:00:00 2001 From: Christopher Warner Date: Sat, 10 Oct 2026 18:47:24 -0400 Subject: feat!: rewrite icloud-note CLI in Rust with chromiumoxide Replace the Node/Playwright driver with a single Rust binary so create/status stay headless without a visible browser. Move the previous implementation to legacy/nodejs for reference. BREAKING CHANGE: the supported CLI is the Rust `icloud-note` binary; the Node entrypoint is no longer installed by setup.sh. Co-authored-by: Cursor --- src/browser.rs | 302 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 302 insertions(+) create mode 100644 src/browser.rs (limited to 'src/browser.rs') 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 { + 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 { + 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 { + 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 { + 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(()) +} + -- cgit v1.2.3