diff --git a/CHANGELOG.md b/CHANGELOG.md index c425e97..9d61548 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,17 @@ candidates before a series ships (`27.1-rc.1`). The tag is the version with a ## [Unreleased] +### Added +- `guide` walks through a move into inbuxa in the browser. It serves a page + on 127.0.0.1 that asks for the source (IMAP with a master user, JMAP with + an administrator, or Maildir folders), the accounts (pasted, from a CSV, + or read from the source) and the inbuxa server. It can create the missing + accounts, previews with a dry run, then moves the mail with live progress + and runs a final pass. It writes an ordinary plan and runs it with + `migrate`, so the same move can be finished from a terminal. Secrets stay + in memory, and only the browser given the address, with its random + token, gets an answer. + ## [27.1-rc.4] The fourth release candidate of the 27.1 series: a whole domain moves with diff --git a/README.md b/README.md index 7598ed5..3d870d6 100644 --- a/README.md +++ b/README.md @@ -25,6 +25,7 @@ contacts, identities, Sieve scripts and files. inbuxa-migrate export-directory … out a server's accounts, no secrets inbuxa-migrate import-directory … out those accounts, set up on inbuxa inbuxa-migrate migrate --plan plan.json work many accounts, by a plan + inbuxa-migrate guide work the same, walked through in the browser Between the two sides sits an archive: one SQLite file holding one account. `import` fills it from the old server; `export` writes it into the new one. @@ -52,7 +53,10 @@ list of domains, accounts, groups, lists and aliases to set up again elsewhere, without passwords, and `import-directory` sets them up on an inbuxa server, with a new password for each user. `migrate` moves many accounts with one plan file: the same steps for each account, several at -once, resuming where it stopped, with one report at the end. The full +once, resuming where it stopped, with one report at the end. `guide` +walks through the same move in the browser: it asks where the mail is, +which accounts and which inbuxa server, previews, and runs the plan it +writes. The full command reference is in [docs/usage.md](docs/usage.md). ## Sources diff --git a/docs/usage.md b/docs/usage.md index 3fdec43..e44ca39 100644 --- a/docs/usage.md +++ b/docs/usage.md @@ -13,7 +13,7 @@ and how to install it. ## Commands and global flags ``` -inbuxa-migrate [args...] +inbuxa-migrate [args...] ``` Every command takes a few global flags -- verbosity, worker pool size, retry @@ -630,6 +630,50 @@ logs. With `--dry-run`, each step runs with `--dry-run`, nothing is recorded, and the report goes to `dry-run-report.csv`. An export step reads the archive as it is, so on a first dry run it has nothing to show. +## The guide + +``` +inbuxa-migrate guide [--port ] [--no-open] +``` + +Walks through moving a domain, or a few accounts, into inbuxa in the +browser. `guide` serves a page on 127.0.0.1 from the binary itself and +opens it. The page asks five things in turn: + +1. **Where the mail is now:** an IMAP server, a JMAP server (Stalwart or + inbuxa), or Maildir folders on this machine. It also asks for a login + that can act for every account. On IMAP that's a master user, such as + Dovecot's `{email}*master`. On JMAP it's an administrator, with a + password or an API key. +2. **Which accounts:** pasted one per line or as a CSV, or read from a + JMAP server's account list. The list can be edited before anything runs. +3. **Where to:** the inbuxa server and an administrator's API key, and + whether to create the accounts inbuxa doesn't have yet. Each new account + gets a generated password, written to a file only its owner can read. +4. **Preview:** a dry run. It signs in for each account, counts what would + move, and creates nothing. +5. **Move,** with progress, a report, and a final pass for when the old + server stops taking mail. + +The guide writes an ordinary plan, `/plan.json`, and runs it with +`migrate`, so a move started in the browser can be finished from a +terminal. The page shows the command. Everything else goes into `` +too: the archives, the logs, `work/report.csv`, the passwords file, and the +answers so far, in `guide.json`. A guide started again on the same +directory picks up where it was. + +- **Only this browser.** The page is served on 127.0.0.1 alone, at an + address with a random token that changes each start. A request without + the token, for another host name, or from another site's page is + refused. +- **Secrets stay in memory.** Passwords and API keys never go into + `guide.json` or the plan. The runs get them through environment + variables, `MIGRATE_SOURCE_SECRET` and `MIGRATE_INBUXA_TOKEN`, as a plan + run from a terminal does. After the guide restarts, the page asks for + them again. +- `--no-open` prints the address instead of opening a browser. + `--port` picks the port; by default any free one is used. + ## Inspect ``` diff --git a/src/cli.rs b/src/cli.rs index c3f7bf4..746418a 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -16,6 +16,7 @@ use crate::exchange_ews::types::MailboxKind; use crate::exchange_graph::types::{EventBodyFormat, MailboxKind as GraphMailboxKind, Surfaces}; use crate::export_directory::ExportDirectoryConfig; use crate::export_files::ExportFilesConfig; +use crate::guide::GuideConfig; use crate::import_directory::ImportDirectoryConfig; use crate::inspect::InspectConfig; use crate::jmap::account::AccountSelector; @@ -95,6 +96,10 @@ enum Command { about = "Move many accounts by a plan file: the same steps for each, several at once, resumable" )] Migrate(Box), + #[command( + about = "Walk through a move to inbuxa in the browser: a page on this machine writes the plan and runs it" + )] + Guide(Box), #[command(about = "Show the contents of a local archive (read-only)")] Inspect(Box), } @@ -733,6 +738,26 @@ struct MigrateArgs { work: PathBuf, } +#[derive(Args)] +struct GuideArgs { + #[arg( + long, + value_name = "PORT", + default_value_t = 0, + help = "Port on 127.0.0.1 (default: any free one)" + )] + port: u16, + + #[arg(long, help = "Print the page's address instead of opening a browser")] + no_open: bool, + + #[arg( + value_name = "DIR", + help = "Where the plan, the archives, the logs and the report go" + )] + dir: PathBuf, +} + #[derive(Args)] struct InspectArgs { #[arg(value_name = "ARCHIVE", help = "Local SQLite archive")] @@ -774,6 +799,7 @@ pub enum Action { ExportDirectory(ExportDirectoryConfig), ImportDirectory(ImportDirectoryConfig), Migrate(MigrateConfig), + Guide(GuideConfig), ExportImap(CommonConfig, ExportImapConfig), ExportManageSieve(CommonConfig, ExportManageSieveConfig), ExportDav(CommonConfig, ExportDavConfig), @@ -906,6 +932,12 @@ impl Cli { Command::ExportDirectory(args) => resolve_export_directory(*args), Command::ImportDirectory(args) => resolve_import_directory(*args), Command::Migrate(args) => resolve_migrate(*args), + Command::Guide(args) => Ok(Action::Guide(GuideConfig { + dir: args.dir, + port: args.port, + open: !args.no_open, + program: std::env::current_exe()?, + })), Command::ExportImap(args) => resolve_export_imap(*args), Command::ExportManageSieve(args) => resolve_export_managesieve(*args), Command::ExportCaldav(args) => resolve_export_dav(*args, DavKindArg::Caldav), diff --git a/src/guide/form.rs b/src/guide/form.rs new file mode 100644 index 0000000..b03cf5b --- /dev/null +++ b/src/guide/form.rs @@ -0,0 +1,459 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! What the page sends, and the plan and directory written from it. The +//! plan is an ordinary one: `migrate` runs it, and so can the administrator +//! from the command line. Secrets stay out of it, named by the variables +//! below, which the guide sets for the runs it starts. + +use serde::{Deserialize, Serialize}; +use serde_json::{Value, json}; + +use crate::export_directory::FORMAT_VERSION as DIRECTORY_VERSION; +use crate::migrate::plan::{self, FORMAT, FORMAT_VERSION}; + +/// The source's password or API key. +pub const SOURCE_SECRET_VAR: &str = "MIGRATE_SOURCE_SECRET"; +/// The inbuxa administrator's API key. +pub const TARGET_TOKEN_VAR: &str = "MIGRATE_INBUXA_TOKEN"; +/// The directory the setup step reads, relative to the guide's directory. +pub const DIRECTORY: &str = "directory"; + +#[derive(Deserialize, Serialize, Clone, Default)] +#[serde(rename_all = "camelCase", default)] +pub struct Form { + pub source: Source, + pub accounts: Vec, + /// Create on inbuxa the accounts it doesn't have yet. + pub create: bool, + pub target: Target, + pub parallel: usize, +} + +#[derive(Deserialize, Serialize, Clone, Copy, Default, PartialEq, Eq)] +#[serde(rename_all = "lowercase")] +pub enum SourceKind { + #[default] + Imap, + Jmap, + Maildir, +} + +#[derive(Deserialize, Serialize, Clone, Default)] +#[serde(rename_all = "camelCase", default)] +pub struct Source { + pub kind: SourceKind, + pub url: String, + /// IMAP: the login for each account, such as `{email}*master`. JMAP: + /// the administrator, or empty for an API key. + pub login: String, + /// Maildir: where each account's folder is, such as + /// `/var/vmail/{domain}/{local}/Maildir`. + pub path: String, + /// IMAP: credentials on `imap://` without STARTTLS. + pub cleartext: bool, + #[serde(skip_serializing)] + pub secret: String, +} + +#[derive(Deserialize, Serialize, Clone, Default)] +#[serde(rename_all = "camelCase", default)] +pub struct Target { + pub url: String, + #[serde(skip_serializing)] + pub token: String, +} + +impl Form { + /// The secrets a run needs, by variable. + pub fn env(&self) -> Vec<(&'static str, String)> { + let mut env = vec![(TARGET_TOKEN_VAR, self.target.token.clone())]; + if self.source.kind != SourceKind::Maildir { + env.push((SOURCE_SECRET_VAR, self.source.secret.clone())); + } + env + } + + /// Fields left empty keep what an earlier form had: the page doesn't + /// hold on to secrets across a reload, the guide does. + pub fn keep_secrets_from(&mut self, earlier: &Form) { + if self.source.secret.is_empty() { + self.source.secret.clone_from(&earlier.source.secret); + } + if self.target.token.is_empty() { + self.target.token.clone_from(&earlier.target.token); + } + } + + /// Everything a plan needs, or what's missing, in the page's words. + pub fn check(&self) -> Result<(), String> { + let s = &self.source; + match s.kind { + SourceKind::Imap | SourceKind::Jmap if s.url.trim().is_empty() => { + return Err("Give the old server's address.".into()); + } + SourceKind::Imap if !names_account(&s.login) => { + return Err( + "The login for each account has to name it: {email} or {local}.".into(), + ); + } + SourceKind::Maildir if !names_account(&s.path) => { + return Err("The Maildir path has to name the account: {email} or {local}.".into()); + } + _ => {} + } + if s.kind != SourceKind::Maildir && s.secret.is_empty() { + return Err("Give the old server's password or API key.".into()); + } + if self.accounts.is_empty() { + return Err("List the accounts to move.".into()); + } + if self.target.url.trim().is_empty() || self.target.token.is_empty() { + return Err("Give the inbuxa server's address and an administrator's API key.".into()); + } + Ok(()) + } + + /// The step that reads each account from the source into its archive. + fn import_step(&self) -> Value { + let s = &self.source; + let mut args: Vec<&str> = Vec::new(); + let mut secrets = json!({}); + match s.kind { + SourceKind::Imap => { + args.extend(["import", "imap", "--url", s.url.trim()]); + args.extend(["--auth-basic", s.login.trim()]); + if s.cleartext { + args.push("--allow-cleartext"); + } + secrets = json!({"password": SOURCE_SECRET_VAR}); + } + SourceKind::Jmap => { + args.extend(["import", "jmap", "--url", s.url.trim()]); + if s.login.trim().is_empty() { + args.push("--auth-bearer"); + secrets = json!({"token": SOURCE_SECRET_VAR}); + } else { + args.extend(["--auth-basic", s.login.trim()]); + secrets = json!({"password": SOURCE_SECRET_VAR}); + } + args.extend(["--account-name", "{email}"]); + } + SourceKind::Maildir => args.extend(["import", "maildir", s.path.trim()]), + } + args.push("{archive}"); + json!({"name": "import", "args": args, "secrets": secrets}) + } + + fn export_step(&self) -> Value { + json!({ + "name": "export", + "args": ["export", "--url", self.target.url.trim(), "--auth-bearer", + "--account-name", "{email}", "{archive}"], + "secrets": {"token": TARGET_TOKEN_VAR}, + }) + } + + fn setup(&self, passwords: &str) -> Vec { + if !self.create { + return Vec::new(); + } + vec![json!({ + "name": "accounts", + "args": ["import-directory", "--url", self.target.url.trim(), "--auth-bearer", + "--passwords", passwords, DIRECTORY], + "secrets": {"token": TARGET_TOKEN_VAR}, + })] + } + + /// The plan for the move: set up the accounts if asked, then read each + /// one and write it into inbuxa. New passwords go to `passwords`. + pub fn plan(&self, passwords: &str) -> Value { + json!({ + "format": FORMAT, "formatVersion": FORMAT_VERSION, + "setup": self.setup(passwords), + "accounts": self.accounts, + "steps": [self.import_step(), self.export_step()], + }) + } + + /// The plan the preview dry-runs. An export reads the archive, which a + /// dry run leaves empty, so it would show nothing; the import is where + /// a wrong login or a missing folder shows up. + pub fn preview_plan(&self) -> Value { + json!({ + "format": FORMAT, "formatVersion": FORMAT_VERSION, + "setup": self.setup("passwords.csv"), + "accounts": self.accounts, + "steps": [self.import_step()], + }) + } +} + +fn names_account(template: &str) -> bool { + template.contains("{email}") || template.contains("{local}") +} + +/// The addresses in pasted text or a CSV: the first field on each line +/// that is one. Blank lines, `#` comments and a header are skipped; a line +/// with no usable address is handed back, so the page can show it. +pub fn parse_accounts(text: &str) -> (Vec, Vec) { + let mut accounts = Vec::new(); + let mut rejected = Vec::new(); + for (n, line) in text.lines().enumerate() { + let line = line.trim(); + if line.is_empty() || line.starts_with('#') { + continue; + } + let address = line + .split([',', ';', '\t', ' ']) + .map(|f| f.trim().trim_matches('"')) + .find(|f| f.contains('@')); + match address.map(plan::account_email) { + Some(Ok(email)) => { + if !accounts.contains(&email) { + accounts.push(email); + } + } + None if n == 0 => {} + _ => rejected.push(line.to_owned()), + } + } + (accounts, rejected) +} + +/// The users in a directory `export-directory` wrote. +pub fn directory_accounts(doc: &Value) -> Vec { + doc.get("users") + .and_then(Value::as_array) + .into_iter() + .flatten() + .filter_map(|u| u.get("email").and_then(Value::as_str)) + .filter_map(|e| plan::account_email(e).ok()) + .collect() +} + +/// The directory `import-directory` sets up: the source's, when it was +/// read, with only the chosen users; and a plain user, and its domain, for +/// each chosen account it doesn't have. +pub fn directory(source: Option<&Value>, accounts: &[String]) -> Value { + let mut doc = source.cloned().unwrap_or_else(|| { + json!({ + "format": "inbuxa-migrate-directory", "formatVersion": DIRECTORY_VERSION, + "domains": [], "tenants": [], "roles": [], "groups": [], "lists": [], "users": [], + }) + }); + let email_of = |v: &Value| { + v.get("email") + .and_then(Value::as_str) + .map(str::to_ascii_lowercase) + }; + let mut users: Vec = doc + .get("users") + .and_then(Value::as_array) + .into_iter() + .flatten() + .filter(|u| email_of(u).is_some_and(|e| accounts.contains(&e))) + .cloned() + .collect(); + let mut domains: Vec = doc + .get("domains") + .and_then(Value::as_array) + .cloned() + .unwrap_or_default(); + for email in accounts { + let Some((local, domain)) = email.split_once('@') else { + continue; + }; + if !users.iter().any(|u| email_of(u).as_ref() == Some(email)) { + users.push(json!({ + "email": email, "name": local, "domain": domain, "description": null, + "roles": "user", "permissions": null, "aliases": [], "quotas": {}, + "tenant": null, "locale": null, "timeZone": null, "externalId": null, + "groups": [], + })); + } + let known = domains.iter().any(|d| { + d.get("name") + .and_then(Value::as_str) + .is_some_and(|n| n.eq_ignore_ascii_case(domain)) + }); + if !known { + domains.push(json!({ + "name": domain, "enabled": true, "description": null, "aliases": [], + "catchAllAddress": null, "subAddressing": "enabled", "tenant": null, + })); + } + } + doc["users"] = Value::Array(users); + doc["domains"] = Value::Array(domains); + doc +} + +#[cfg(test)] +mod tests { + use super::*; + + fn form(kind: SourceKind) -> Form { + Form { + source: Source { + kind, + url: "imaps://old.example.org".into(), + login: "{email}*master".into(), + path: "/var/vmail/{domain}/{local}/Maildir".into(), + cleartext: false, + secret: "s3cret".into(), + }, + accounts: vec!["ann@example.org".into()], + create: true, + target: Target { + url: "https://mail.example.org".into(), + token: "t0ken".into(), + }, + parallel: 4, + } + } + + #[test] + fn an_imap_plan_sets_up_reads_with_the_master_login_and_exports() { + let plan = form(SourceKind::Imap).plan("passwords-1.csv"); + let text = plan.to_string(); + assert!( + !text.contains("s3cret") && !text.contains("t0ken"), + "{text}" + ); + assert_eq!( + plan["setup"][0]["args"], + json!([ + "import-directory", + "--url", + "https://mail.example.org", + "--auth-bearer", + "--passwords", + "passwords-1.csv", + "directory" + ]) + ); + assert_eq!( + plan["steps"][0]["args"], + json!([ + "import", + "imap", + "--url", + "imaps://old.example.org", + "--auth-basic", + "{email}*master", + "{archive}" + ]) + ); + assert_eq!(plan["steps"][0]["secrets"]["password"], SOURCE_SECRET_VAR); + assert_eq!(plan["steps"][1]["args"][5], "{email}"); + assert_eq!(plan["steps"][1]["secrets"]["token"], TARGET_TOKEN_VAR); + } + + #[test] + fn a_jmap_source_acts_for_each_account_by_basic_or_by_key() { + let mut f = form(SourceKind::Jmap); + f.source.login = "admin".into(); + let step = &f.plan("p.csv")["steps"][0]; + assert_eq!(step["args"][4], "--auth-basic"); + assert_eq!(step["args"][6], "--account-name"); + f.source.login.clear(); + let step = &f.plan("p.csv")["steps"][0]; + assert_eq!(step["args"][4], "--auth-bearer"); + assert_eq!(step["secrets"]["token"], SOURCE_SECRET_VAR); + } + + #[test] + fn the_preview_has_no_export_and_maildir_needs_no_secret() { + let mut f = form(SourceKind::Maildir); + f.create = false; + f.source.secret.clear(); + assert_eq!(f.check(), Ok(())); + let plan = f.preview_plan(); + assert_eq!(plan["setup"], json!([])); + assert_eq!(plan["steps"].as_array().unwrap().len(), 1); + assert_eq!( + plan["steps"][0]["args"], + json!([ + "import", + "maildir", + "/var/vmail/{domain}/{local}/Maildir", + "{archive}" + ]) + ); + assert_eq!(f.env(), [(TARGET_TOKEN_VAR, "t0ken".to_owned())]); + } + + #[test] + fn a_form_that_cant_make_a_plan_says_why() { + let mut f = form(SourceKind::Imap); + f.source.login = "master".into(); + assert!(f.check().unwrap_err().contains("{email}")); + let mut f = form(SourceKind::Imap); + f.accounts.clear(); + assert!(f.check().unwrap_err().contains("accounts")); + let mut f = form(SourceKind::Jmap); + f.source.secret.clear(); + assert!(f.check().unwrap_err().contains("password")); + } + + #[test] + fn secrets_are_never_saved_and_an_empty_one_keeps_the_last() { + let f = form(SourceKind::Imap); + let saved = serde_json::to_string(&f).unwrap(); + assert!( + !saved.contains("s3cret") && !saved.contains("t0ken"), + "{saved}" + ); + let mut again: Form = serde_json::from_str(&saved).unwrap(); + again.keep_secrets_from(&f); + assert_eq!( + (again.source.secret.as_str(), again.target.token.as_str()), + ("s3cret", "t0ken") + ); + } + + #[test] + fn accounts_come_from_pasted_lines_or_a_csv() { + let (ok, bad) = parse_accounts( + "email,name\nAnn@Example.org,Ann\n\n# left out\n\"bob@example.org\";Bob\nann@example.org\nno address here\n/x@y\n", + ); + assert_eq!(ok, ["ann@example.org", "bob@example.org"]); + assert_eq!(bad, ["no address here", "/x@y"]); + } + + #[test] + fn the_directory_keeps_the_chosen_users_and_adds_the_rest() { + let source = json!({ + "format": "inbuxa-migrate-directory", "formatVersion": 1, + "domains": [{"name": "example.org"}], + "groups": [{"email": "team@example.org"}], + "users": [{"email": "Ann@example.org", "name": "ann", "domain": "example.org", + "roles": "admin"}, + {"email": "cat@example.org"}], + }); + let accounts = ["ann@example.org".to_owned(), "bob@other.test".to_owned()]; + let doc = directory(Some(&source), &accounts); + let emails: Vec<_> = doc["users"] + .as_array() + .unwrap() + .iter() + .map(|u| u["email"].as_str().unwrap()) + .collect(); + assert_eq!(emails, ["Ann@example.org", "bob@other.test"]); + assert_eq!(doc["users"][0]["roles"], "admin"); + assert_eq!(doc["users"][1]["roles"], "user"); + assert_eq!(doc["domains"][1]["name"], "other.test"); + assert_eq!(doc["domains"].as_array().unwrap().len(), 2); + assert_eq!(doc["groups"], source["groups"]); + assert_eq!(directory_accounts(&doc), accounts); + + let fresh = directory(None, &accounts[..1]); + assert_eq!(fresh["format"], "inbuxa-migrate-directory"); + assert_eq!(fresh["domains"][0]["name"], "example.org"); + } +} diff --git a/src/guide/http.rs b/src/guide/http.rs new file mode 100644 index 0000000..be910b7 --- /dev/null +++ b/src/guide/http.rs @@ -0,0 +1,162 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! Just enough HTTP/1.1 for one page and its calls, from one browser on +//! this machine: a request per connection, then the connection closes. + +use std::io::{self, BufRead, BufReader, Read, Write}; + +const MAX_HEAD: usize = 16 * 1024; +const MAX_BODY: usize = 1024 * 1024; + +pub struct Request { + pub method: String, + pub path: String, + headers: Vec<(String, String)>, + pub body: Vec, +} + +impl Request { + pub fn header(&self, name: &str) -> Option<&str> { + self.headers + .iter() + .find(|(n, _)| n.eq_ignore_ascii_case(name)) + .map(|(_, v)| v.as_str()) + } +} + +fn invalid(message: &str) -> io::Error { + io::Error::new(io::ErrorKind::InvalidData, message.to_owned()) +} + +pub fn read(stream: impl Read) -> io::Result { + let mut reader = BufReader::new(stream.take((MAX_HEAD + MAX_BODY) as u64)); + let mut head = 0; + let mut line = String::new(); + let mut next_line = |reader: &mut BufReader<_>, line: &mut String| -> io::Result<()> { + line.clear(); + head += reader.read_line(line)?; + if head > MAX_HEAD { + return Err(invalid("request head too large")); + } + Ok(()) + }; + next_line(&mut reader, &mut line)?; + let mut parts = line.split_whitespace(); + let (Some(method), Some(path), Some(_version)) = (parts.next(), parts.next(), parts.next()) + else { + return Err(invalid("bad request line")); + }; + let (method, path) = (method.to_owned(), path.to_owned()); + let mut headers = Vec::new(); + loop { + next_line(&mut reader, &mut line)?; + let l = line.trim_end_matches(['\r', '\n']); + if l.is_empty() { + break; + } + let (name, value) = l.split_once(':').ok_or_else(|| invalid("bad header"))?; + headers.push((name.trim().to_owned(), value.trim().to_owned())); + } + let mut request = Request { + method, + path, + headers, + body: Vec::new(), + }; + let length = match request.header("content-length") { + Some(v) => v.parse::().map_err(|_| invalid("bad length"))?, + None => 0, + }; + if length > MAX_BODY { + return Err(invalid("request body too large")); + } + request.body = vec![0; length]; + reader.read_exact(&mut request.body)?; + Ok(request) +} + +pub struct Response { + pub status: u16, + pub content_type: &'static str, + pub body: Vec, +} + +impl Response { + pub fn new(status: u16, content_type: &'static str, body: impl Into>) -> Self { + Self { + status, + content_type, + body: body.into(), + } + } + + pub fn json(value: &serde_json::Value) -> Self { + Self::new(200, "application/json", value.to_string()) + } + + pub fn error(status: u16, message: &str) -> Self { + Self::new( + status, + "application/json", + serde_json::json!({ "error": message }).to_string(), + ) + } + + /// The token is in the page's address, so nothing is cached, nothing + /// is sent on as a referrer, and the page loads only from here. + pub fn write(&self, mut stream: impl Write) -> io::Result<()> { + let reason = match self.status { + 200 => "OK", + 400 => "Bad Request", + 403 => "Forbidden", + 404 => "Not Found", + 405 => "Method Not Allowed", + 409 => "Conflict", + 415 => "Unsupported Media Type", + _ => "Error", + }; + write!( + stream, + "HTTP/1.1 {} {reason}\r\nContent-Type: {}\r\nContent-Length: {}\r\n\ + Cache-Control: no-store\r\nReferrer-Policy: no-referrer\r\n\ + X-Content-Type-Options: nosniff\r\n\ + Content-Security-Policy: default-src 'self'; frame-ancestors 'none'; \ + form-action 'none'; base-uri 'none'\r\nConnection: close\r\n\r\n", + self.status, + self.content_type, + self.body.len() + )?; + stream.write_all(&self.body)?; + stream.flush() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn a_request_is_read_with_its_headers_and_body() { + let raw = b"POST /t/api/job HTTP/1.1\r\nHost: 127.0.0.1:1\r\nContent-Type: application/json\r\nContent-Length: 2\r\n\r\n{}"; + let r = read(&raw[..]).unwrap(); + assert_eq!((r.method.as_str(), r.path.as_str()), ("POST", "/t/api/job")); + assert_eq!(r.header("content-type"), Some("application/json")); + assert_eq!(r.body, b"{}"); + } + + #[test] + fn oversized_or_broken_requests_are_refused() { + let big = format!( + "POST / HTTP/1.1\r\nContent-Length: {}\r\n\r\n", + MAX_BODY + 1 + ); + assert!(read(big.as_bytes()).is_err()); + assert!(read(&b"nonsense\r\n\r\n"[..]).is_err()); + let long = format!("GET / HTTP/1.1\r\nX: {}\r\n\r\n", "a".repeat(MAX_HEAD)); + assert!(read(long.as_bytes()).is_err()); + } +} diff --git a/src/guide/mod.rs b/src/guide/mod.rs new file mode 100644 index 0000000..1bee3d0 --- /dev/null +++ b/src/guide/mod.rs @@ -0,0 +1,637 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! `guide`: the walk-through. A page served from this binary on +//! 127.0.0.1 asks where the mail is, which accounts, and which inbuxa +//! server, then writes a plan into its directory and has `migrate` preview +//! and run it, so it moves exactly what the same plan would from the +//! command line. Only the browser given the address, with its random +//! token, gets an answer, and secrets stay in memory: the runs get them +//! the way a plan's steps do, through variables. + +pub mod form; +mod http; + +use std::fs; +use std::io::{BufRead, BufReader, Read}; +use std::net::{TcpListener, TcpStream}; +use std::path::{Path, PathBuf}; +use std::process::{Command, Stdio}; +use std::sync::{Arc, Mutex, MutexGuard}; +use std::time::Duration; + +use serde_json::{Value, json}; + +use crate::error::Error; +use crate::jmap::http::{Auth, HttpClient, RetryPolicy}; +use crate::jmap::request::URN_INBUXA; +use crate::jmap::session::Session; +use crate::migrate::plan::SECRET_VARS; +use crate::migrate::private_dir; +use crate::net::CertOverride; +use form::{Form, SourceKind}; +use http::{Request, Response}; + +const PAGE: &str = include_str!("page/index.html"); +const SCRIPT: &str = include_str!("page/guide.js"); +const STYLE: &str = include_str!("page/guide.css"); + +/// The non-secret answers, so a guide started again picks up where it was. +const SAVED: &str = "guide.json"; +/// The output kept from a run, newest last. +const KEEP_LINES: usize = 400; + +pub struct GuideConfig { + /// Where the plan, the archives and the report go. + pub dir: PathBuf, + /// 0 for any free port. + pub port: u16, + pub open: bool, + /// This binary, which runs each step. + pub program: PathBuf, +} + +#[derive(Clone, Copy, PartialEq, Eq)] +enum Kind { + Directory, + Preview, + Run, + FinalPass, +} + +impl Kind { + fn parse(s: &str) -> Option { + Some(match s { + "directory" => Self::Directory, + "preview" => Self::Preview, + "run" => Self::Run, + "final" => Self::FinalPass, + _ => return None, + }) + } + + fn name(self) -> &'static str { + match self { + Self::Directory => "directory", + Self::Preview => "preview", + Self::Run => "run", + Self::FinalPass => "final", + } + } +} + +struct Job { + kind: Kind, + /// Where a directory run writes. + out: Option, + lines: Vec, + exit: Option, + result: Value, +} + +#[derive(Default)] +struct State { + form: Form, + /// The source's directory, once read. + directory: Option, + job: Option, +} + +struct Guide { + dir: PathBuf, + token: String, + port: u16, + program: PathBuf, + state: Mutex, +} + +pub fn run(config: GuideConfig) -> Result<(), Error> { + let dir = std::path::absolute(&config.dir)?; + private_dir(&dir)?; + let listener = TcpListener::bind(("127.0.0.1", config.port))?; + let port = listener.local_addr()?.port(); + let mut token = [0u8; 16]; + getrandom::fill(&mut token) + .map_err(|e| Error::Io(std::io::Error::other(format!("no random token: {e}"))))?; + let token: String = token.iter().map(|b| format!("{b:02x}")).collect(); + + let mut state = State::default(); + if let Ok(text) = fs::read_to_string(dir.join(SAVED)) + && let Ok(saved) = serde_json::from_str::(&text) + { + state.form = serde_json::from_value(saved["form"].clone()).unwrap_or_default(); + state.directory = saved["directory"].as_str().map(PathBuf::from); + } + let guide = Arc::new(Guide { + dir, + token, + port, + program: config.program, + state: Mutex::new(state), + }); + + let url = format!("http://127.0.0.1:{port}/{}/", guide.token); + println!("The guide is at {url}"); + println!("Keep this running while you use it. Ctrl-C ends it."); + if config.open && !open_browser(&url) { + println!("Open that address in a browser on this machine."); + } + for stream in listener.incoming() { + let Ok(stream) = stream else { continue }; + let guide = Arc::clone(&guide); + std::thread::spawn(move || guide.serve(stream)); + } + Ok(()) +} + +fn open_browser(url: &str) -> bool { + #[cfg(target_os = "macos")] + let mut command = Command::new("open"); + #[cfg(windows)] + let mut command = { + let mut c = Command::new("cmd"); + c.args(["/C", "start", ""]); + c + }; + #[cfg(all(unix, not(target_os = "macos")))] + let mut command = Command::new("xdg-open"); + command + .arg(url) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn() + .map(|mut child| std::thread::spawn(move || child.wait())) + .is_ok() +} + +fn lock(m: &Mutex) -> MutexGuard<'_, T> { + m.lock().unwrap_or_else(|e| e.into_inner()) +} + +/// Equal, in time that doesn't depend on where they differ. +fn same(a: &str, b: &str) -> bool { + a.len() == b.len() && a.bytes().zip(b.bytes()).fold(0, |d, (x, y)| d | (x ^ y)) == 0 +} + +impl Guide { + fn serve(self: Arc, mut stream: TcpStream) { + let _ = stream.set_read_timeout(Some(Duration::from_secs(10))); + let response = match http::read(&mut stream) { + Ok(request) => self.answer(&request), + Err(_) => Response::error(400, "bad request"), + }; + let _ = response.write(&mut stream); + } + + fn answer(self: &Arc, r: &Request) -> Response { + // A page from anywhere else can't reach this, even by a name that + // resolves here: the Host has to be this address. + let hosts = [ + format!("127.0.0.1:{}", self.port), + format!("localhost:{}", self.port), + ]; + if !r + .header("host") + .is_some_and(|h| hosts.iter().any(|x| x == h)) + { + return Response::error(403, "wrong host"); + } + let Some(rest) = r + .path + .strip_prefix('/') + .and_then(|p| p.split_once('/')) + .filter(|(token, _)| same(token, &self.token)) + .map(|(_, rest)| rest) + else { + return Response::error(404, "not found"); + }; + if r.method == "POST" { + if !r + .header("content-type") + .is_some_and(|t| t.starts_with("application/json")) + { + return Response::error(415, "send JSON"); + } + if let Some(origin) = r.header("origin") + && !hosts.iter().any(|h| origin == format!("http://{h}")) + { + return Response::error(403, "wrong origin"); + } + } + let body = || serde_json::from_slice::(&r.body).unwrap_or(Value::Null); + match (r.method.as_str(), rest) { + ("GET", "") => Response::new(200, "text/html; charset=utf-8", PAGE), + ("GET", "guide.js") => Response::new(200, "text/javascript; charset=utf-8", SCRIPT), + ("GET", "guide.css") => Response::new(200, "text/css; charset=utf-8", STYLE), + ("GET", "api/state") => Response::json(&self.state_json()), + ("POST", "api/accounts") => { + let (accounts, rejected) = + form::parse_accounts(body()["text"].as_str().unwrap_or_default()); + Response::json(&json!({ "accounts": accounts, "rejected": rejected })) + } + ("POST", "api/check-source") => match self.take_form(&body()) { + Ok(f) => Response::json(&self.check_source(&f)), + Err(e) => Response::error(400, &e), + }, + ("POST", "api/check-target") => match self.take_form(&body()) { + Ok(f) => Response::json(&check_target(&f)), + Err(e) => Response::error(400, &e), + }, + ("POST", "api/job") => self.start(&body()), + (_, "" | "guide.js" | "guide.css" | "api/state") => { + Response::error(405, "method not allowed") + } + _ => Response::error(404, "not found"), + } + } + + fn state_json(&self) -> Value { + let state = lock(&self.state); + let job = state.job.as_ref().map(|j| { + json!({ + "kind": j.kind.name(), "running": j.exit.is_none(), "exit": j.exit, + "lines": j.lines, "result": j.result, + }) + }); + json!({ + "dir": self.dir.display().to_string(), + "form": state.form, + "hasSourceSecret": !state.form.source.secret.is_empty(), + "hasTargetToken": !state.form.target.token.is_empty(), + "directoryRead": state.directory.is_some(), + "job": job, + "command": self.command_line(&state.form), + }) + } + + /// The same run from a terminal, for the administrator to keep. + fn command_line(&self, f: &Form) -> String { + let mut vars: Vec<_> = f.env().into_iter().map(|(var, _)| var).collect(); + vars.sort_unstable(); + let mut text: String = vars.iter().map(|v| format!("export {v}=…\n")).collect(); + text += &format!( + "inbuxa-migrate migrate --plan {} --parallel {} {}", + self.dir.join("plan.json").display(), + f.parallel.max(1), + self.dir.join("work").display() + ); + text + } + + /// The form the page sent, with the secrets it left out kept from the + /// last one, and saved without them. + fn take_form(&self, body: &Value) -> Result { + let mut f: Form = serde_json::from_value(body["form"].clone()) + .map_err(|e| format!("the form didn't read: {e}"))?; + let mut state = lock(&self.state); + f.keep_secrets_from(&state.form); + if f.parallel == 0 { + f.parallel = 4; + } + state.form = f.clone(); + let saved = json!({ + "form": f, + "directory": state.directory.as_ref().map(|d| d.display().to_string()), + }); + drop(state); + write_private( + &self.dir.join(SAVED), + &serde_json::to_vec_pretty(&saved).unwrap_or_default(), + ) + .map_err(|e| format!("{SAVED} couldn't be written: {e}"))?; + Ok(f) + } + + fn check_source(&self, f: &Form) -> Value { + let s = &f.source; + match s.kind { + SourceKind::Jmap => { + let auth = if s.login.trim().is_empty() { + Auth::Bearer { + token: s.secret.clone(), + } + } else { + Auth::Basic { + user: s.login.trim().to_owned(), + password: s.secret.clone(), + } + }; + match discover(auth, &s.url) { + Err(e) => json!({ "ok": false, "message": e }), + Ok(session) if session.registry_account().is_none() => json!({ + "ok": false, + "message": "This login reaches only its own account. Sign in as an \ + administrator, who can act for every account.", + }), + Ok(_) => json!({ + "ok": true, "directory": true, + "message": "Signed in as an administrator: the guide can read the \ + account list and each account.", + }), + } + } + SourceKind::Maildir => { + let found = f + .accounts + .iter() + .filter(|a| self.dir.join(fill(&s.path, a)).is_dir()) + .count(); + let total = f.accounts.len(); + json!({ + "ok": total > 0 && found == total, + "message": if total == 0 { + "List the accounts, and the guide will look for each one's folder.".to_owned() + } else { + format!("Found the folder for {found} of {total} accounts.") + }, + }) + } + SourceKind::Imap => json!({ + "ok": true, + "message": "The preview signs in for each account and shows any that fail.", + }), + } + } + + fn start(self: &Arc, body: &Value) -> Response { + let Some(kind) = body["kind"].as_str().and_then(Kind::parse) else { + return Response::error(400, "no such run"); + }; + if lock(&self.state) + .job + .as_ref() + .is_some_and(|j| j.exit.is_none()) + { + return Response::error(409, "Something is already running; wait for it to end."); + } + let f = match self.take_form(body) { + Ok(f) => f, + Err(e) => return Response::error(400, &e), + }; + let prepared = match kind { + Kind::Directory => self.directory_run(&f), + _ => self.plan_run(&f, kind), + }; + let (args, env, out) = match prepared { + Ok(p) => p, + Err(e) => return Response::error(400, &e), + }; + let mut command = Command::new(&self.program); + command + .args(&args) + .current_dir(&self.dir) + .stdin(Stdio::null()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + for var in SECRET_VARS { + command.env_remove(var); + } + command.envs(env); + let mut child = match command.spawn() { + Ok(c) => c, + Err(e) => return Response::error(400, &format!("couldn't start: {e}")), + }; + lock(&self.state).job = Some(Job { + kind, + out, + lines: vec![format!("inbuxa-migrate {}", args.join(" "))], + exit: None, + result: Value::Null, + }); + let readers: Vec<_> = [ + child + .stdout + .take() + .map(|o| Box::new(o) as Box), + child + .stderr + .take() + .map(|e| Box::new(e) as Box), + ] + .into_iter() + .flatten() + .map(|out| { + let me = Arc::clone(self); + std::thread::spawn(move || { + for line in BufReader::new(out).lines().map_while(Result::ok) { + if let Some(job) = lock(&me.state).job.as_mut() { + job.lines.push(line); + let over = job.lines.len().saturating_sub(KEEP_LINES); + job.lines.drain(..over); + } + } + }) + }) + .collect(); + let me = Arc::clone(self); + std::thread::spawn(move || { + for r in readers { + let _ = r.join(); + } + let exit = child.wait().ok().and_then(|s| s.code()).unwrap_or(1); + let result = me.result_of(kind, exit); + if let Some(job) = lock(&me.state).job.as_mut() { + job.result = result; + job.exit = Some(exit); + } + }); + Response::json(&json!({ "started": kind.name() })) + } + + /// `export-directory` into a new directory beside the plan. + fn directory_run(&self, f: &Form) -> Result { + let s = &f.source; + if s.kind != SourceKind::Jmap || s.url.trim().is_empty() || s.secret.is_empty() { + return Err( + "Only a JMAP server, signed in as an administrator, has a list to read.".into(), + ); + } + let out = format!("source-directory-{}", stamp()); + let mut args = vec![ + "export-directory".to_owned(), + "--url".into(), + s.url.trim().into(), + ]; + let var = if s.login.trim().is_empty() { + args.push("--auth-bearer".into()); + "INBUXA_MIGRATE_API_KEY" + } else { + args.extend(["--auth-basic".into(), s.login.trim().into()]); + "INBUXA_MIGRATE_PASSWORD" + }; + args.push(out.clone()); + Ok(( + args, + vec![(var, s.secret.clone())], + Some(self.dir.join(out)), + )) + } + + /// Writes the plan, and the directory it sets up, for `migrate`. + fn plan_run(&self, f: &Form, kind: Kind) -> Result { + f.check()?; + let write = |name: &str, value: &Value| { + let path = self.dir.join(name); + write_private(&path, &serde_json::to_vec_pretty(value).unwrap_or_default()) + .map_err(|e| format!("{} couldn't be written: {e}", path.display())) + }; + if f.create { + let source = lock(&self.state).directory.clone(); + let source = match source { + Some(d) => { + let text = fs::read_to_string(d.join("directory.json")) + .map_err(|e| format!("{}: {e}", d.display()))?; + Some(serde_json::from_str::(&text).map_err(|e| e.to_string())?) + } + None => None, + }; + private_dir(&self.dir.join(form::DIRECTORY)).map_err(|e| e.to_string())?; + write( + &format!("{}/directory.json", form::DIRECTORY), + &form::directory(source.as_ref(), &f.accounts), + )?; + } + let plan = if kind == Kind::Preview { + write("preview-plan.json", &f.preview_plan())?; + "preview-plan.json" + } else { + write("plan.json", &f.plan(&format!("passwords-{}.csv", stamp())))?; + "plan.json" + }; + let mut args: Vec = ["migrate", "--plan", plan, "--parallel"] + .map(str::to_owned) + .into(); + args.push(f.parallel.max(1).to_string()); + match kind { + Kind::Preview => args.push("--dry-run".into()), + Kind::FinalPass => args.push("--again".into()), + _ => {} + } + args.push("work".into()); + Ok((args, f.env(), None)) + } + + /// What the page shows once a run ends. + fn result_of(&self, kind: Kind, exit: i32) -> Value { + if kind == Kind::Directory { + let dir = lock(&self.state).job.as_ref().and_then(|j| j.out.clone()); + let doc = dir.as_ref().and_then(|d| { + let text = fs::read_to_string(d.join("directory.json")).ok()?; + serde_json::from_str::(&text).ok() + }); + return match (exit, dir, doc) { + (0, Some(dir), Some(doc)) => { + lock(&self.state).directory = Some(dir); + json!({ "accounts": form::directory_accounts(&doc) }) + } + _ => Value::Null, + }; + } + let report = if kind == Kind::Preview { + "dry-run-report.csv" + } else { + "report.csv" + }; + let passwords = if kind == Kind::Preview { + None + } else { + newest_passwords(&self.dir) + }; + json!({ + "report": fs::read_to_string(self.dir.join("work").join(report)).ok(), + "reportPath": self.dir.join("work").join(report).display().to_string(), + "passwords": passwords.map(|p| p.display().to_string()), + }) + } +} + +/// A run's arguments, the secrets it gets, and where a directory run writes. +type Prepared = (Vec, Vec<(&'static str, String)>, Option); + +/// A template with the account's parts filled in. +fn fill(template: &str, email: &str) -> String { + let (local, domain) = email.split_once('@').unwrap_or((email, "")); + template + .replace("{email}", email) + .replace("{local}", local) + .replace("{domain}", domain) +} + +fn discover(auth: Auth, url: &str) -> Result { + if url.trim().is_empty() { + return Err("Give the server's address.".into()); + } + let client = HttpClient::new(auth, RetryPolicy::new(1), CertOverride::none()); + Session::discover(&client, url.trim()).map_err(|e| format!("Couldn't sign in: {e}")) +} + +fn check_target(f: &Form) -> Value { + let t = &f.target; + if t.token.is_empty() { + return json!({ "ok": false, "message": "Give an administrator's API key." }); + } + let auth = Auth::Bearer { + token: t.token.clone(), + }; + match discover(auth, &t.url) { + Err(e) => json!({ "ok": false, "message": e }), + Ok(s) if !s.capabilities.contains_key(URN_INBUXA) => json!({ + "ok": false, "message": "That server isn't inbuxa.", + }), + Ok(s) => match s.registry_account() { + None => json!({ + "ok": false, + "message": "This key can't act for other accounts. Use an administrator's API key.", + }), + Some((id, _)) => json!({ + "ok": true, + "message": format!( + "Signed in to inbuxa as {}, an administrator.", + s.accounts.get(id).map_or("?", |a| a.name.as_str()) + ), + }), + }, + } +} + +/// The passwords file the last setup wrote, if it wrote one. +fn newest_passwords(dir: &Path) -> Option { + fs::read_dir(dir) + .ok()? + .filter_map(Result::ok) + .map(|e| e.path()) + .filter(|p| { + p.file_name() + .and_then(|n| n.to_str()) + .is_some_and(|n| n.starts_with("passwords-") && n.ends_with(".csv")) + }) + .max() +} + +fn stamp() -> String { + let now = time::OffsetDateTime::now_utc(); + format!( + "{:04}{:02}{:02}-{:02}{:02}{:02}", + now.year(), + u8::from(now.month()), + now.day(), + now.hour(), + now.minute(), + now.second() + ) +} + +fn write_private(path: &Path, bytes: &[u8]) -> std::io::Result<()> { + let mut options = fs::OpenOptions::new(); + options.write(true).create(true).truncate(true); + #[cfg(unix)] + { + use std::os::unix::fs::OpenOptionsExt; + options.mode(0o600); + } + std::io::Write::write_all(&mut options.open(path)?, bytes) +} diff --git a/src/guide/page/guide.css b/src/guide/page/guide.css new file mode 100644 index 0000000..b3340cd --- /dev/null +++ b/src/guide/page/guide.css @@ -0,0 +1,110 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +:root { + --ink: #1d2330; + --muted: #5b6475; + --line: #d9dde5; + --paper: #ffffff; + --page: #f4f5f8; + --accent: #3b5bdb; + --ok: #2b8a3e; + --bad: #c92a2a; + --warn: #a35d00; + color-scheme: light dark; +} + +@media (prefers-color-scheme: dark) { + :root { + --ink: #e6e8ee; + --muted: #9aa3b5; + --line: #343b4a; + --paper: #1b1f29; + --page: #12151c; + --accent: #7c95f5; + --ok: #69db7c; + --bad: #ff8787; + --warn: #ffc078; + } +} + +* { box-sizing: border-box; } + +body { + margin: 0; + background: var(--page); + color: var(--ink); + font: 16px/1.5 system-ui, sans-serif; +} + +header, main { max-width: 46rem; margin: 0 auto; padding: 0 1rem; } +header { padding-top: 2rem; } +h1 { margin: 0 0 .25rem; font-size: 1.75rem; } +header p { color: var(--muted); margin-top: 0; } + +section { + background: var(--paper); + border: 1px solid var(--line); + border-radius: 10px; + padding: 1.25rem 1.5rem; + margin: 1rem 0; +} + +h2 { margin: 0 0 .75rem; font-size: 1.2rem; display: flex; align-items: center; gap: .6rem; } +h3 { font-size: 1rem; margin: 1.5rem 0 .25rem; } +.n { + display: inline-grid; place-items: center; + width: 1.7rem; height: 1.7rem; border-radius: 50%; + background: var(--accent); color: var(--paper); font-size: .95rem; +} + +label { display: block; margin: .75rem 0 .25rem; font-weight: 600; } +label.check { font-weight: normal; display: flex; gap: .5rem; align-items: center; } +label.short input[type=number] { width: 6rem; } +.choices { border: 0; padding: 0; margin: 0 0 .5rem; } +.choices label { font-weight: normal; display: flex; gap: .5rem; margin: .3rem 0; } + +input:not([type=radio]):not([type=checkbox]), textarea { + display: block; width: 100%; margin-top: .25rem; + padding: .5rem .6rem; font: inherit; font-weight: normal; color: inherit; + background: var(--page); border: 1px solid var(--line); border-radius: 6px; +} +textarea { font-family: ui-monospace, monospace; font-size: .9rem; } + +.note { color: var(--muted); font-size: .9rem; margin: .25rem 0 .5rem; } +code { font-family: ui-monospace, monospace; font-size: .9em; } + +button { + font: inherit; font-weight: 600; cursor: pointer; + margin-top: .75rem; padding: .5rem 1.1rem; + color: var(--paper); background: var(--accent); + border: 1px solid var(--accent); border-radius: 6px; +} +button.secondary { color: var(--accent); background: transparent; } +button:disabled { opacity: .5; cursor: default; } +.row { display: flex; gap: .75rem; flex-wrap: wrap; } + +.status { min-height: 1.5em; margin: .5rem 0 0; } +.status.ok { color: var(--ok); } +.status.bad { color: var(--bad); } + +.job pre, #command { + max-height: 16rem; overflow: auto; white-space: pre-wrap; + background: var(--page); border: 1px solid var(--line); border-radius: 6px; + padding: .5rem .75rem; font-size: .8rem; +} +.job .summary { font-weight: 600; margin: .75rem 0 .25rem; } + +table { border-collapse: collapse; width: 100%; font-size: .85rem; margin-top: .5rem; } +th, td { text-align: left; padding: .3rem .5rem; border-bottom: 1px solid var(--line); vertical-align: top; } +td:last-child { overflow-wrap: anywhere; } +td.num { text-align: right; font-variant-numeric: tabular-nums; } +tr.bad td { color: var(--bad); } +tr.warn td { color: var(--warn); } + +details { margin-top: 1rem; } +summary { cursor: pointer; color: var(--muted); } +.job .summary.bad { color: var(--bad); } diff --git a/src/guide/page/guide.js b/src/guide/page/guide.js new file mode 100644 index 0000000..b68baf6 --- /dev/null +++ b/src/guide/page/guide.js @@ -0,0 +1,228 @@ +// SPDX-FileCopyrightText: 2026 Coffey Labs LLC +// SPDX-License-Identifier: Apache-2.0 OR MIT + +"use strict"; + +const $ = (id) => document.getElementById(id); +let polling = false; + +function kind() { + return document.querySelector("input[name=kind]:checked").value; +} + +function showKind() { + const k = kind(); + for (const el of document.querySelectorAll("[data-kind]")) { + el.hidden = !el.dataset.kind.split(" ").includes(k); + } +} + +function lines(text) { + return text.split("\n").map((l) => l.trim()).filter((l) => l); +} + +function form() { + const k = kind(); + return { + source: { + kind: k, + url: $("src-url").value.trim(), + login: k === "imap" ? $("src-imap-login").value.trim() : $("src-jmap-login").value.trim(), + path: $("src-path").value.trim(), + cleartext: $("src-cleartext").checked, + secret: $("src-secret").value, + }, + accounts: lines($("accounts").value), + create: $("create").checked, + target: { url: $("dst-url").value.trim(), token: $("dst-token").value }, + parallel: Number($("parallel").value) || 4, + }; +} + +async function call(path, body) { + const init = body === undefined ? {} : { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify(body), + }; + const r = await fetch(path, init); + const data = await r.json().catch(() => ({})); + if (!r.ok) throw new Error(data.error || `The guide answered ${r.status}.`); + return data; +} + +function status(id, ok, message) { + const el = $(id); + el.className = "status " + (ok ? "ok" : "bad"); + el.textContent = message; +} + +// The list as the server reads it: tidied in place, with what it couldn't use. +async function checkAccounts() { + const r = await call("api/accounts", { text: $("accounts").value }); + $("accounts").value = r.accounts.join("\n"); + let message = r.accounts.length === 1 ? "1 account." : `${r.accounts.length} accounts.`; + if (r.rejected.length) message += ` Left out, no address: ${r.rejected.join("; ")}`; + status("accounts-status", r.accounts.length > 0 && !r.rejected.length, message); + return r.accounts; +} + +async function check(path, statusId) { + try { + if (statusId === "source-status" && kind() === "maildir") await checkAccounts(); + const r = await call(path, { form: form() }); + status(statusId, r.ok, r.message); + await refresh(); + } catch (e) { + status(statusId, false, e.message); + } +} + +async function start(jobKind) { + const box = jobKind === "directory" ? "accounts-status" : jobKind === "preview" ? "preview-job" : "run-job"; + try { + if (jobKind !== "directory") await checkAccounts(); + await call("api/job", { kind: jobKind, form: form() }); + await refresh(); + } catch (e) { + if (box === "accounts-status") status(box, false, e.message); + else { $(box).replaceChildren(); $(box).append(para("summary bad", e.message)); } + } +} + +function para(cls, text) { + const p = document.createElement("p"); + p.className = cls; + p.textContent = text; + return p; +} + +function parseCsv(text) { + const rows = []; + let row = [], field = "", quoted = false; + for (let i = 0; i < text.length; i++) { + const c = text[i]; + if (quoted) { + if (c === '"' && text[i + 1] === '"') { field += '"'; i++; } + else if (c === '"') quoted = false; + else field += c; + } else if (c === '"') quoted = true; + else if (c === ",") { row.push(field); field = ""; } + else if (c === "\n") { row.push(field); rows.push(row); row = []; field = ""; } + else if (c !== "\r") field += c; + } + if (field || row.length) { row.push(field); rows.push(row); } + return rows; +} + +function reportTable(csv) { + const [head, ...rows] = parseCsv(csv); + const show = ["account", "step", "result", "fetched", "created", "updated", "skipped", "failed", "detail"]; + const at = show.map((name) => head.indexOf(name)); + const table = document.createElement("table"); + const tr = table.insertRow(); + for (const name of show) { + const th = document.createElement("th"); + th.textContent = name; + tr.append(th); + } + for (const r of rows) { + const row = table.insertRow(); + const result = r[head.indexOf("result")]; + if (result === "failed") row.className = "bad"; + else if (result === "partial" || result === "not run") row.className = "warn"; + at.forEach((i, n) => { + const td = row.insertCell(); + td.textContent = r[i] ?? ""; + if (n >= 3 && n <= 7) td.className = "num"; + }); + } + return table; +} + +function summary(job) { + const progress = job.lines.map((l) => l.match(/^\[(\d+)\/(\d+)\]/)).filter((m) => m).pop(); + if (job.running) { + return progress ? `Running: ${progress[1]} of ${progress[2]} accounts done.` : "Running…"; + } + const preview = job.kind === "preview"; + const report = (job.result && job.result.report) || ""; + if (/^\(setup\),[^,]*,failed,/m.test(report)) { + return (preview ? "Setting up the accounts would fail" : "Setting up the accounts failed") + + ", so no account was " + (preview ? "previewed" : "moved") + ". The table says why."; + } + if (job.exit === 0) return preview ? "Nothing in the preview failed." : "Every account moved."; + if (job.exit === 5) { + return preview + ? "Some accounts would fail. The table says why." + : "Some accounts didn't finish. Fix what the table says and start again: it picks up where each stopped."; + } + return (preview ? "The preview" : "The run") + " stopped. The output says why."; +} + +function renderJob(job) { + if (job.kind === "directory") { + if (job.running) status("accounts-status", true, "Reading the list from the server…"); + else if (job.result && job.result.accounts) { + $("accounts").value = job.result.accounts.join("\n"); + status("accounts-status", true, `Read ${job.result.accounts.length} accounts. Remove any that shouldn't move.`); + } else status("accounts-status", false, "The list couldn't be read: " + (job.lines.slice(-1)[0] || "")); + return; + } + const box = $(job.kind === "preview" ? "preview-job" : "run-job"); + const pre = document.createElement("pre"); + pre.textContent = job.lines.slice(-40).join("\n"); + const ok = job.running || job.exit === 0; + box.replaceChildren(para("summary " + (ok ? "" : "bad"), summary(job)), pre); + const result = job.result || {}; + if (result.report) box.append(reportTable(result.report), para("note", "Report: " + result.reportPath)); + if (result.passwords) box.append(para("note", "The new accounts' passwords are in " + result.passwords)); + pre.scrollTop = pre.scrollHeight; +} + +async function refresh() { + const s = await call("api/state"); + $("dir").textContent = s.dir; + $("command").textContent = s.command; + $("src-secret-kept").hidden = !s.hasSourceSecret; + $("dst-token-kept").hidden = !s.hasTargetToken; + const running = s.job && s.job.running; + for (const id of ["preview", "run", "final", "read-directory"]) $(id).disabled = running; + if (s.job) renderJob(s.job); + if (running && !polling) { + polling = true; + setTimeout(() => { polling = false; refresh(); }, 1000); + } + return s; +} + +async function load() { + const s = await refresh(); + const f = s.form; + if (f.source) { + document.querySelector(`input[name=kind][value=${f.source.kind}]`).checked = true; + $("src-url").value = f.source.url || ""; + if (f.source.kind === "imap" && f.source.login) $("src-imap-login").value = f.source.login; + if (f.source.kind === "jmap") $("src-jmap-login").value = f.source.login || ""; + if (f.source.path) $("src-path").value = f.source.path; + $("src-cleartext").checked = !!f.source.cleartext; + $("accounts").value = (f.accounts || []).join("\n"); + $("create").checked = f.create || !f.target.url; + $("dst-url").value = f.target.url || ""; + if (f.parallel) $("parallel").value = f.parallel; + } + showKind(); +} + +document.addEventListener("DOMContentLoaded", () => { + for (const r of document.querySelectorAll("input[name=kind]")) r.addEventListener("change", showKind); + $("check-source").addEventListener("click", () => check("api/check-source", "source-status")); + $("check-target").addEventListener("click", () => check("api/check-target", "target-status")); + $("read-accounts").addEventListener("click", () => checkAccounts().catch((e) => status("accounts-status", false, e.message))); + $("read-directory").addEventListener("click", () => start("directory")); + $("preview").addEventListener("click", () => start("preview")); + $("run").addEventListener("click", () => start("run")); + $("final").addEventListener("click", () => start("final")); + showKind(); + load().catch((e) => document.body.prepend(para("status bad", e.message))); +}); diff --git a/src/guide/page/index.html b/src/guide/page/index.html new file mode 100644 index 0000000..60b5525 --- /dev/null +++ b/src/guide/page/index.html @@ -0,0 +1,108 @@ + + + + + + + +Move to inbuxa + + + + +
+

Move to inbuxa

+

Answer each step, preview, then run. Everything is saved in , + and the guide can be closed and started again at any point.

+
+ +
+
+

1 Where is the mail now?

+
+ + + +
+ +
+ +
+
+ +

One login that can open every mailbox. Dovecot calls this a master user: + the account's address, then *, then the master user's name. Other servers + have their own form; {email}, {local} and {domain} + stand for each account.

+ +
+
+ +

An administrator can read the account list and act for each account. + Leave this empty to sign in with an API key instead of a password.

+
+
+ + +
+
+ +

Dovecot keeps one Maildir per account. {domain} and + {local} are the two halves of the address.

+
+ +

+
+ +
+

2 Which accounts?

+

One address per line, or paste a CSV: the first address on each line counts.

+ +
+ + +
+

+
+ +
+

3 Where to?

+ + +

Make one in INBUXA Admin under your account's API keys. With it the guide + writes into each account, so no one has to hand over a password.

+ + +

Each new account gets a generated password, written to a file only you can read.

+ + +

+
+ +
+

4 Preview

+

Signs in for each account and counts what it would move, without moving anything.

+ +
+
+ +
+

5 Move

+

People can keep working on the old server while this runs. A second start picks up + where it stopped.

+ +
+

The final pass

+

Once the old server stops taking mail, run this. It moves only what changed since.

+ +
+ The same from a terminal +

+  
+
+
+ + diff --git a/src/lib.rs b/src/lib.rs index f11c6b5..7b29d9b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -14,6 +14,7 @@ pub mod exchange_ews; pub mod exchange_graph; pub mod export_directory; pub mod export_files; +pub mod guide; pub mod imap; pub mod import_directory; pub mod inspect; diff --git a/src/main.rs b/src/main.rs index 8210d56..5fec816 100644 --- a/src/main.rs +++ b/src/main.rs @@ -10,7 +10,7 @@ use clap::Parser; use inbuxa_migrate::cli::{Action, Cli}; use inbuxa_migrate::error::Error; use inbuxa_migrate::sync::{self, RunOutcome, Summary}; -use inbuxa_migrate::{export_directory, export_files, import_directory, inspect, migrate}; +use inbuxa_migrate::{export_directory, export_files, guide, import_directory, inspect, migrate}; fn main() { let code = run(); @@ -147,6 +147,12 @@ fn run() -> i32 { Err(err) => fail(&err), }; } + Action::Guide(config) => { + return match guide::run(config) { + Ok(()) => 0, + Err(err) => fail(&err), + }; + } Action::Inspect(config) => { return match inspect::run(config) { Ok(()) => 0, diff --git a/src/migrate/mod.rs b/src/migrate/mod.rs index 04bfdf7..90eecb9 100644 --- a/src/migrate/mod.rs +++ b/src/migrate/mod.rs @@ -222,7 +222,7 @@ fn chosen(plan: &Plan, only: &[String]) -> Result, Error> { } /// The work directory holds whole mailboxes: readable by its owner only. -fn private_dir(path: &Path) -> Result<(), Error> { +pub(crate) fn private_dir(path: &Path) -> Result<(), Error> { if path.is_dir() { return Ok(()); } diff --git a/src/migrate/plan.rs b/src/migrate/plan.rs index 7270ec8..d03f714 100644 --- a/src/migrate/plan.rs +++ b/src/migrate/plan.rs @@ -305,7 +305,7 @@ fn directory_users(path: &Path) -> Result, Error> { } /// An address that is safe as a directory name, lowercased. -fn account_email(email: &str) -> Result { +pub(crate) fn account_email(email: &str) -> Result { let email = email.trim().to_ascii_lowercase(); let ok = match email.split_once('@') { Some((local, domain)) => { diff --git a/tests/integration/guide.rs b/tests/integration/guide.rs new file mode 100644 index 0000000..0984efb --- /dev/null +++ b/tests/integration/guide.rs @@ -0,0 +1,100 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! A `guide` started from the real binary, and requests sent to it the way +//! a browser would, raw, so a test can also send what a browser wouldn't. + +use std::io::{BufRead, BufReader, Read, Write}; +use std::net::TcpStream; +use std::path::Path; +use std::process::{Child, Command, Stdio}; +use std::time::{Duration, Instant}; + +use serde_json::Value; + +pub struct Guide { + child: Child, + pub host: String, + pub token: String, +} + +impl Drop for Guide { + fn drop(&mut self) { + let _ = self.child.kill(); + let _ = self.child.wait(); + } +} + +/// `bin` is the test's `CARGO_BIN_EXE_inbuxa-migrate`. +pub fn start(bin: &str, dir: &Path) -> Guide { + let mut child = Command::new(bin) + .args(["guide", "--no-open"]) + .arg(dir) + .stdout(Stdio::piped()) + .spawn() + .unwrap(); + let mut line = String::new(); + BufReader::new(child.stdout.take().unwrap()) + .read_line(&mut line) + .unwrap(); + let url = line + .trim() + .strip_prefix("The guide is at http://") + .unwrap_or_else(|| panic!("{line}")); + let (host, token) = url.trim_end_matches('/').split_once('/').unwrap(); + Guide { + host: host.to_owned(), + token: token.to_owned(), + child, + } +} + +/// Status, headers and body of one request, sent as given. +pub fn send(guide: &Guide, head: &str, body: &str) -> (u16, String, String) { + let mut s = TcpStream::connect(&guide.host).unwrap(); + write!(s, "{head}\r\nContent-Length: {}\r\n\r\n{body}", body.len()).unwrap(); + let mut out = String::new(); + s.read_to_string(&mut out).unwrap(); + let (headers, body) = out.split_once("\r\n\r\n").unwrap(); + let status = headers[9..12].parse().unwrap(); + (status, headers.to_owned(), body.to_owned()) +} + +pub fn get(guide: &Guide, path: &str) -> (u16, String, String) { + send( + guide, + &format!( + "GET /{}/{path} HTTP/1.1\r\nHost: {}", + guide.token, guide.host + ), + "", + ) +} + +pub fn post(guide: &Guide, path: &str, body: &Value) -> (u16, Value) { + let (status, _, text) = send( + guide, + &format!( + "POST /{}/{path} HTTP/1.1\r\nHost: {}\r\nContent-Type: application/json\r\nOrigin: http://{}", + guide.token, guide.host, guide.host + ), + &body.to_string(), + ); + (status, serde_json::from_str(&text).unwrap()) +} + +/// The state once the running job, if any, has ended. +pub fn settled(guide: &Guide) -> Value { + let deadline = Instant::now() + Duration::from_secs(120); + loop { + let state: Value = serde_json::from_str(&get(guide, "api/state").2).unwrap(); + if !state["job"]["running"].as_bool().unwrap_or(false) { + return state; + } + assert!(Instant::now() < deadline, "{state}"); + std::thread::sleep(Duration::from_millis(100)); + } +} diff --git a/tests/integration/mod.rs b/tests/integration/mod.rs index f0fcef0..6cfcfb3 100644 --- a/tests/integration/mod.rs +++ b/tests/integration/mod.rs @@ -13,6 +13,7 @@ pub mod data; pub mod dav_client; pub mod dovecot; pub mod error; +pub mod guide; pub mod imap_client; pub mod inbuxa; pub mod layouts; diff --git a/tests/integration_inbuxa.rs b/tests/integration_inbuxa.rs index 5214e3f..f8b2ee4 100644 --- a/tests/integration_inbuxa.rs +++ b/tests/integration_inbuxa.rs @@ -14,6 +14,7 @@ use std::path::Path; use std::process::Command; use inbuxa_migrate::db; +use integration::guide::{post, settled, start}; use integration::inbuxa::{ADMIN_EMAIL, ADMIN_PASSWORD, Inbuxa}; use serde_json::{Value, json}; use tempfile::TempDir; @@ -289,3 +290,80 @@ fn a_second_export_updates_flags_and_sieve_names_are_renamed() { )] ); } + +#[test] +#[ignore = "requires Docker"] +fn the_guide_sets_up_the_accounts_previews_and_moves_them() { + let server = Inbuxa::start().expect("start inbuxa"); + let dir = TempDir::new().unwrap(); + let root = dir.path(); + message( + &root.join("mail/example.org/cat"), + "1:2,S", + "cat-1", + "For Cat", + ); + message( + &root.join("mail/other.test/dan"), + "1:2,", + "dan-1", + "For Dan", + ); + let guide = start(BIN, root); + let form = json!({ + "source": {"kind": "maildir", "path": "mail/{domain}/{local}"}, + "accounts": ["cat@example.org", "dan@other.test"], + "create": true, + "target": {"url": server.base_url, "token": server.token}, + "parallel": 2, + }); + let (_, checked) = post(&guide, "api/check-target", &json!({"form": form})); + assert_eq!(checked["ok"], true, "{checked}"); + let job = |kind: &str| { + let (status, body) = post(&guide, "api/job", &json!({"kind": kind, "form": form})); + assert_eq!(status, 200, "{body}"); + let state = settled(&guide); + assert_eq!(state["job"]["exit"], 0, "{state}"); + state["job"]["result"].clone() + }; + + // The preview creates nothing and reads each account's folder. + let preview = job("preview"); + let report = preview["report"].as_str().unwrap(); + assert!(report.contains("(setup),accounts,done,"), "{report}"); + assert!( + report.contains("dan@other.test,import,done,2,2"), + "{report}" + ); + assert!(server.account_of("cat@example.org", "x").is_err()); + + let run = job("run"); + let passwords = + fs::read_to_string(run["passwords"].as_str().expect("a passwords file")).unwrap(); + let password = |email: &str| { + passwords + .lines() + .find_map(|l| l.strip_prefix(&format!("{email},"))) + .unwrap_or_else(|| panic!("{email} not in {passwords}")) + .to_owned() + }; + assert_eq!( + emails(&server, "cat@example.org", &password("cat@example.org")), + [("For Cat".to_owned(), 1, vec!["$seen".to_owned()])] + ); + assert_eq!( + emails(&server, "dan@other.test", &password("dan@other.test")), + [("For Dan".to_owned(), 1, Vec::new())] + ); + + // The final pass finds nothing new. + let last = job("final"); + let report = last["report"].as_str().unwrap(); + assert!( + report + .lines() + .filter(|r| r.contains(",export,")) + .all(|r| r.contains(",export,done,0,0,0,0,")), + "{report}" + ); +} diff --git a/tests/mock_guide.rs b/tests/mock_guide.rs new file mode 100644 index 0000000..d2937d7 --- /dev/null +++ b/tests/mock_guide.rs @@ -0,0 +1,146 @@ +/* + * SPDX-FileCopyrightText: 2026 Coffey Labs LLC + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + */ + +//! `guide` as the browser sees it: the real binary serving its page on +//! 127.0.0.1, answering only its own address and token, and running +//! `migrate` on the plan it writes. Maildir in, offline; the inbuxa side +//! is a port nothing listens on, so the export fails as it should. + +mod integration; + +use std::fs; + +use integration::guide::{get, post, send, settled, start}; +use serde_json::{Value, json}; +use tempfile::TempDir; + +const BIN: &str = env!("CARGO_BIN_EXE_inbuxa-migrate"); + +#[test] +fn the_page_answers_only_its_own_address_and_token() { + let dir = TempDir::new().unwrap(); + let guide = start(BIN, dir.path()); + + let (status, headers, page) = get(&guide, ""); + assert_eq!(status, 200); + assert!(page.contains("Move to inbuxa"), "{page}"); + assert!(headers.contains("Content-Security-Policy: default-src 'self'")); + assert!(headers.contains("Referrer-Policy: no-referrer")); + assert_eq!(get(&guide, "guide.js").0, 200); + + let wrong_token = format!("GET /{}x/ HTTP/1.1\r\nHost: {}", guide.token, guide.host); + assert_eq!(send(&guide, &wrong_token, "").0, 404); + let port = guide.host.rsplit(':').next().unwrap(); + let rebound = format!( + "GET /{}/ HTTP/1.1\r\nHost: attacker.example:{port}", + guide.token + ); + assert_eq!(send(&guide, &rebound, "").0, 403); + let form_post = format!( + "POST /{}/api/job HTTP/1.1\r\nHost: {}\r\nContent-Type: text/plain", + guide.token, guide.host + ); + assert_eq!(send(&guide, &form_post, "{}").0, 415); + let elsewhere = format!( + "POST /{}/api/job HTTP/1.1\r\nHost: {}\r\nContent-Type: application/json\r\nOrigin: https://attacker.example", + guide.token, guide.host + ); + assert_eq!(send(&guide, &elsewhere, "{}").0, 403); +} + +#[test] +fn a_maildir_move_previews_runs_and_reports() { + let dir = TempDir::new().unwrap(); + let root = dir.path(); + let mail = root.join("mail/ann"); + for sub in ["cur", "new", "tmp"] { + fs::create_dir_all(mail.join(sub)).unwrap(); + } + fs::write( + mail.join("cur/1:2,S"), + "From: a@example.org\r\nSubject: Hi\r\nMessage-ID: \r\n\r\nHi\r\n", + ) + .unwrap(); + let guide = start(BIN, root); + + let (_, parsed) = post( + &guide, + "api/accounts", + &json!({"text": "email\nAnn@example.org\nnot one\n"}), + ); + assert_eq!(parsed["accounts"], json!(["ann@example.org"])); + assert_eq!(parsed["rejected"], json!(["not one"])); + + let form = json!({ + "source": {"kind": "maildir", "path": "mail/{local}"}, + "accounts": ["ann@example.org"], + "create": false, + "target": {"url": "http://127.0.0.1:9", "token": "t0ken-for-the-test"}, + "parallel": 2, + }); + let (_, found) = post(&guide, "api/check-source", &json!({"form": form})); + assert_eq!(found["ok"], true, "{found}"); + + let (status, _) = post(&guide, "api/job", &json!({"kind": "preview", "form": form})); + assert_eq!(status, 200); + let state = settled(&guide); + let report = state["job"]["result"]["report"].as_str().unwrap(); + assert!( + report.contains("ann@example.org,import,done,2,2"), + "{report}" + ); + assert_eq!(state["job"]["exit"], 0, "{state}"); + + // The token came once; an empty one keeps it. + let mut again = form.clone(); + again["target"]["token"] = json!(""); + let (status, _) = post(&guide, "api/job", &json!({"kind": "run", "form": again})); + assert_eq!(status, 200); + let state = settled(&guide); + assert_eq!(state["job"]["exit"], 5, "{state}"); + let report = state["job"]["result"]["report"].as_str().unwrap(); + assert!( + report.contains("ann@example.org,import,done,2,2"), + "{report}" + ); + assert!(report.contains("ann@example.org,export,failed"), "{report}"); + assert!( + state["command"] + .as_str() + .unwrap() + .contains("export MIGRATE_INBUXA_TOKEN=…"), + "{state}" + ); + + // The plan is an ordinary one, and nothing written holds the token. + let plan: Value = + serde_json::from_str(&fs::read_to_string(root.join("plan.json")).unwrap()).unwrap(); + assert_eq!( + plan["steps"][0]["args"], + json!(["import", "maildir", "mail/{local}", "{archive}"]) + ); + for name in [ + "plan.json", + "preview-plan.json", + "guide.json", + "work/report.csv", + ] { + let text = fs::read_to_string(root.join(name)).unwrap(); + assert!(!text.contains("t0ken-for-the-test"), "{name}: {text}"); + } + #[cfg(unix)] + { + use std::os::unix::fs::PermissionsExt; + let mode = fs::metadata(root.join("guide.json")) + .unwrap() + .permissions() + .mode(); + assert_eq!(mode & 0o777, 0o600); + } + let saved: Value = + serde_json::from_str(&fs::read_to_string(root.join("guide.json")).unwrap()).unwrap(); + assert_eq!(saved["form"]["target"]["url"], "http://127.0.0.1:9"); +}