@tutao/node-mimimi 259.250106.0 → 259.250108.1

package/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 edition = "2021"
 name = "tutao_node-mimimi"
-version = "259.250102.0"
+version = "259.250108.1"
 
 [lib]
 # need to have lib to be able to use this from rust tests

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tutao/node-mimimi",
-  "version": "259.250106.0",
+  "version": "259.250108.1",
   "main": "./dist/binding.cjs",
   "types": "./dist/binding.d.ts",
   "napi": {
@@ -16,7 +16,7 @@
   },
   "license": "MIT",
   "devDependencies": {
-    "@tutao/otest": "259.250106.0",
+    "@tutao/otest": "259.250108.1",
     "@napi-rs/cli": "^2.18.4",
     "typescript": "5.3.3",
     "zx": "8.1.5"
@@ -33,8 +33,8 @@
     "version": "napi version"
   },
   "optionalDependencies": {
-    "@tutao/node-mimimi-win32-x64-msvc": "259.250106.0",
-    "@tutao/node-mimimi-linux-x64-gnu": "259.250106.0",
-    "@tutao/node-mimimi-darwin-universal": "259.250106.0"
+    "@tutao/node-mimimi-win32-x64-msvc": "259.250108.1",
+    "@tutao/node-mimimi-linux-x64-gnu": "259.250108.1",
+    "@tutao/node-mimimi-darwin-universal": "259.250108.1"
   }
 }

package/src/importer.rs

@@ -8,10 +8,10 @@ use file_reader::{FileImport, FileIterationError};
 use imap_reader::ImapImportConfig;
 use imap_reader::{ImapImport, ImapIterationError};
 use importable_mail::ImportableMail;
+use napi::tokio::sync::{Mutex, MutexGuard};
 use std::fs;
-use std::future::Future;
 use std::path::PathBuf;
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 use std::time::{SystemTime, UNIX_EPOCH};
 use tutasdk::blobs::blob_facade::FileData;
 use tutasdk::crypto::aes;
@@ -20,6 +20,7 @@ use tutasdk::crypto::key::{GenericAesKey, VersionedAesKey};
 use tutasdk::crypto::randomizer_facade::RandomizerFacade;
 use tutasdk::entities::generated::sys::{BlobReferenceTokenWrapper, StringWrapper};
 
+use std::collections::HashMap;
 use tutasdk::entities::generated::tutanota::{
 	ImportAttachment, ImportMailGetIn, ImportMailPostIn, ImportMailPostOut, ImportMailState,
 };
@@ -41,6 +42,12 @@ pub const MAX_REQUEST_SIZE: usize = 1024 * 1024 * 8;
 #[cfg(test)]
 pub const MAX_REQUEST_SIZE: usize = 1024 * 5;
 
+type MailboxId = String;
+
+pub static GLOBAL_IMPORTER_STATES: OnceLock<
+	Mutex<HashMap<MailboxId, Arc<Mutex<LocalImportState>>>>,
+> = OnceLock::new();
+
 // We need this type because IdTupleGenerated cannot be converted to a napi value.
 #[cfg_attr(feature = "javascript", napi_derive::napi(object))]
 #[cfg_attr(test, derive(Debug))]
@@ -115,6 +122,8 @@ pub enum ImportError {
 	FileDeletionError(std::io::Error, PathBuf),
 	IOError(std::io::Error),
 	CannotLoadMailbox,
+	ImporterAlreadyRunning,
+	NoRunningImport,
 }
 
 #[derive(Debug)]
@@ -148,6 +157,7 @@ pub enum ImportStatus {
 	Paused = 1,
 	Canceled = 2,
 	Finished = 3,
+	Error = 4,
 }
 
 /// A running import can be stopped or paused
@@ -179,6 +189,7 @@ pub struct LocalImportState {
 	pub total_count: i64,
 	pub success_count: i64,
 	pub failed_count: i64,
+	pub import_progress_action: ImportProgressAction,
 }
 
 pub struct ImportEssential {
@@ -189,13 +200,6 @@ pub struct ImportEssential {
 	randomizer_facade: RandomizerFacade,
 }
 
-pub struct Importer {
-	pub state: LocalImportState,
-	pub essentials: ImportEssential,
-	source: ImportSource,
-	import_directory: PathBuf,
-}
-
 pub enum ImportSource {
 	RemoteImap { imap_import_client: Box<ImapImport> },
 	LocalFile { fs_email_client: FileImport },
@@ -233,13 +237,6 @@ impl Iterator for ImportSource {
 
 pub type ImportableMailsButcher<Source> =
 	super::reduce_to_chunks::Butcher<{ MAX_REQUEST_SIZE }, AttachmentUploadData, Source>;
-impl Importer {
-	fn make_random_aggregate_id(randomizer_facade: &RandomizerFacade) -> CustomId {
-		let new_id_bytes = randomizer_facade.generate_random_array::<4>();
-		let new_id_string = BASE64_URL_SAFE_NO_PAD.encode(new_id_bytes);
-		CustomId(new_id_string)
-	}
-}
 
 impl ImportEssential {
 	const IMPORT_DISABLED_ERR: ApiCallError = ApiCallError::ServerResponseError {
@@ -472,12 +469,24 @@ impl ImportEssential {
 }
 
 impl LocalImportState {
-	fn change_status(&mut self, new_status: ImportStatus) {
+	pub(crate) fn change_status(&mut self, new_status: ImportStatus) {
 		self.current_status = new_status;
 	}
 }
 
+pub struct Importer {
+	pub(super) state: Arc<Mutex<LocalImportState>>,
+	pub(super) essentials: ImportEssential,
+	source: ImportSource,
+	import_directory: PathBuf,
+}
 impl Importer {
+	fn make_random_aggregate_id(randomizer_facade: &RandomizerFacade) -> CustomId {
+		let new_id_bytes = randomizer_facade.generate_random_array::<4>();
+		let new_id_string = BASE64_URL_SAFE_NO_PAD.encode(new_id_bytes);
+		CustomId(new_id_string)
+	}
+
 	pub async fn create_imap_importer(
 		logged_in_sdk: Arc<LoggedInSdk>,
 		target_owner_group: GeneratedId,
@@ -543,6 +552,7 @@ impl Importer {
 		let randomizer_facade = RandomizerFacade::from_core(rand::rngs::OsRng);
 
 		Self {
+			state: Arc::new(Mutex::new(LocalImportState::new())),
 			source: import_source,
 			essentials: ImportEssential {
 				logged_in_sdk,
@@ -551,23 +561,24 @@ impl Importer {
 				target_mailset,
 				randomizer_facade,
 			},
-			state: LocalImportState::new(),
 			import_directory,
 		}
 	}
 
-	fn update_remote_state_id(
-		local_state: &mut LocalImportState,
+	async fn update_remote_state_id(
+		&self,
 		state_id: IdTupleGenerated,
 		import_directory: PathBuf,
 	) -> Result<(), ImportError> {
 		let min_id = GeneratedId::min_id();
 
-		if local_state.remote_state_id.list_id == min_id.as_str()
-			&& local_state.remote_state_id.element_id == min_id.as_str()
+		let remote_state_id = self.get_state(|state| state.remote_state_id.clone()).await;
+		if remote_state_id.list_id == min_id.as_str()
+			&& remote_state_id.element_id == min_id.as_str()
 		{
 			let generated = state_id.clone();
-			local_state.remote_state_id = state_id.into();
+			self.update_state(|mut state| state.remote_state_id = state_id.clone().into())
+				.await;
 			let mut state_id_file = import_directory.clone();
 			state_id_file.push("import_mail_state");
 
@@ -575,8 +586,9 @@ impl Importer {
 			return Ok(());
 		}
 
+		let remote_state_id = self.get_state(|state| state.remote_state_id.clone()).await;
 		// once id is set, it should always be same
-		if local_state.remote_state_id != state_id.into() {
+		if remote_state_id != state_id.into() {
 			return Err(ImportError::InconsistentStateId);
 		}
 
@@ -594,31 +606,28 @@ impl Importer {
 			.load::<ImportMailState, _>(&id)
 			.await
 	}
-	async fn mark_remote_final_state(
-		&mut self,
-		final_status: ImportStatus,
+	pub(super) async fn mark_remote_final_state(
+		logged_in_sdk: &LoggedInSdk,
+		local_state: &LocalImportState,
 	) -> Result<(), ImportError> {
 		assert!(
-			final_status == ImportStatus::Finished
-				|| final_status == ImportStatus::Canceled
-				|| final_status == ImportStatus::Paused,
+			local_state.current_status == ImportStatus::Finished
+				|| local_state.current_status == ImportStatus::Canceled
+				|| local_state.current_status == ImportStatus::Paused,
 			"only cancel and finished should be final state"
 		);
 
 		// we reached final state before making first call, was either empty mails or was cancelled before making first post call
-		if self.state.remote_state_id
+		if local_state.remote_state_id
 			!= IdTupleGenerated::new(GeneratedId::min_id(), GeneratedId::min_id()).into()
 		{
-			let mut import_state = Self::load_import_state(
-				&self.essentials.logged_in_sdk,
-				self.state.remote_state_id.clone(),
-			)
-			.await
-			.map_err(|e| ImportError::sdk("loading importState before Finished", e))?;
-			import_state.status = final_status as i64;
+			let mut import_state =
+				Self::load_import_state(logged_in_sdk, local_state.remote_state_id.clone())
+					.await
+					.map_err(|e| ImportError::sdk("loading importState before Finished", e))?;
+			import_state.status = local_state.current_status as i64;
 
-			self.essentials
-				.logged_in_sdk
+			logged_in_sdk
 				.mail_facade()
 				.get_crypto_entity_client()
 				.update_instance(import_state)
@@ -630,11 +639,10 @@ impl Importer {
 	}
 
 	pub async fn import_next_chunk(&mut self) -> Result<(), ImportError> {
+		let import_essentials = &self.essentials;
 		let Self {
-			essentials: import_essentials,
 			source: import_source,
-			state: import_state,
-			import_directory,
+			..
 		} = self;
 
 		let attachment_upload_data = import_source.into_iter().map(|importable_mail| {
@@ -648,17 +656,17 @@ impl Importer {
 			ImportableMailsButcher::new(attachment_upload_data, |upload_data| {
 				estimate_json_size(&upload_data.keyed_import_mail_data.import_mail_data)
 			});
-
 		match chunked_mails_provider.next() {
 			// everything have been finished
 			None => {
-				self.state.change_status(ImportStatus::Finished);
+				self.update_state(|mut state| state.change_status(ImportStatus::Finished))
+					.await;
 				Ok(())
 			},
 
 			// this chunk was too big to import
 			Some(Err(_too_big_chunk)) => {
-				self.state.failed_count += 1;
+				self.update_state(|mut state| state.failed_count += 1).await;
 				Err(ImportError::TooBigChunk)?
 			},
 
@@ -674,35 +682,32 @@ impl Importer {
 					.map(|id| id.keyed_import_mail_data.eml_file_path.clone())
 					.collect();
 
+				let mut failed_count: i64 = 0;
+				let remote_state_id = self.get_state(|state| state.remote_state_id.clone()).await;
 				let unit_import_data = import_essentials
 					.upload_attachments_for_chunk(chunked_import_data)
 					.await
-					.inspect_err(|_e| {
-						import_state.failed_count += import_count_in_this_chunk;
-					})?;
+					.inspect_err(|_e| failed_count += import_count_in_this_chunk)?;
 				let importable_post_data = import_essentials
-					.make_serialized_chunk(
-						import_state.remote_state_id.clone().into(),
-						unit_import_data,
-					)
+					.make_serialized_chunk(remote_state_id.into(), unit_import_data)
 					.await
-					.inspect_err(|_e| {
-						import_state.failed_count += import_count_in_this_chunk;
-					})?;
+					.inspect_err(|_e| failed_count += import_count_in_this_chunk)?;
 
 				let import_mails_post_out = import_essentials
 					.make_import_service_call(importable_post_data)
 					.await
-					.inspect_err(|_e| {
-						import_state.failed_count += import_count_in_this_chunk;
-					})?;
+					.inspect_err(|_e| failed_count += import_count_in_this_chunk)?;
 
-				Self::update_remote_state_id(
-					import_state,
+				self.update_state(|mut state| {
+					state.failed_count += failed_count;
+					state.success_count += import_count_in_this_chunk;
+				})
+				.await;
+				self.update_remote_state_id(
 					import_mails_post_out.mailState,
-					import_directory.clone(),
-				)?;
-				import_state.success_count += import_count_in_this_chunk;
+					self.import_directory.clone(),
+				)
+				.await?;
 				for eml_file_path in eml_file_paths.into_iter().flatten() {
 					fs::remove_file(&eml_file_path)
 						.map_err(|e| ImportError::FileDeletionError(e, eml_file_path))?;
@@ -713,49 +718,45 @@ impl Importer {
 		}
 	}
 
-	pub async fn start_stateful_import<CallbackHandle, Err>(
-		&mut self,
-		callback_handle: impl Fn(LocalImportState) -> CallbackHandle,
-	) -> Result<(), Err>
-	where
-		CallbackHandle: Future<Output = Result<StateCallbackResponse, Err>>,
-		Err: From<ImportError>,
-	{
-		self.state.change_status(ImportStatus::Running);
-		'import: loop {
-			let callback_response = callback_handle(self.state.clone()).await?;
-			match callback_response.action {
-				ImportProgressAction::Pause => {
-					self.state.change_status(ImportStatus::Paused);
-					callback_handle(self.state.clone()).await?;
-					self.mark_remote_final_state(ImportStatus::Paused).await?;
-					break 'import Ok(());
-				},
-				ImportProgressAction::Stop => {
-					self.state.change_status(ImportStatus::Canceled);
-					self.mark_remote_final_state(ImportStatus::Canceled).await?;
-					Self::delete_import_dir(&self.import_directory)?;
-					callback_handle(self.state.clone()).await?;
-					break 'import Ok(());
-				},
-				ImportProgressAction::Continue => {
-					self.import_next_chunk().await?;
-					if self.state.current_status == ImportStatus::Finished {
-						self.mark_remote_final_state(ImportStatus::Finished).await?;
-						Self::delete_import_dir(&self.import_directory)?;
-						break 'import Ok(());
-					}
-				},
+	pub async fn start_stateful_import(&mut self) -> Result<(), ImportError> {
+		self.update_state(|mut state| state.change_status(ImportStatus::Running))
+			.await;
+		let mut import_progress_action = ImportProgressAction::Continue;
+
+		while import_progress_action == ImportProgressAction::Continue {
+			self.import_next_chunk().await?;
+
+			let updated_state = self.get_state(|state| state.clone()).await;
+			import_progress_action = updated_state.import_progress_action;
+			eprintln!(
+				"Import state Id: {}",
+				updated_state.remote_state_id.element_id
+			);
+
+			if updated_state.current_status == ImportStatus::Finished {
+				Importer::mark_remote_final_state(&self.essentials.logged_in_sdk, &updated_state)
+					.await?;
+				Self::delete_import_dir(&self.import_directory)?;
+				break;
 			}
 		}
+
+		Ok(())
+	}
+
+	pub(super) async fn update_state<F: Fn(MutexGuard<LocalImportState>)>(&self, f: F) {
+		f(self.state.lock().await)
+	}
+
+	pub(super) async fn get_state<T>(&self, f: fn(state: MutexGuard<LocalImportState>) -> T) -> T {
+		f(self.state.lock().await)
 	}
 
 	pub(super) async fn get_resumable_import(
 		config_directory: String,
 		mailbox_id: String,
 	) -> Result<ResumableImport, ImportError> {
-		let import_directory_path =
-			Importer::get_import_directory(config_directory, GeneratedId::from(mailbox_id));
+		let import_directory_path = Importer::get_import_directory(config_directory, &mailbox_id);
 		let mut state_file_path = import_directory_path.clone();
 		state_file_path.push("import_mail_state");
 
@@ -777,19 +778,19 @@ impl Importer {
 			}
 		}
 
-		Self::delete_import_dir(&state_file_path.parent().unwrap().to_path_buf())?;
+		Self::delete_import_dir(&import_directory_path)?;
 
 		Err(ImportError::NoElementIdForState)
 	}
 
-	fn delete_import_dir(import_directory_path: &PathBuf) -> Result<(), ImportError> {
+	pub(super) fn delete_import_dir(import_directory_path: &PathBuf) -> Result<(), ImportError> {
 		if import_directory_path.exists() {
 			fs::remove_dir_all(import_directory_path)
 				.map_err(|e| ImportError::FileDeletionError(e, import_directory_path.clone()))?;
 		}
 		Ok(())
 	}
-	pub fn get_import_directory(config_directory: String, mailbox_id: GeneratedId) -> PathBuf {
+	pub fn get_import_directory(config_directory: String, mailbox_id: &str) -> PathBuf {
 		[
 			config_directory,
 			"current_imports".into(),
@@ -827,6 +828,7 @@ impl LocalImportState {
 			total_count: 0,
 			success_count: 0,
 			failed_count: 0,
+			import_progress_action: ImportProgressAction::Continue,
 		}
 	}
 }
@@ -856,18 +858,12 @@ mod tests {
 		new_count
 	}
 	pub async fn import_all_of_source(importer: &mut Importer) -> Result<(), ImportError> {
-		importer
-			.start_stateful_import(|_| async {
-				Ok(StateCallbackResponse {
-					action: ImportProgressAction::Continue,
-				})
-			})
-			.await
+		importer.start_stateful_import().await
 	}
 
 	fn assert_same_remote_and_local_state(
 		remote_state: &ImportMailState,
-		local_state: &LocalImportState,
+		local_state: MutexGuard<LocalImportState>,
 	) {
 		// todo! sug
 		// assert_eq!(remote_state.status, local_state.current_status as i64);
@@ -996,13 +992,14 @@ mod tests {
 		greenmail.store_mail("sug@example.org", email_second.as_str());
 
 		import_all_of_source(&mut importer).await.unwrap();
-		let remote_state = Importer::load_import_state(
-			&importer.essentials.logged_in_sdk,
-			importer.state.remote_state_id.clone(),
-		)
-		.await
-		.unwrap();
-		assert_same_remote_and_local_state(&remote_state, &importer.state);
+		let remote_state_id = importer
+			.get_state(|state| state.remote_state_id.clone())
+			.await;
+		let remote_state =
+			Importer::load_import_state(&importer.essentials.logged_in_sdk, remote_state_id)
+				.await
+				.unwrap();
+		assert_same_remote_and_local_state(&remote_state, importer.state.lock().await);
 
 		assert_eq!(remote_state.status, ImportStatus::Finished as i64);
 		assert_eq!(remote_state.failedMails, 0);
@@ -1017,14 +1014,15 @@ mod tests {
 		greenmail.store_mail("sug@example.org", email.as_str());
 
 		import_all_of_source(&mut importer).await.unwrap();
-		let remote_state = Importer::load_import_state(
-			&importer.essentials.logged_in_sdk,
-			importer.state.remote_state_id.clone(),
-		)
-		.await
-		.unwrap();
+		let remote_state_id = importer
+			.get_state(|state| state.remote_state_id.clone())
+			.await;
+		let remote_state =
+			Importer::load_import_state(&importer.essentials.logged_in_sdk, remote_state_id)
+				.await
+				.unwrap();
 
-		assert_same_remote_and_local_state(&remote_state, &importer.state);
+		assert_same_remote_and_local_state(&remote_state, importer.state.lock().await);
 		assert_eq!(remote_state.status, ImportStatus::Finished as i64);
 		assert_eq!(remote_state.failedMails, 0);
 		assert_eq!(remote_state.successfulMails, 1);
@@ -1034,14 +1032,15 @@ mod tests {
 	async fn can_import_single_eml_file_without_attachment() {
 		let mut importer = init_file_importer(vec!["sample.eml"]).await;
 		import_all_of_source(&mut importer).await.unwrap();
-		let remote_state = Importer::load_import_state(
-			&importer.essentials.logged_in_sdk,
-			importer.state.remote_state_id.clone(),
-		)
-		.await
-		.unwrap();
+		let remote_state_id = importer
+			.get_state(|state| state.remote_state_id.clone())
+			.await;
+		let remote_state =
+			Importer::load_import_state(&importer.essentials.logged_in_sdk, remote_state_id)
+				.await
+				.unwrap();
 
-		assert_same_remote_and_local_state(&remote_state, &importer.state);
+		assert_same_remote_and_local_state(&remote_state, importer.state.lock().await);
 		assert_eq!(remote_state.status, ImportStatus::Finished as i64);
 		assert_eq!(remote_state.failedMails, 0);
 		assert_eq!(remote_state.successfulMails, 1);
@@ -1051,14 +1050,15 @@ mod tests {
 	async fn can_import_single_eml_file_with_attachment() {
 		let mut importer = init_file_importer(vec!["attachment_sample.eml"]).await;
 		import_all_of_source(&mut importer).await.unwrap();
-		let remote_state = Importer::load_import_state(
-			&importer.essentials.logged_in_sdk,
-			importer.state.remote_state_id.clone(),
-		)
-		.await
-		.unwrap();
+		let remote_state_id = importer
+			.get_state(|state| state.remote_state_id.clone())
+			.await;
+		let remote_state =
+			Importer::load_import_state(&importer.essentials.logged_in_sdk, remote_state_id)
+				.await
+				.unwrap();
 
-		assert_same_remote_and_local_state(&remote_state, &importer.state);
+		assert_same_remote_and_local_state(&remote_state, importer.state.lock().await);
 		assert_eq!(remote_state.status, ImportStatus::Finished as i64);
 		assert_eq!(remote_state.failedMails, 0);
 		assert_eq!(remote_state.successfulMails, 1);
@@ -1069,21 +1069,14 @@ mod tests {
 	async fn should_stop_if_on_stop_action() {
 		let mut importer = init_file_importer(vec!["sample.eml"; 3]).await;
 
-		let callback_resolver = |_| async {
-			Result::<_, ImportError>::Ok(StateCallbackResponse {
-				action: ImportProgressAction::Stop,
-			})
-		};
-		importer
-			.start_stateful_import(callback_resolver)
-			.await
-			.unwrap();
-		let remote_state = Importer::load_import_state(
-			&importer.essentials.logged_in_sdk,
-			importer.state.remote_state_id.clone(),
-		)
-		.await
-		.unwrap();
+		importer.start_stateful_import().await.unwrap();
+		let remote_state_id = importer
+			.get_state(|state| state.remote_state_id.clone())
+			.await;
+		let remote_state =
+			Importer::load_import_state(&importer.essentials.logged_in_sdk, remote_state_id)
+				.await
+				.unwrap();
 
 		assert_eq!(remote_state.status, ImportStatus::Canceled as i64);
 		assert_eq!(remote_state.failedMails, 0);

package/src/importer_api.rs

@@ -1,11 +1,12 @@
 use super::importer::{
-	ImportError, ImportMailStateId, Importer, IterationError, LocalImportState, ResumableImport,
-	StateCallbackResponse,
+	ImportError, ImportMailStateId, ImportProgressAction, ImportStatus, Importer, IterationError,
+	LocalImportState, ResumableImport, GLOBAL_IMPORTER_STATES,
 };
 use crate::importer::file_reader::FileImport;
-use napi::bindgen_prelude::Promise;
-use napi::threadsafe_function::ThreadsafeFunction;
+use napi::tokio::sync::Mutex;
+use napi::tokio::sync::MutexGuard;
 use napi::Env;
+use std::collections::HashMap;
 use std::fs;
 use std::path::PathBuf;
 use std::sync::Arc;
@@ -13,17 +14,6 @@ use tutasdk::login::{CredentialType, Credentials};
 use tutasdk::net::native_rest_client::NativeRestClient;
 use tutasdk::{GeneratedId, IdTupleGenerated, LoggedInSdk};
 
-pub type NapiTokioMutex<T> = napi::tokio::sync::Mutex<T>;
-
-/// Javascript function to check for state change
-type StateCallback =
-	ThreadsafeFunction<LocalImportState, napi::threadsafe_function::ErrorStrategy::Fatal>;
-
-#[napi_derive::napi]
-pub struct ImporterApi {
-	pub(crate) inner: Arc<NapiTokioMutex<Importer>>,
-}
-
 #[napi_derive::napi(object)]
 #[derive(Clone)]
 /// Passed in from js-side, will be validated before being converted to proper tuta sdk credentials.
@@ -38,18 +28,29 @@ pub struct TutaCredentials {
 	pub is_internal_credential: bool,
 }
 
+#[napi_derive::napi]
+pub struct ImporterApi {}
+
 impl ImporterApi {
+	pub async fn get_running_imports<'a>(
+	) -> MutexGuard<'a, HashMap<String, Arc<Mutex<LocalImportState>>>> {
+		GLOBAL_IMPORTER_STATES
+			.get_or_init(|| Mutex::new(HashMap::new()))
+			.lock()
+			.await
+	}
+
 	pub async fn create_file_importer_inner(
 		logged_in_sdk: Arc<LoggedInSdk>,
 		target_owner_group: String,
 		target_mailset: IdTupleGenerated,
 		source_paths: Vec<PathBuf>,
 		import_directory: PathBuf,
-	) -> napi::Result<ImporterApi> {
+	) -> napi::Result<Importer> {
 		let target_owner_group = GeneratedId(target_owner_group);
 
 		let source_count = source_paths.len() as i64;
-		let mut importer = Importer::create_file_importer(
+		let importer = Importer::create_file_importer(
 			logged_in_sdk,
 			target_owner_group,
 			target_mailset,
@@ -58,10 +59,11 @@ impl ImporterApi {
 		)
 		.await?;
 
-		importer.state.total_count = source_count;
-		Ok(ImporterApi {
-			inner: Arc::new(NapiTokioMutex::new(importer)),
-		})
+		importer
+			.update_state(|mut state| state.total_count = source_count)
+			.await;
+
+		Ok(importer)
 	}
 
 	async fn create_sdk(
@@ -83,64 +85,77 @@ impl ImporterApi {
 #[napi_derive::napi]
 impl ImporterApi {
 	#[napi]
-	pub async unsafe fn start_import(
-		&mut self,
-		callback_handle: StateCallback,
-	) -> napi::Result<()> {
-		let callback_handle_provider = |local_state: LocalImportState| async {
-			let res = callback_handle
-				.call_async::<Promise<StateCallbackResponse>>(local_state)
-				.await;
-			match res {
-				Ok(promise) => promise.await,
-				Err(e) => Err(e),
-			}
-		};
-
-		let mut importer = self.inner.lock().await;
-		importer
-			.start_stateful_import(callback_handle_provider)
-			.await?;
-
-		Ok(())
+	pub async fn get_import_state(mailbox_id: String) -> napi::Result<Option<LocalImportState>> {
+		let locked_importer_states = Self::get_running_imports().await;
+		match locked_importer_states.get(&mailbox_id) {
+			Some(locked_state) => Ok(Some({
+				let state = locked_state.lock().await.clone();
+				state
+			})),
+			None => Ok(None),
+		}
 	}
 
 	#[napi]
-	pub async fn create_file_importer(
+	pub async fn start_file_import(
+		mailbox_id: String,
 		tuta_credentials: TutaCredentials,
 		target_owner_group: String,
 		target_mailset_id: (String, String),
 		source_paths: Vec<String>,
 		config_directory: String,
-	) -> napi::Result<ImporterApi> {
-		let (target_mailset_lid, target_mailset_eid) = target_mailset_id;
-
+	) -> napi::Result<()> {
 		let logged_in_sdk = ImporterApi::create_sdk(tuta_credentials).await?;
+
+		let mut running_imports = Self::get_running_imports().await;
+		if let Some(import) = running_imports.get_mut(&mailbox_id) {
+			let current_status = import.lock().await.current_status;
+			if current_status != ImportStatus::Running {
+				running_imports.remove(&mailbox_id);
+			} else {
+				Err(ImportError::ImporterAlreadyRunning)?;
+			}
+		}
+
+		let (target_mailset_lid, target_mailset_eid) = target_mailset_id;
 		let target_mailset = IdTupleGenerated::new(
 			GeneratedId(target_mailset_lid),
 			GeneratedId(target_mailset_eid),
 		);
-		let mailbox_id = logged_in_sdk
-			.mail_facade()
-			.load_user_mailbox()
-			.await
-			.map_err(|e| ImportError::sdk("loading mailbox", e))?
-			._id
-			.ok_or(ImportError::CannotLoadMailbox)?;
 		let import_directory: PathBuf =
-			Importer::get_import_directory(config_directory, mailbox_id);
+			Importer::get_import_directory(config_directory, &mailbox_id);
 		let source_paths = source_paths.into_iter().map(PathBuf::from).collect();
 		let eml_sources = FileImport::prepare_import(import_directory.clone(), source_paths)
 			.map_err(|e| ImportError::IterationError(IterationError::File(e)))?;
 
-		Self::create_file_importer_inner(
+		let inner = Self::create_file_importer_inner(
 			logged_in_sdk,
 			target_owner_group,
 			target_mailset,
 			eml_sources,
 			import_directory,
 		)
-		.await
+		.await?;
+
+		running_imports.insert(mailbox_id.clone(), inner.state.clone());
+		drop(running_imports);
+
+		Self::spawn_importer_task(inner);
+		Ok(())
+	}
+
+	fn spawn_importer_task(mut inner: Importer) {
+		napi::tokio::task::spawn(async move {
+			match inner.start_stateful_import().await {
+				Ok(_) => {},
+				Err(e) => {
+					log::error!("Importer task failed: {:?}", e);
+					inner
+						.update_state(|mut state| state.change_status(ImportStatus::Error))
+						.await;
+				},
+			};
+		});
 	}
 
 	#[napi]
@@ -155,10 +170,11 @@ impl ImporterApi {
 
 	#[napi]
 	pub async fn resume_file_import(
+		mailbox_id: String,
 		tuta_credentials: TutaCredentials,
 		mail_state_id: ImportMailStateId,
 		config_directory: String,
-	) -> napi::Result<ImporterApi> {
+	) -> napi::Result<()> {
 		let logged_in_sdk = ImporterApi::create_sdk(tuta_credentials).await?;
 		let import_state = Importer::load_import_state(&logged_in_sdk, mail_state_id)
 			.await
@@ -168,15 +184,8 @@ impl ImporterApi {
 		let target_owner_group = import_state
 			._ownerGroup
 			.expect("import state should have ownerGroup");
-		let mailbox_id = logged_in_sdk
-			.mail_facade()
-			.load_user_mailbox()
-			.await
-			.map_err(|e| ImportError::sdk("loading mailbox", e))?
-			._id
-			.ok_or(ImportError::CannotLoadMailbox)?;
-		let import_directory: PathBuf =
-			Importer::get_import_directory(config_directory, mailbox_id);
+
+		let import_directory = Importer::get_import_directory(config_directory, &mailbox_id);
 
 		let dir_entries = fs::read_dir(&import_directory)?;
 		let mut source_paths: Vec<PathBuf> = vec![];
@@ -191,24 +200,82 @@ impl ImporterApi {
 			}
 		}
 
-		Self::create_file_importer_inner(
+		let inner = Self::create_file_importer_inner(
 			logged_in_sdk,
 			target_owner_group.as_str().to_string(),
 			target_mailset,
 			source_paths,
 			import_directory,
 		)
-		.await
+		.await?;
+
+		{
+			let mut running_imports = Self::get_running_imports().await;
+			running_imports.insert(mailbox_id.clone(), inner.state.clone());
+		}
+
+		Self::spawn_importer_task(inner);
+		Ok(())
+	}
+
+	#[napi]
+	pub async fn set_progress_action(
+		mailbox_id: String,
+		tuta_credentials: TutaCredentials,
+		import_progress_action: ImportProgressAction,
+		config_directory: String,
+	) -> napi::Result<()> {
+		let mut running_imports = Self::get_running_imports().await;
+		let locked_local_state = running_imports.get_mut(mailbox_id.as_str());
+		let import_directory_path = Importer::get_import_directory(config_directory, &mailbox_id);
+
+		match locked_local_state {
+			Some(local_import_state) => {
+				let logged_in_sdk = ImporterApi::create_sdk(tuta_credentials).await?;
+				let mut local_import_state = local_import_state.lock().await;
+				local_import_state.import_progress_action = import_progress_action;
+
+				match import_progress_action {
+					ImportProgressAction::Continue => Ok(()),
+
+					ImportProgressAction::Pause => {
+						local_import_state.current_status = ImportStatus::Paused;
+						Importer::mark_remote_final_state(&logged_in_sdk, &local_import_state)
+							.await?;
+
+						Ok(())
+					},
+
+					ImportProgressAction::Stop => {
+						let previous_status = local_import_state.current_status;
+						local_import_state.current_status = ImportStatus::Canceled;
+						Importer::mark_remote_final_state(&logged_in_sdk, &local_import_state)
+							.await?;
+
+						if previous_status != ImportStatus::Running {
+							Importer::delete_import_dir(&import_directory_path)?;
+						}
+
+						Ok(())
+					},
+				}
+			},
+
+			None => {
+				Importer::delete_import_dir(&import_directory_path)?;
+				Ok(())
+			},
+		}
 	}
 
 	#[napi]
-	pub unsafe fn init_log(env: Env) {
+	pub fn init_log(env: Env) {
 		// this is in a separate fn because Env isn't Send, so can't be used in async fn.
 		crate::logging::console::Console::init(env)
 	}
 
 	#[napi]
-	pub unsafe fn deinit_log() {
+	pub fn deinit_log() {
 		crate::logging::console::Console::deinit();
 	}
 }

package/src/logging/console.rs

@@ -1,18 +1,22 @@
 use crate::logging::logger::{LogLevel, LogMessage, Logger};
 use log::{Level, LevelFilter, Log, Metadata, Record};
-use napi::sys::{napi_async_work, napi_cancel_async_work};
-use napi::{AsyncWorkPromise, Env, Task};
-use std::sync::OnceLock;
+use napi::Env;
+use std::sync::mpsc::Sender;
+use std::sync::Once;
+use std::sync::RwLock;
 
 const TAG: &str = file!();
 
-pub static mut GLOBAL_CONSOLE: OnceLock<Console> = OnceLock::new();
+/// Maintain one instance of the logger, as the log crate can only have the logger be set exactly
+/// once.
+static GLOBAL_CONSOLE: Console = Console {
+	sender: RwLock::new(None),
+};
 
 /// A way for the rust code to log messages to the main applications log files
 /// without having to deal with obtaining a reference to console each time.
-#[derive(Clone)]
 pub struct Console {
-	tx: std::sync::mpsc::Sender<LogMessage>,
+	sender: RwLock<Option<Sender<LogMessage>>>,
 }
 
 impl Log for Console {
@@ -28,56 +32,59 @@ impl Log for Console {
 
 		let tag = record.file().unwrap_or("<unknown>").to_string();
 
-		let _ = self.tx.send(LogMessage {
-			level: record.metadata().level().into(),
-			message: format!("{}", record.args()),
-			tag,
-		});
+		let lock = self.sender.read().expect("poisoned");
+		if let Some(sender) = lock.as_ref() {
+			let _ = sender.send(LogMessage {
+				level: record.metadata().level().into(),
+				message: format!("{}", record.args()),
+				tag,
+			});
+		}
 	}
 
 	fn flush(&self) {}
 }
 
 impl Console {
-	pub unsafe fn init(env: Env) {
-		if GLOBAL_CONSOLE.get().is_some() {
+	pub fn init(env: Env) {
+		Self::init_global_state();
+
+		let mut current_sender = GLOBAL_CONSOLE.sender.write().expect("poisoned");
+		if current_sender.is_some() {
 			// some other thread already initialized the cell, we don't need to set up the logger.
 			return;
 		}
+
 		let (tx, rx) = std::sync::mpsc::channel::<LogMessage>();
-		let console = Console { tx };
 		let logger = Logger::new(rx);
 		let maybe_async_task = env.spawn(logger);
 
 		match maybe_async_task {
 			Ok(_logger_task) => {
-				console.log(
+				*current_sender = Some(tx);
+				drop(current_sender);
+				GLOBAL_CONSOLE.log(
 					&Record::builder()
 						.level(Level::Info)
 						.file(Some(TAG))
 						.args(format_args!("{}", "spawned logger"))
 						.build(),
 				);
-
-				GLOBAL_CONSOLE
-					.set(console)
-					.map_err(|_| "can not set")
-					.unwrap();
-
-				let console = GLOBAL_CONSOLE.get().unwrap();
-				set_panic_hook(&console);
-				log::set_logger(console).unwrap_or_else(|e| eprintln!("failed to set logger: {e}"));
-				log::set_max_level(LevelFilter::Info);
 			},
 			Err(e) => {
 				eprintln!("failed to spawn logger: {e}");
 			},
 		}
 	}
-	pub unsafe fn deinit() {
-		let console = GLOBAL_CONSOLE.take().expect("cannot deinit logger before initializing");
-		console
-			.tx
+
+	pub fn deinit() {
+		let sender = GLOBAL_CONSOLE
+			.sender
+			.write()
+			.expect("poisoned")
+			.take()
+			.expect("cannot deinit logger before initializing");
+		sender
 			.send(LogMessage {
 				level: LogLevel::Finish,
 				message: "called deinit".to_string(),
@@ -85,42 +92,59 @@ impl Console {
 			})
 			.expect("Can not send finish log message. Receiver already disconnected");
 	}
-}
 
-/// set a panic hook that tries to log the panic to the JS side before continuing
-/// a normal unwind. should work unless the panicking thread is the main thread.
-fn set_panic_hook(console: &'static Console) {
-	let logger_thread_id = std::thread::current().id();
-	let panic_console = console.clone();
-	let old_panic_hook = std::panic::take_hook();
-	std::panic::set_hook(Box::new(move |panic_info| {
-		let formatted_info = panic_info.to_string();
-		let formatted_stack = std::backtrace::Backtrace::force_capture().to_string();
-		if logger_thread_id == std::thread::current().id() {
-			// logger is (probably) running on the currently panicking thread,
-			// so we can't use it to log to JS. this at least shows up in stderr.
-			eprintln!("PANIC MAIN {}", formatted_info);
-			eprintln!("PANIC MAIN {}", formatted_stack);
-		} else {
-			panic_console.log(
-				&Record::builder()
-					.level(Level::Error)
-					.file(Some("PANIC"))
-					.args(format_args!(
-						"thread {} {}",
-						std::thread::current().name().unwrap_or("<unknown>"),
-						formatted_info
-					))
-					.build(),
-			);
-			panic_console.log(
-				&Record::builder()
-					.level(Level::Error)
-					.file(Some("PANIC"))
-					.args(format_args!("{}", formatted_stack.as_str()))
-					.build(),
-			);
-		}
-		old_panic_hook(panic_info)
-	}));
+	/// Sets the panic hook and global logger.
+	///
+	/// This function must be called once before the console can be used, but it can be safely
+	/// called multiple times, and it is thread-safe.
+	fn init_global_state() {
+		// Limit scope to this function only.
+		static GLOBAL_CONSOLE_SETUP: Once = Once::new();
+
+		GLOBAL_CONSOLE_SETUP.call_once(|| {
+			// Sets the logger to the static instance and sets up the panic hook.
+			// This can fail if the logger was set somewhere else.
+			if let Err(e) = log::set_logger(&GLOBAL_CONSOLE) {
+				eprintln!("failed to set logger: {e}");
+			} else {
+				log::set_max_level(LevelFilter::Info);
+			}
+
+			// set a panic hook that tries to log the panic to the JS side before continuing
+			// a normal unwind. should work unless the panicking thread is the main thread.
+			let logger_thread_id = std::thread::current().id();
+			let old_panic_hook = std::panic::take_hook();
+
+			std::panic::set_hook(Box::new(move |panic_info| {
+				let formatted_info = panic_info.to_string();
+				let formatted_stack = std::backtrace::Backtrace::force_capture().to_string();
+				if logger_thread_id == std::thread::current().id() {
+					// logger is (probably) running on the currently panicking thread,
+					// so we can't use it to log to JS. this at least shows up in stderr.
+					eprintln!("PANIC MAIN {}", formatted_info);
+					eprintln!("PANIC MAIN {}", formatted_stack);
+				} else {
+					GLOBAL_CONSOLE.log(
+						&Record::builder()
+							.level(Level::Error)
+							.file(Some("PANIC"))
+							.args(format_args!(
+								"thread {} {}",
+								std::thread::current().name().unwrap_or("<unknown>"),
+								formatted_info
+							))
+							.build(),
+					);
+					GLOBAL_CONSOLE.log(
+						&Record::builder()
+							.level(Level::Error)
+							.file(Some("PANIC"))
+							.args(format_args!("{}", formatted_stack.as_str()))
+							.build(),
+					);
+				}
+				old_panic_hook(panic_info)
+			}));
+		});
+	}
 }