git.delta.rocks / fleet / refs/commits / 3e7b063c34a7

1use std::{2	collections::{BTreeMap, BTreeSet, HashSet},3	io::{self, stdin, stdout, Read, Write},4	path::PathBuf,5};67use age::Recipient;8use anyhow::{anyhow, bail, ensure, Context, Result};9use chrono::{DateTime, Utc};10use clap::Parser;11use fleet_base::{12	fleetdata::{encrypt_secret_data, FleetSecret, FleetSecretPart, FleetSharedSecret},13	host::Config,14	opts::FleetOpts,15};16use fleet_shared::SecretData;17use nix_eval::{nix_go, nix_go_json, NixBuildBatch, Value};18use owo_colors::OwoColorize;19use serde::Deserialize;20use tabled::{Table, Tabled};21use tokio::fs::read;22use tracing::{error, info, info_span, warn, Instrument};2324#[derive(Parser)]25pub enum Secret {26	/// Force load host keys for all defined hosts27	ForceKeys,28	/// Add secret, data should be provided in stdin29	AddShared {30		/// Secret name31		name: String,32		/// Secret owners33		#[clap(long, short)]34		machines: Vec<String>,35		/// Override secret if already present36		#[clap(long)]37		force: bool,38		/// Secret public part39		#[clap(long)]40		public: Option<String>,41		/// Load public part from specified file42		#[clap(long)]43		public_file: Option<PathBuf>,4445		/// Create a notification on secret expiration46		#[clap(long)]47		expires_at: Option<DateTime<Utc>>,4849		/// Secret with this name already exists, override its value while keeping the same owners.50		#[clap(long)]51		re_add: bool,5253		/// How to name public secret part54		#[clap(long, short = 'p', default_value = "public")]55		public_part: String,56		/// How to name private secret part57		#[clap(short = 's', long, default_value = "secret")]58		part: String,59	},60	/// Add secret, data should be provided in stdin61	Add {62		/// Secret name63		name: String,64		/// Secret owner65		#[clap(short = 'm', long)]66		machine: String,67		/// Replace secret if already present68		#[clap(long)]69		replace: bool,70		/// Add new parts to existing secret71		#[clap(long)]72		merge: bool,73		/// Secret public part74		#[clap(long)]75		public: Option<String>,76		/// Load public part from specified file77		#[clap(long)]78		public_file: Option<PathBuf>,7980		/// How to name public secret part81		#[clap(short = 'p', long, default_value = "public")]82		public_part: String,83		/// How to name private secret part84		#[clap(short = 's', long, default_value = "secret")]85		part: String,86	},87	/// Read secret from remote host, requires sudo on said host88	Read {89		name: String,90		#[clap(short = 'm', long)]91		machine: String,9293		/// Which private secret part to read94		#[clap(short = 'p', long, default_value = "secret")]95		part: String,96	},97	UpdateShared {98		name: String,99100		#[clap(short = 'm', long)]101		machine: Option<Vec<String>>,102103		#[clap(long)]104		add_machine: Vec<String>,105		#[clap(long)]106		remove_machine: Vec<String>,107108		/// Which host should we use to decrypt109		#[clap(long)]110		prefer_identities: Vec<String>,111	},112	Regenerate {113		/// Which host should we use to decrypt, in case if reencryption is required, without114		/// regeneration115		#[clap(long)]116		prefer_identities: Vec<String>,117	},118	List {},119	Edit {120		name: String,121		#[clap(short = 'm', long)]122		machine: String,123124		#[clap(long)]125		add: bool,126127		/// Which private secret part to read128		#[clap(short = 'p', long, default_value = "secret")]129		part: String,130	},131}132133fn secret_needs_regeneration(134	secret: &FleetSecret,135	expected_generation_data: &serde_json::Value,136) -> bool {137	let data_is_expected = secret.generation_data == *expected_generation_data;138	// TODO: Leeway?139	let expired = secret140		.expires_at141		.map(|expiration| expiration < Utc::now())142		.unwrap_or(false);143	expired || !data_is_expected144}145146#[allow(clippy::too_many_arguments)]147#[tracing::instrument(skip(config, secret, field, prefer_identities, batch))]148async fn maybe_regenerate_shared_secret(149	secret_name: &str,150	config: &Config,151	mut secret: FleetSharedSecret,152	field: Value,153	expected_owners: &[String],154	expected_generation_data: serde_json::Value,155	prefer_identities: &[String],156	batch: Option<NixBuildBatch>,157) -> Result<FleetSharedSecret> {158	let original_set = secret.owners.clone();159160	let set = original_set.iter().collect::<BTreeSet<_>>();161	let expected_set = expected_owners.iter().collect::<BTreeSet<_>>();162163	let regeneration_required =164		secret_needs_regeneration(&secret.secret, &expected_generation_data);165166	if set == expected_set && !regeneration_required {167		info!("no need to update owner list, it is already correct");168		return Ok(secret);169	}170171	let should_regenerate = if regeneration_required {172		info!("secret has its generation data changed, regeneration is required");173		true174	} else if set.difference(&expected_set).next().is_some() {175		// TODO: Remove this warning for revokable secrets.176		warn!("host was removed from secret owners, but until this host rebuild, the secret will still be stored on it.");177		nix_go_json!(field.regenerateOnOwnerRemoved)178	} else if expected_set.difference(&set).next().is_some() {179		nix_go_json!(field.regenerateOnOwnerAdded)180	} else {181		false182	};183184	if should_regenerate {185		info!("secret needs to be regenerated");186		let generated = generate_shared(187			config,188			secret_name,189			field,190			expected_owners.to_vec(),191			expected_generation_data,192			batch,193		)194		.await?;195		Ok(generated)196	} else {197		drop(batch);198		let identity_holder = if !prefer_identities.is_empty() {199			prefer_identities200				.iter()201				.find(|i| original_set.iter().any(|s| s == *i))202		} else {203			secret.owners.first()204		};205		let Some(identity_holder) = identity_holder else {206			bail!("no available holder found");207		};208209		for (part_name, part) in secret.secret.parts.iter_mut() {210			let _span = info_span!("part reencryption", part_name);211			if !part.raw.encrypted {212				continue;213			}214			let host = config.host(identity_holder).await?;215			let encrypted = host216				.reencrypt(part.raw.clone(), expected_owners.to_vec())217				.await?;218			part.raw = encrypted;219		}220221		secret.owners = expected_owners.to_vec();222		Ok(secret)223	}224}225226#[derive(Deserialize)]227#[serde(rename_all = "camelCase")]228enum GeneratorKind {229	Impure,230	Pure,231}232233async fn generate_pure(234	_config: &Config,235	_display_name: &str,236	_secret: Value,237	_default_generator: Value,238	_owners: &[String],239) -> Result<FleetSecret> {240	bail!("pure generators are broken for now")241}242async fn generate_impure(243	config: &Config,244	_display_name: &str,245	secret: Value,246	default_generator: Value,247	expected_owners: &[String],248	expected_generation_data: serde_json::Value,249	batch: Option<NixBuildBatch>,250) -> Result<FleetSecret> {251	let generator = nix_go!(secret.generator);252	let on: Option<String> = nix_go_json!(default_generator.impureOn);253254	let host = if let Some(on) = &on {255		config.host(on).await?256	} else {257		config.local_host()258	};259	let on_pkgs = host.pkgs().await?;260	let call_package = nix_go!(on_pkgs.callPackage);261	let mk_secret_generators = nix_go!(on_pkgs.mkSecretGenerators);262263	let mut recipients = Vec::new();264	for owner in expected_owners {265		let key = config.key(owner).await?;266		recipients.push(key);267	}268	let generators = nix_go!(mk_secret_generators(Obj { recipients }));269270	let generator = nix_go!(call_package(generator)(generators));271272	let generator = generator.build_maybe_batch(batch).await?;273	let generator = generator274		.get("out")275		.ok_or_else(|| anyhow!("missing generateImpure out"))?;276	let generator = host.remote_derivation(generator).await?;277278	let out_parent = host.mktemp_dir().await?;279	let out = format!("{out_parent}/out");280281	let mut gen = host.cmd(generator).await?;282	gen.env("out", &out);283	if on.is_none() {284		// This path is local, thus we can feed `OsString` directly to env var... But I don't think that's necessary to handle.285		let project_path: String = config286			.directory287			.clone()288			.into_os_string()289			.into_string()290			.map_err(|s| anyhow!("fleet project path is not utf-8: {s:?}"))?;291		gen.env("FLEET_PROJECT", project_path);292	}293	gen.run().await.context("impure generator")?;294295	{296		let marker = host.read_file_text(format!("{out}/marker")).await?;297		ensure!(marker == "SUCCESS", "generation not succeeded");298	}299300	let mut parts = BTreeMap::new();301	for part in host.read_dir(&out).await? {302		if part == "created_at" || part == "expired_at" || part == "marker" {303			continue;304		}305		let contents: SecretData = host306			.read_file_text(format!("{out}/{part}"))307			.await?308			.parse()309			.map_err(|e| anyhow!("failed to decode secret {out:?} part {part:?}: {e}"))?;310		parts.insert(part.to_owned(), FleetSecretPart { raw: contents });311	}312313	let created_at = host.read_file_value(format!("{out}/created_at")).await?;314	let expires_at = host.read_file_value(format!("{out}/expires_at")).await.ok();315316	Ok(FleetSecret {317		created_at,318		expires_at,319		parts,320		generation_data: expected_generation_data,321	})322}323async fn generate(324	config: &Config,325	display_name: &str,326	secret: Value,327	expected_owners: &[String],328	expected_generation_data: serde_json::Value,329	batch: Option<NixBuildBatch>,330) -> Result<FleetSecret> {331	let generator = nix_go!(secret.generator);332	// Can't properly check on nix module system level333	{334		let gen_ty = generator.type_of().await?;335		if gen_ty == "null" {336			bail!("secret has no generator defined, can't automatically generate it.");337		}338		if gen_ty != "lambda" {339			bail!("generator should be lambda, got {gen_ty}");340		}341	}342	let default_pkgs = &config.default_pkgs;343	let default_call_package = nix_go!(default_pkgs.callPackage);344	let default_mk_secret_generators = nix_go!(default_pkgs.mkSecretGenerators);345	// Generators provide additional information in passthru, to access346	// passthru we should call generator, but information about where this generator is supposed to build347	// is located in passthru... Thus evaluating generator on host.348	//349	// Maybe it is also possible to do some magic with __functor?350	//351	// I don't want to make modules always responsible for additional secret data anyway,352	// so it should be in derivation, and not in the secret data itself.353	let generators = nix_go!(default_mk_secret_generators(Obj {354		recipients: <Vec<String>>::new(),355	}));356	let default_generator = nix_go!(default_call_package(generator)(generators));357358	let kind: GeneratorKind = nix_go_json!(default_generator.generatorKind);359360	match kind {361		GeneratorKind::Impure => {362			generate_impure(363				config,364				display_name,365				secret,366				default_generator,367				expected_owners,368				expected_generation_data,369				batch,370			)371			.await372		}373		GeneratorKind::Pure => {374			generate_pure(375				config,376				display_name,377				secret,378				default_generator,379				expected_owners,380			)381			.await382		}383	}384}385async fn generate_shared(386	config: &Config,387	display_name: &str,388	secret: Value,389	expected_owners: Vec<String>,390	expected_generation_data: serde_json::Value,391	batch: Option<NixBuildBatch>,392) -> Result<FleetSharedSecret> {393	// let owners: Vec<String> = nix_go_json!(secret.expectedOwners);394	Ok(FleetSharedSecret {395		secret: generate(396			config,397			display_name,398			secret,399			&expected_owners,400			expected_generation_data,401			batch,402		)403		.await?,404		owners: expected_owners,405	})406}407408async fn parse_public(409	public: Option<String>,410	public_file: Option<PathBuf>,411) -> Result<Option<SecretData>> {412	Ok(match (public, public_file) {413		(Some(v), None) => Some(SecretData {414			data: v.into(),415			encrypted: false,416		}),417		(None, Some(v)) => Some(SecretData {418			data: read(v).await?,419			encrypted: false,420		}),421		(Some(_), Some(_)) => {422			bail!("only public or public_file should be set")423		}424		(None, None) => None,425	})426}427428async fn parse_secret() -> Result<Option<Vec<u8>>> {429	let mut input = vec![];430	stdin().read_to_end(&mut input)?;431	if input.is_empty() {432		Ok(None)433	} else {434		Ok(Some(input))435	}436}437438fn parse_machines(439	initial: Vec<String>,440	machines: Option<Vec<String>>,441	mut add_machines: Vec<String>,442	mut remove_machines: Vec<String>,443) -> Result<Vec<String>> {444	if machines.is_none() && add_machines.is_empty() && remove_machines.is_empty() {445		bail!("no operation");446	}447448	let initial_machines = initial.clone();449	let mut target_machines = initial;450	info!("Currently encrypted for {initial_machines:?}");451452	// ensure!(machines.is_some() || !add_machines.is_empty() || )453	if let Some(machines) = machines {454		ensure!(455			add_machines.is_empty() && remove_machines.is_empty(),456			"can't combine --machines and --add-machines/--remove-machines"457		);458		let target = initial_machines.iter().collect::<HashSet<_>>();459		let source = machines.iter().collect::<HashSet<_>>();460		for removed in target.difference(&source) {461			remove_machines.push((*removed).clone());462		}463		for added in source.difference(&target) {464			add_machines.push((*added).clone());465		}466	}467468	for machine in &remove_machines {469		let mut removed = false;470		while let Some(pos) = target_machines.iter().position(|m| m == machine) {471			target_machines.swap_remove(pos);472			removed = true;473		}474		if !removed {475			warn!("secret is not enabled for {machine}");476		}477	}478	for machine in &add_machines {479		if target_machines.iter().any(|m| m == machine) {480			warn!("secret is already added to {machine}");481		} else {482			target_machines.push(machine.to_owned());483		}484	}485	if !remove_machines.is_empty() {486		// TODO: maybe force secret regeneration?487		// Not that useful without revokation.488		warn!("secret will not be regenerated for removed machines, and until host rebuild, they will still possess the ability to decode secret");489	}490	Ok(target_machines)491}492impl Secret {493	pub async fn run(self, config: &Config, opts: &FleetOpts) -> Result<()> {494		match self {495			Secret::ForceKeys => {496				for host in config.list_hosts().await? {497					if opts.should_skip(&host).await? {498						continue;499					}500					config.key(&host.name).await?;501				}502			}503			Secret::AddShared {504				mut machines,505				name,506				force,507				public,508				public_part: public_name,509				public_file,510				expires_at,511				re_add,512				part: part_name,513			} => {514				// TODO: Forbid updating secrets with set expectedOwners (= not user-managed).515516				let exists = config.has_shared(&name);517				if exists && !force && !re_add {518					bail!("secret already defined");519				}520				if re_add {521					// Fixme: use clap to limit this usage522					ensure!(!force, "--force and --readd are not compatible");523					ensure!(exists, "secret doesn't exists");524					ensure!(525						machines.is_empty(),526						"you can't use machines argument for --readd"527					);528					let shared = config.shared_secret(&name)?;529					machines = shared.owners;530				}531532				let recipients = config.recipients(machines.clone()).await?;533534				let mut parts = BTreeMap::new();535536				let mut input = vec![];537				io::stdin().read_to_end(&mut input)?;538539				if !input.is_empty() {540					let encrypted =541						encrypt_secret_data(recipients.iter().map(|r| r as &dyn Recipient), input)542							.ok_or_else(|| anyhow!("no recipients provided"))?;543					parts.insert(part_name, FleetSecretPart { raw: encrypted });544				}545546				if let Some(public) = parse_public(public, public_file).await? {547					parts.insert(public_name, FleetSecretPart { raw: public });548				}549550				config.replace_shared(551					name,552					FleetSharedSecret {553						owners: machines,554						secret: FleetSecret {555							created_at: Utc::now(),556							expires_at,557							parts,558							generation_data: serde_json::Value::Null,559						},560					},561				);562			}563			Secret::Add {564				machine,565				name,566				replace,567				merge,568				public,569				public_part: public_name,570				public_file,571				part: part_name,572			} => {573				if config.has_secret(&machine, &name) && !replace && !merge {574					bail!("secret already defined.\nUse --replace to override, or --merge to add new parts to existing secret");575				}576577				let mut out = if merge && !replace {578					config579						.host_secret(&machine, &name)580						.context("failed to read existing secret for --merge")?581				} else {582					FleetSecret {583						created_at: Utc::now(),584						expires_at: None,585						parts: BTreeMap::new(),586						generation_data: serde_json::Value::Null,587					}588				};589590				if let Some(secret) = parse_secret().await? {591					let recipient = config.recipient(&machine).await?;592					let encrypted = encrypt_secret_data([&recipient as &dyn Recipient], secret)593						.expect("recipient provided");594					if out595						.parts596						.insert(part_name.clone(), FleetSecretPart { raw: encrypted })597						.is_some() && !replace598					{599						bail!("part {part_name:?} is already defined");600					}601				}602603				if let Some(public) = parse_public(public, public_file).await? {604					if out605						.parts606						.insert(public_name.clone(), FleetSecretPart { raw: public })607						.is_some() && !replace608					{609						bail!("part {public_name:?} is already defined");610					}611				};612613				config.insert_secret(&machine, name, out);614			}615			#[allow(clippy::await_holding_refcell_ref)]616			Secret::Read {617				name,618				machine,619				part: part_name,620			} => {621				let secret = config.host_secret(&machine, &name)?;622				let Some(secret) = secret.parts.get(&part_name) else {623					bail!("no part {part_name} in secret {name}");624				};625				let data = if secret.raw.encrypted {626					let host = config.host(&machine).await?;627					host.decrypt(secret.raw.clone()).await?628				} else {629					secret.raw.data.clone()630				};631632				stdout().write_all(&data)?;633			}634			Secret::UpdateShared {635				name,636				machine,637				add_machine,638				remove_machine,639				prefer_identities,640			} => {641				// TODO: Forbid updating secrets with set expectedOwners (= not user-managed).642643				let secret = config.shared_secret(&name)?;644				if secret.secret.parts.values().all(|v| !v.raw.encrypted) {645					bail!("no secret");646				}647648				let initial_machines = secret.owners.clone();649				let target_machines = parse_machines(650					initial_machines.clone(),651					machine,652					add_machine,653					remove_machine,654				)?;655656				if target_machines.is_empty() {657					info!("no machines left for secret, removing it");658					config.remove_shared(&name);659					return Ok(());660				}661662				let config_field = &config.config_field;663				let field = nix_go!(config_field.sharedSecrets[{ name }]);664				let expected_generation_data = nix_go_json!(field.expectedGenerationData);665666				let updated = maybe_regenerate_shared_secret(667					&name,668					config,669					secret,670					field,671					&target_machines,672					expected_generation_data,673					&prefer_identities,674					None,675				)676				.await?;677				config.replace_shared(name, updated);678			}679			Secret::Regenerate { prefer_identities } => {680				info!("checking for secrets to regenerate");681				let stored_shared_set = config.list_shared().into_iter().collect::<HashSet<_>>();682				{683					// Generate missing shared684					let shared_batch = None;685					let _span = info_span!("shared").entered();686					let expected_shared_set = config687						.list_configured_shared()688						.await?689						.into_iter()690						.collect::<HashSet<_>>();691					for missing in expected_shared_set.difference(&stored_shared_set) {692						let config_field = &config.config_field;693						let secret = nix_go!(config_field.sharedSecrets[{ missing }]);694						let expected_generation_data: serde_json::Value =695							nix_go_json!(secret.expectedGenerationData);696						let expected_owners: Option<Vec<String>> =697							nix_go_json!(secret.expectedOwners);698						let Some(expected_owners) = expected_owners else {699							// Can't generate this missing secret, as it has no defined owners.700							continue;701						};702						info!("generating secret: {missing}");703						let shared = generate_shared(704							config,705							missing,706							secret,707							expected_owners,708							expected_generation_data,709							shared_batch.clone(),710						)711						.in_current_span()712						.await?;713						config.replace_shared(missing.to_string(), shared)714					}715				}716				let hosts_batch = None;717				for host in config.list_hosts().await? {718					if opts.should_skip(&host).await? {719						continue;720					}721722					let _span = info_span!("host", host = host.name).entered();723					let expected_set = host724						.list_configured_secrets()725						.in_current_span()726						.await?727						.into_iter()728						.collect::<HashSet<_>>();729					let stored_set = config730						.list_secrets(&host.name)731						.into_iter()732						.collect::<HashSet<_>>();733					for missing in expected_set.difference(&stored_set) {734						info!("generating secret: {missing}");735						let secret = host.secret_field(missing).in_current_span().await?;736						let expected_generation_data = nix_go_json!(secret.expectedGenerationData);737						let generated = match generate(738							config,739							missing,740							secret,741							&[host.name.clone()],742							expected_generation_data,743							hosts_batch.clone(),744						)745						.in_current_span()746						.await747						{748							Ok(v) => v,749							Err(e) => {750								error!("{e:?}");751								continue;752							}753						};754						config.insert_secret(&host.name, missing.to_string(), generated)755					}756					for name in stored_set {757						info!("updating secret: {name}");758						let data = config.host_secret(&host.name, &name)?;759						let secret = host.secret_field(&name).in_current_span().await?;760						let expected_generation_data = nix_go_json!(secret.expectedGenerationData);761						if secret_needs_regeneration(&data, &expected_generation_data) {762							let generated = match generate(763								config,764								&name,765								secret,766								&[host.name.clone()],767								expected_generation_data,768								hosts_batch.clone(),769							)770							.in_current_span()771							.await772							{773								Ok(v) => v,774								Err(e) => {775									error!("{e:?}");776									continue;777								}778							};779							config.insert_secret(&host.name, name.to_string(), generated)780						}781					}782				}783				let mut to_remove = Vec::new();784				for name in &stored_shared_set {785					info!("updating secret: {name}");786					let data = config.shared_secret(name)?;787					let config_field = &config.config_field;788					let expected_owners: Vec<String> =789						nix_go_json!(config_field.sharedSecrets[{ name }].expectedOwners);790					if expected_owners.is_empty() {791						warn!("secret was removed from fleet config: {name}, removing from data");792						to_remove.push(name.to_string());793						continue;794					}795796					let secret = nix_go!(config_field.sharedSecrets[{ name }]);797					let expected_generation_data = nix_go_json!(secret.expectedGenerationData);798					config.replace_shared(799						name.to_owned(),800						maybe_regenerate_shared_secret(801							name,802							config,803							data,804							secret,805							&expected_owners,806							expected_generation_data,807							&prefer_identities,808							None,809						)810						.await?,811					);812				}813				for k in to_remove {814					config.remove_shared(&k);815				}816			}817			Secret::List {} => {818				let _span = info_span!("loading secrets").entered();819				let configured = config.list_configured_shared().await?;820				#[derive(Tabled)]821				struct SecretDisplay {822					#[tabled(rename = "Name")]823					name: String,824					#[tabled(rename = "Owners")]825					owners: String,826				}827				let mut table = vec![];828				for name in configured.iter().cloned() {829					let config = config.clone();830					let expected_owners = config.shared_secret_expected_owners(&name).await?;831					let data = config.shared_secret(&name)?;832					let owners = data833						.owners834						.iter()835						.map(|o| {836							if expected_owners.contains(o) {837								o.green().to_string()838							} else {839								o.red().to_string()840							}841						})842						.collect::<Vec<_>>();843					table.push(SecretDisplay {844						owners: owners.join(", "),845						name,846					})847				}848				info!("loaded\n{}", Table::new(table).to_string())849			}850			Secret::Edit {851				name,852				machine,853				part,854				add,855			} => {856				let secret = config.host_secret(&machine, &name)?;857				if let Some(data) = secret.parts.get(&part) {858					let host = config.host(&machine).await?;859					let secret = host.decrypt(data.raw.clone()).await?;860					String::from_utf8(secret).context("secret is not utf8")?861				} else if add {862					String::new()863				} else {864					bail!("part {part} not found in secret {name}. Did you mean to `--add` it?");865				};866			}867		}868		Ok(())869	}870}871872/*873async fn edit_temp_file(874	builder: tempfile::Builder<'_, '_>,875	r: Vec<u8>,876	header: &str,877	comment: &str,878) -> Result<(Vec<u8>, Option<String>), anyhow::Error> {879	if !stdin().is_tty() {880		// TODO: Also try to open /dev/tty directly?881		bail!("stdin is not tty, can't open editor");882	}883884	use std::fmt::Write;885	let mut file = builder.tempfile()?;886887	let mut full_header = String::new();888	let mut had = false;889	for line in header.trim_end().lines() {890		had = true;891		writeln!(&mut full_header, "{comment}{line}")?;892	}893	if had {894		writeln!(&mut full_header, "{}", comment.trim_end())?;895	}896	writeln!(897		&mut full_header,898		"{comment}Do not touch this header! It will be removed automatically"899	)?;900901	file.write_all(full_header.as_bytes())?;902	file.write_all(&r)?;903904	let abs_path = file.into_temp_path();905	let editor = std::env::var_os("VISUAL")906		.or_else(|| std::env::var_os("EDITOR"))907		.unwrap_or_else(|| "vi".into());908	let editor_args = shlex::bytes::split(editor.as_encoded_bytes())909		.ok_or_else(|| anyhow!("EDITOR env var has wrong syntax"))?;910	let editor_args = editor_args911		.into_iter()912		.map(|v| {913			// Only ASCII subsequences are replaced914			unsafe { OsString::from_encoded_bytes_unchecked(v) }915		})916		.collect_vec();917	let Some((editor, args)) = editor_args.split_first() else {918		bail!("EDITOR env var has no command");919	};920	let mut command = Command::new(editor);921	command.args(args);922923	let path_arg = abs_path.canonicalize()?;924925	// TODO: Save full state, using tcget/_getmode/_setmode926	let was_raw = terminal::is_raw_mode_enabled()?;927	terminal::enable_raw_mode()?;928929	let status = command.arg(path_arg).status().await;930931	if !was_raw {932		terminal::disable_raw_mode()?;933	}934935	let success = match status {936		Ok(s) => s.success(),937		Err(e) if e.kind() == io::ErrorKind::NotFound => {938			bail!("editor not found")939		}940		Err(e) => bail!("editor spawn error: {e}"),941	};942943	let mut file = std::fs::read(&abs_path).context("read editor output")?;944	let Some(v) = file.strip_prefix(full_header.as_bytes()) else {945		todo!();946	};947	todo!();948949	// Ok((success, abs_path))950}951*/