π End-to-end encrypted cloud for everything.
Dart 2faandroidauthye2eeencryptionend-to-end-encryptionfluttergolanggoogle-photosgoogle-photos-alternativeiosopensourcephotosprivacyprivacy-toolstypescriptzero-knowledge
use std::collections::HashMap;
use std::env;
use std::error::Error;
use std::ffi::OsStr;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::{SystemTime, UNIX_EPOCH};
use camino::Utf8PathBuf;
use lib_flutter_rust_bridge_codegen::codegen::{
self as frb_codegen, Config as FrbConfig, MetaConfig as FrbMetaConfig,
};
use uniffi_bindgen::bindings::{self, GenerateOptions, TargetLanguage};
type DynError = Box<dyn Error>;
struct UniffiCrate<'a> {
crate_name: &'a str,
crate_dir: PathBuf,
}
#[derive(Clone, Copy)]
enum NativeTarget {
All,
Ensu,
Cast,
}
#[derive(Clone, Copy)]
enum FrbTarget {
All,
Auth,
Photos,
Locker,
}
fn main() {
if let Err(error) = run() {
eprintln!("{error}");
std::process::exit(1);
}
}
fn run() -> Result<(), DynError> {
let mut args = env::args().skip(1);
match args.next().as_deref() {
Some("native") => {
let target = match args.next().as_deref() {
None => NativeTarget::All,
Some("ensu") => NativeTarget::Ensu,
Some("cast") => NativeTarget::Cast,
_ => return Err(usage_error()),
};
if args.next().is_some() {
return Err(usage_error());
}
generate_native(target)
}
Some("frb") => {
let target = match args.next().as_deref() {
None => FrbTarget::All,
Some("auth") => FrbTarget::Auth,
Some("photos") => FrbTarget::Photos,
Some("locker") => FrbTarget::Locker,
_ => return Err(usage_error()),
};
if args.next().is_some() {
return Err(usage_error());
}
generate_frb(target)
}
Some("napi") => {
if args.next().is_some() {
return Err(usage_error());
}
generate_napi()
}
_ => Err(usage_error()),
}
}
fn usage_error() -> DynError {
"usage: cargo codegen <native [ensu|cast]|frb [auth|photos|locker]|napi>".into()
}
fn generate_native(target: NativeTarget) -> Result<(), DynError> {
let rust_root = rust_root()?;
if matches!(target, NativeTarget::All | NativeTarget::Ensu) {
let ensu = UniffiCrate {
crate_name: "ensu",
crate_dir: rust_root.join("bindings/uniffi/ensu"),
};
generate_swift(&ensu, "apple/apps/ensu/Ensu/Generated")?;
generate_kotlin(
&ensu,
"android/apps/ensu/rust/src/main/kotlin",
"io/ente/ensu/bindings/ensu.kt",
)?;
}
if matches!(target, NativeTarget::All | NativeTarget::Cast) {
let cast = UniffiCrate {
crate_name: "cast",
crate_dir: rust_root.join("bindings/uniffi/cast"),
};
generate_swift(&cast, "apple/apps/cast/Cast/Generated")?;
// TODO: Android cast bindings scaffold
// generate_kotlin(
// &cast,
// "android/apps/cast/app/src/main/kotlin",
// "io/ente/cast/bindings/cast.kt",
// )?;
}
Ok(())
}
fn generate_swift(uniffi_crate: &UniffiCrate<'_>, generated_rel: &str) -> Result<(), DynError> {
let generated_dir = repo_root()?.join(generated_rel);
write_generated_gitignore(&generated_dir)?;
build_host_library(&uniffi_crate.crate_dir)?;
remove_paths(&swift_generated_paths(
&generated_dir,
uniffi_crate.crate_name,
))?;
generate_bindings(TargetLanguage::Swift, &generated_dir, uniffi_crate)?;
sanitize_generated_swift_bindings(
&generated_dir.join(format!("{}.swift", uniffi_crate.crate_name)),
uniffi_crate.crate_name,
)?;
Ok(())
}
fn generate_kotlin(
uniffi_crate: &UniffiCrate<'_>,
out_rel: &str,
generated_rel: &str,
) -> Result<(), DynError> {
let rust_out_dir = repo_root()?.join(out_rel);
let generated_path = rust_out_dir.join(generated_rel);
if let Some(bindings_dir) = generated_path.parent() {
write_generated_gitignore(bindings_dir)?;
}
build_host_library(&uniffi_crate.crate_dir)?;
remove_path(&generated_path)?;
generate_bindings(TargetLanguage::Kotlin, &rust_out_dir, uniffi_crate)?;
Ok(())
}
fn write_generated_gitignore(dir: &Path) -> Result<(), DynError> {
fs::create_dir_all(dir)?;
let path = dir.join(".gitignore");
fs::write(&path, "*\n!.gitignore\n")
.map_err(|error| format!("failed to write {}: {error}", path.display()).into())
}
fn generate_frb(target: FrbTarget) -> Result<(), DynError> {
let rust_root = rust_root()?;
let repo_root = rust_root
.parent()
.ok_or("failed to resolve repo root from rust/tools/codegen")?;
let apps: &[&str] = match target {
FrbTarget::All => &["auth", "photos", "locker"],
FrbTarget::Auth => &["auth"],
FrbTarget::Photos => &["photos"],
FrbTarget::Locker => &["locker"],
};
let shared_dir = repo_root.join("mobile/packages/frb/lib");
write_generated_gitignore(&shared_dir)?;
let mut shared_types = HashMap::new();
for app in apps {
let package_dir = repo_root.join("mobile/apps").join(app);
let generated_dir = package_dir.join("lib/src/rust");
if generated_dir.exists() {
fs::remove_dir_all(&generated_dir)?;
}
generate_frb_package(&package_dir)?;
for name in ["account_deletion", "accounts", "contacts", "legacy"] {
if *app == "auth" && matches!(name, "contacts" | "legacy") {
continue;
}
let types_path = package_dir
.join("lib/src/rust/third_party/ente_frb_lib")
.join(format!("{name}/types.dart"));
let types = fs::read_to_string(&types_path)?
.replace(
"part 'types.freezed.dart';",
&format!("part '{name}.freezed.dart';"),
)
.lines()
.filter(|line| !line.ends_with("/frb_generated.dart';"))
.collect::<Vec<_>>()
.join("\n")
+ "\n";
if shared_types
.get(name)
.is_some_and(|previous| previous != &types)
{
return Err(format!("Apps generated different shared {name} types").into());
}
let freezed_file = format!("{name}.freezed.dart");
if types.contains(&format!("part '{freezed_file}';")) {
let freezed_path = types_path.with_extension("freezed.dart");
let freezed = fs::read_to_string(&freezed_path)?
.replace("part of 'types.dart';", &format!("part of '{name}.dart';"));
fs::write(shared_dir.join(freezed_file), freezed)?;
fs::remove_file(freezed_path)?;
}
fs::write(shared_dir.join(format!("{name}.dart")), &types)?;
fs::write(
types_path,
format!(
"// This file is automatically generated, so please do not edit it.\n\n\
export 'package:ente_frb/{name}.dart';\n"
),
)?;
shared_types.insert(name, types);
}
}
if apps.contains(&"photos") {
let notifications = UniffiCrate {
crate_name: "ente_notification_uniffi",
crate_dir: rust_root.join("bindings/uniffi/notifications"),
};
generate_swift(
¬ifications,
"mobile/apps/photos/ios/NotificationServiceExtension/Generated",
)?;
}
format_frb_bindings(target)
}
fn generate_frb_package(package_dir: &Path) -> Result<(), DynError> {
let previous_dir = env::current_dir().map_err(|error| {
format!("failed to capture current directory before generating FRB bindings: {error}")
})?;
env::set_current_dir(package_dir).map_err(|error| {
format!(
"failed to enter {} before generating FRB bindings: {error}",
package_dir.display()
)
})?;
let result = FrbConfig::from_files_auto().and_then(|config| {
let config = FrbConfig::merge(
FrbConfig {
build_runner: Some(false),
dart_fix: Some(false),
dart_format: Some(false),
..Default::default()
},
config,
);
frb_codegen::generate(config, FrbMetaConfig { watch: false })
});
env::set_current_dir(&previous_dir).map_err(|error| {
format!(
"failed to restore current directory to {}: {error}",
previous_dir.display()
)
})?;
result?;
let dart = if cfg!(windows) { "dart.bat" } else { "dart" };
run_command(
Command::new(dart)
.args(["run", "build_runner", "build"])
.current_dir(package_dir),
format!("failed to generate Dart code in {}", package_dir.display()),
)?;
run_command(
Command::new(dart)
.args(["format", "lib/src/rust"])
.current_dir(package_dir),
format!("failed to format Dart code in {}", package_dir.display()),
)
}
fn generate_napi() -> Result<(), DynError> {
let rust_root = rust_root()?;
let desktop_dir = repo_root()?.join("desktop");
ensure_napi_codegen_dependencies(&desktop_dir)?;
let out_dir = desktop_dir.join("rust-bindings");
write_generated_gitignore(&out_dir)?;
let type_def_dir = target_dir()?.join("napi-type-defs");
match fs::remove_dir_all(&type_def_dir) {
Ok(()) => {}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => {
return Err(format!("failed to clear {}: {error}", type_def_dir.display()).into());
}
}
fs::create_dir_all(&type_def_dir)?;
let force_build = SystemTime::now()
.duration_since(UNIX_EPOCH)?
.as_nanos()
.to_string();
run_command(
Command::new("cargo")
.arg("check")
.arg("--locked")
.arg("-p")
.arg("ente-photos-napi")
.arg("--target-dir")
.arg(target_dir()?)
.env("NAPI_TYPE_DEF_TMP_FOLDER", &type_def_dir)
.env("NAPI_FORCE_BUILD_ENTE_PHOTOS_NAPI", force_build)
.current_dir(&rust_root),
"failed to type-check the desktop Node bindings".to_owned(),
)?;
run_command(
Command::new("node")
.arg("scripts/napi.js")
.arg("dts")
.arg(&type_def_dir)
.arg(out_dir.join("index.d.ts"))
.current_dir(&desktop_dir),
"failed to render the TypeScript declarations".to_owned(),
)
}
fn ensure_napi_codegen_dependencies(desktop_dir: &Path) -> Result<(), DynError> {
let status = Command::new("node")
.arg("-e")
.arg("try { require.resolve('@napi-rs/cli') } catch { process.exit(1) }")
.current_dir(desktop_dir)
.status()
.map_err(|error| {
format!(
concat!(
"N-API codegen requires Node.js and the desktop npm dependencies.\n\n",
"Failed to run Node.js:\n",
" {}\n\n",
"After installing Node.js, run:\n",
" (cd \"{}\" && npm ci)"
),
error,
desktop_dir.display(),
)
})?;
if !status.success() {
return Err(format!(
concat!(
"N-API codegen requires the desktop npm dependencies.\n\n",
"Run:\n",
" (cd \"{}\" && npm ci)"
),
desktop_dir.display(),
)
.into());
}
Ok(())
}
fn format_frb_bindings(target: FrbTarget) -> Result<(), DynError> {
let rust_root = rust_root()?;
let mut command = Command::new("cargo");
command.arg("fmt");
match target {
FrbTarget::All => {
command
.arg("-p")
.arg("ente-auth-frb")
.arg("-p")
.arg("ente-photos-frb")
.arg("-p")
.arg("ente-locker-frb");
}
FrbTarget::Auth => {
command.arg("-p").arg("ente-auth-frb");
}
FrbTarget::Photos => {
command.arg("-p").arg("ente-photos-frb");
}
FrbTarget::Locker => {
command.arg("-p").arg("ente-locker-frb");
}
}
command.current_dir(rust_root);
run_command(
&mut command,
"failed to format generated FRB Rust bindings".to_owned(),
)
}
fn rust_root() -> Result<PathBuf, DynError> {
let root = env::current_dir()?;
if !root.join("Cargo.toml").is_file() {
return Err("run cargo codegen from the Rust workspace root".into());
}
Ok(root)
}
fn repo_root() -> Result<PathBuf, DynError> {
Ok(rust_root()?
.parent()
.ok_or("failed to resolve repo root from rust/tools/codegen")?
.to_path_buf())
}
fn target_dir() -> Result<PathBuf, DynError> {
Ok(rust_root()?.join("target"))
}
fn build_host_library(crate_dir: &Path) -> Result<(), DynError> {
let target_dir = target_dir()?;
run_command(
Command::new("cargo")
.arg("build")
.arg("--locked")
.arg("--target-dir")
.arg(target_dir)
.current_dir(crate_dir),
format!("failed to build {}", crate_dir.display()),
)
}
fn swift_generated_paths(generated_dir: &Path, crate_name: &str) -> [PathBuf; 3] {
[
generated_dir.join(format!("{crate_name}.swift")),
generated_dir.join(format!("{crate_name}FFI.h")),
generated_dir.join(format!("{crate_name}FFI.modulemap")),
]
}
fn remove_path(path: &Path) -> Result<(), DynError> {
match fs::remove_file(path) {
Ok(()) => {}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => {
return Err(format!("failed to remove {}: {error}", path.display()).into());
}
}
Ok(())
}
fn remove_paths(paths: &[PathBuf]) -> Result<(), DynError> {
for path in paths {
remove_path(path)?;
}
Ok(())
}
fn generate_bindings(
language: TargetLanguage,
out_dir: &Path,
uniffi_crate: &UniffiCrate<'_>,
) -> Result<(), DynError> {
let source = target_dir()?.join("debug").join(format!(
"{}{}{}",
env::consts::DLL_PREFIX,
uniffi_crate.crate_name,
env::consts::DLL_SUFFIX
));
let source = utf8_path(&source)?;
let out_dir = utf8_path(out_dir)?;
let previous_dir = env::current_dir().map_err(|error| {
format!(
"failed to capture current directory before generating {} bindings: {error}",
uniffi_crate.crate_name
)
})?;
env::set_current_dir(&uniffi_crate.crate_dir).map_err(|error| {
format!(
"failed to enter {} before generating bindings: {error}",
uniffi_crate.crate_dir.display()
)
})?;
let result = bindings::generate(GenerateOptions {
languages: vec![language],
source,
out_dir,
config_override: None,
format: false,
crate_filter: Some(uniffi_crate.crate_name.to_owned()),
metadata_no_deps: false,
});
env::set_current_dir(&previous_dir).map_err(|error| {
format!(
"failed to restore current directory to {}: {error}",
previous_dir.display()
)
})?;
result?;
Ok(())
}
fn sanitize_generated_swift_bindings(swift_file: &Path, crate_name: &str) -> Result<(), DynError> {
let original = fs::read_to_string(swift_file)
.map_err(|error| format!("failed to read {}: {error}", swift_file.display()))?;
let free_call_prefix = format!("try! rustCall {{ uniffi_{crate_name}_fn_free_");
let mut rewritten = String::from("// swift-format-ignore-file\n");
for segment in original.split_inclusive('\n') {
let line = segment.strip_suffix('\n').unwrap_or(segment);
let trimmed = line.trim_start();
if trimmed.starts_with(&free_call_prefix) && trimmed.ends_with("(handle, $0) }") {
let indent = &line[..line.len() - trimmed.len()];
rewritten.push_str(indent);
rewritten.push_str("// Avoid aborting the host app if Rust-side teardown fails during process shutdown.\n");
rewritten.push_str(indent);
rewritten.push_str(&line.replacen("try!", "try?", 1));
if segment.ends_with('\n') {
rewritten.push('\n');
}
} else {
rewritten.push_str(segment);
}
}
fs::write(swift_file, rewritten)
.map_err(|error| format!("failed to write {}: {error}", swift_file.display()))?;
Ok(())
}
fn utf8_path(path: &Path) -> Result<Utf8PathBuf, DynError> {
Utf8PathBuf::from_path_buf(path.to_path_buf())
.map_err(|path| format!("path is not valid UTF-8: {}", path.display()).into())
}
fn run_command(command: &mut Command, error_context: String) -> Result<(), DynError> {
let program = command.get_program().to_os_string();
let args = command
.get_args()
.map(OsStr::to_os_string)
.collect::<Vec<_>>();
let status = command.status().map_err(|error| {
format!(
"{error_context}: failed to start {}: {error}",
render_command(&program, &args)
)
})?;
if status.success() {
return Ok(());
}
Err(format!(
"{error_context}: {} exited with status {status}",
render_command(&program, &args)
)
.into())
}
fn render_command(program: &OsStr, args: &[std::ffi::OsString]) -> String {
let mut parts = Vec::with_capacity(args.len() + 1);
parts.push(program.to_string_lossy().into_owned());
parts.extend(args.iter().map(|arg| arg.to_string_lossy().into_owned()));
parts.join(" ")
}