@narumitw/pi-sync 0.50.3 → 0.51.0

package/src/settings/settings-management.ts

@@ -3,262 +3,237 @@ import { normalizeSyncInclude } from "../sync/sync-policy.js";
 import { type SyncSetupStorageReview, syncSetupStorageReview } from "./config.js";
 import { localConfigPath } from "./config-file.js";
 import { updateLocalConfig } from "./settings-store.js";
-import type {
-	PiSyncSettingsV3,
-	StorageConnectionSettings,
-	SyncSetupSettings,
-} from "./settings-types.js";
+import type { PiSyncSettingsV3, StorageConnectionSettings, SyncSetupSettings } from "./settings-types.js";
 import { effectiveSyncSetupRemoteIdentity, validateConfigName } from "./settings-validation.js";
 
 export class SyncSetupReviewChangedError extends Error {
-	constructor(message: string) {
-		super(message);
-		this.name = "SyncSetupReviewChangedError";
-	}
+  constructor(message: string) {
+    super(message);
+    this.name = "SyncSetupReviewChangedError";
+  }
 }
 
 export async function saveNewV3Settings(
-	input: {
-		setupName: string;
-		connectionName: string;
-		connection: StorageConnectionSettings;
-		setup: SyncSetupSettings;
-	},
-	signal?: AbortSignal,
+  input: {
+    setupName: string;
+    connectionName: string;
+    connection: StorageConnectionSettings;
+    setup: SyncSetupSettings;
+  },
+  signal?: AbortSignal,
 ) {
-	validateConfigName(input.setupName, "sync setup");
-	validateConfigName(input.connectionName, "storage connection");
-	const settings: PiSyncSettingsV3 = {
-		version: 3,
-		activeSyncSetup: input.setupName,
-		onSwitch: "ask-before-pull",
-		skipSecretScan: false,
-		storageConnections: { [input.connectionName]: structuredClone(input.connection) },
-		syncSetups: {
-			[input.setupName]: {
-				...structuredClone(input.setup),
-				storage: { ...input.setup.storage, connection: input.connectionName },
-			},
-		},
-	};
-	return updateLocalConfig((current) => {
-		if (Object.keys(current.storageConnections).length || Object.keys(current.syncSetups).length) {
-			throw new Error(`Settings already exist: ${localConfigPath()}`);
-		}
-		return { ...current, ...settings };
-	}, signal);
+  validateConfigName(input.setupName, "sync setup");
+  validateConfigName(input.connectionName, "storage connection");
+  const settings: PiSyncSettingsV3 = {
+    version: 3,
+    activeSyncSetup: input.setupName,
+    onSwitch: "ask-before-pull",
+    skipSecretScan: false,
+    storageConnections: { [input.connectionName]: structuredClone(input.connection) },
+    syncSetups: {
+      [input.setupName]: {
+        ...structuredClone(input.setup),
+        storage: { ...input.setup.storage, connection: input.connectionName },
+      },
+    },
+  };
+  return updateLocalConfig((current) => {
+    if (Object.keys(current.storageConnections).length || Object.keys(current.syncSetups).length) {
+      throw new Error(`Settings already exist: ${localConfigPath()}`);
+    }
+    return { ...current, ...settings };
+  }, signal);
 }
 
-export async function addStorageConnection(
-	name: string,
-	connection: StorageConnectionSettings,
-	signal?: AbortSignal,
-) {
-	validateConfigName(name, "storage connection");
-	await updateSettings((settings) => {
-		if (Object.hasOwn(settings.storageConnections, name)) {
-			throw new Error(`Storage connection already exists: ${name}`);
-		}
-		return {
-			...settings,
-			storageConnections: {
-				...settings.storageConnections,
-				[name]: structuredClone(connection),
-			},
-		};
-	}, signal);
+export async function addStorageConnection(name: string, connection: StorageConnectionSettings, signal?: AbortSignal) {
+  validateConfigName(name, "storage connection");
+  await updateSettings((settings) => {
+    if (Object.hasOwn(settings.storageConnections, name)) {
+      throw new Error(`Storage connection already exists: ${name}`);
+    }
+    return {
+      ...settings,
+      storageConnections: {
+        ...settings.storageConnections,
+        [name]: structuredClone(connection),
+      },
+    };
+  }, signal);
 }
 
 export async function updateStorageConnection(
-	name: string,
-	update: (connection: StorageConnectionSettings) => StorageConnectionSettings,
-	expectedSetups?: readonly string[],
-	signal?: AbortSignal,
+  name: string,
+  update: (connection: StorageConnectionSettings) => StorageConnectionSettings,
+  expectedSetups?: readonly string[],
+  signal?: AbortSignal,
 ) {
-	validateConfigName(name, "storage connection");
-	await updateSettings((settings) => {
-		const connection = settings.storageConnections[name];
-		if (!connection) throw new Error(`Storage connection not found: ${name}`);
-		const currentSetups = referencingSetupNames(settings.syncSetups, name);
-		if (expectedSetups && !sameNames(currentSetups, expectedSetups)) {
-			throw new Error(
-				`Storage connection “${name}” usage changed while it was open; reopen it and review the affected sync setups.`,
-			);
-		}
-		const nextConnection = update(structuredClone(connection));
-		const nextConnections = { ...settings.storageConnections, [name]: nextConnection };
-		assertUniqueLocations(settings.syncSetups, nextConnections);
-		return { ...settings, storageConnections: nextConnections };
-	}, signal);
+  validateConfigName(name, "storage connection");
+  await updateSettings((settings) => {
+    const connection = settings.storageConnections[name];
+    if (!connection) throw new Error(`Storage connection not found: ${name}`);
+    const currentSetups = referencingSetupNames(settings.syncSetups, name);
+    if (expectedSetups && !sameNames(currentSetups, expectedSetups)) {
+      throw new Error(
+        `Storage connection “${name}” usage changed while it was open; reopen it and review the affected sync setups.`,
+      );
+    }
+    const nextConnection = update(structuredClone(connection));
+    const nextConnections = { ...settings.storageConnections, [name]: nextConnection };
+    assertUniqueLocations(settings.syncSetups, nextConnections);
+    return { ...settings, storageConnections: nextConnections };
+  }, signal);
 }
 
 export async function addSyncSetup(
-	name: string,
-	setup: SyncSetupSettings,
-	signal?: AbortSignal,
-	expectedConnection?: StorageConnectionSettings,
+  name: string,
+  setup: SyncSetupSettings,
+  signal?: AbortSignal,
+  expectedConnection?: StorageConnectionSettings,
 ) {
-	validateConfigName(name, "sync setup");
-	await updateSettings((settings) => {
-		if (Object.hasOwn(settings.syncSetups, name))
-			throw new Error(`Sync setup already exists: ${name}`);
-		if (!Object.hasOwn(settings.storageConnections, setup.storage.connection)) {
-			throw new Error(`Storage connection not found: ${setup.storage.connection}`);
-		}
-		if (
-			expectedConnection &&
-			!isDeepStrictEqual(settings.storageConnections[setup.storage.connection], expectedConnection)
-		) {
-			throw new SyncSetupReviewChangedError(
-				"Storage connection changed while the setup review was open; reopen it.",
-			);
-		}
-		const nextSetups = { ...settings.syncSetups, [name]: structuredClone(setup) };
-		assertUniqueLocations(nextSetups, settings.storageConnections);
-		return {
-			...settings,
-			syncSetups: nextSetups,
-			...(settings.activeSyncSetup ? {} : { activeSyncSetup: name }),
-		};
-	}, signal);
+  validateConfigName(name, "sync setup");
+  await updateSettings((settings) => {
+    if (Object.hasOwn(settings.syncSetups, name)) throw new Error(`Sync setup already exists: ${name}`);
+    if (!Object.hasOwn(settings.storageConnections, setup.storage.connection)) {
+      throw new Error(`Storage connection not found: ${setup.storage.connection}`);
+    }
+    if (
+      expectedConnection &&
+      !isDeepStrictEqual(settings.storageConnections[setup.storage.connection], expectedConnection)
+    ) {
+      throw new SyncSetupReviewChangedError("Storage connection changed while the setup review was open; reopen it.");
+    }
+    const nextSetups = { ...settings.syncSetups, [name]: structuredClone(setup) };
+    assertUniqueLocations(nextSetups, settings.storageConnections);
+    return {
+      ...settings,
+      syncSetups: nextSetups,
+      ...(settings.activeSyncSetup ? {} : { activeSyncSetup: name }),
+    };
+  }, signal);
 }
 
 export async function updateSyncSetup(
-	name: string,
-	update: (setup: SyncSetupSettings) => SyncSetupSettings,
-	options: {
-		expectedStorage?: SyncSetupStorageReview;
-		expectedInclude?: readonly string[];
-		expectedConnection?: StorageConnectionSettings;
-		signal?: AbortSignal;
-	} = {},
+  name: string,
+  update: (setup: SyncSetupSettings) => SyncSetupSettings,
+  options: {
+    expectedStorage?: SyncSetupStorageReview;
+    expectedInclude?: readonly string[];
+    expectedConnection?: StorageConnectionSettings;
+    signal?: AbortSignal;
+  } = {},
 ) {
-	validateConfigName(name, "sync setup");
-	await updateSettings((settings) => {
-		const setup = settings.syncSetups[name];
-		if (!setup) throw new Error(`Sync setup not found: ${name}`);
-		if (
-			options.expectedInclude &&
-			!sameNames(normalizeSyncInclude(setup.sync.include), options.expectedInclude)
-		) {
-			throw new SyncSetupReviewChangedError(
-				`Sync setup “${name}” included content changed while it was open; reopen it and review the current selection.`,
-			);
-		}
-		if (options.expectedStorage) {
-			const connectionName = setup.storage.connection;
-			const connection = settings.storageConnections[connectionName];
-			if (
-				!connection ||
-				!sameStorageReview(
-					syncSetupStorageReview(name, setup, connectionName, connection),
-					options.expectedStorage,
-				)
-			) {
-				throw new SyncSetupReviewChangedError(
-					`Sync setup “${name}” storage changed while it was open; reopen it and review the current storage location.`,
-				);
-			}
-		}
-		if (
-			options.expectedConnection &&
-			!isDeepStrictEqual(
-				settings.storageConnections[setup.storage.connection],
-				options.expectedConnection,
-			)
-		) {
-			throw new SyncSetupReviewChangedError(
-				"Storage connection changed while the setup review was open; reopen it.",
-			);
-		}
-		const nextSetup = update(structuredClone(setup));
-		if (!Object.hasOwn(settings.storageConnections, nextSetup.storage.connection)) {
-			throw new Error(`Storage connection not found: ${nextSetup.storage.connection}`);
-		}
-		const nextSetups = { ...settings.syncSetups, [name]: nextSetup };
-		assertUniqueLocations(nextSetups, settings.storageConnections);
-		return { ...settings, syncSetups: nextSetups };
-	}, options.signal);
+  validateConfigName(name, "sync setup");
+  await updateSettings((settings) => {
+    const setup = settings.syncSetups[name];
+    if (!setup) throw new Error(`Sync setup not found: ${name}`);
+    if (options.expectedInclude && !sameNames(normalizeSyncInclude(setup.sync.include), options.expectedInclude)) {
+      throw new SyncSetupReviewChangedError(
+        `Sync setup “${name}” included content changed while it was open; reopen it and review the current selection.`,
+      );
+    }
+    if (options.expectedStorage) {
+      const connectionName = setup.storage.connection;
+      const connection = settings.storageConnections[connectionName];
+      if (
+        !connection ||
+        !sameStorageReview(syncSetupStorageReview(name, setup, connectionName, connection), options.expectedStorage)
+      ) {
+        throw new SyncSetupReviewChangedError(
+          `Sync setup “${name}” storage changed while it was open; reopen it and review the current storage location.`,
+        );
+      }
+    }
+    if (
+      options.expectedConnection &&
+      !isDeepStrictEqual(settings.storageConnections[setup.storage.connection], options.expectedConnection)
+    ) {
+      throw new SyncSetupReviewChangedError("Storage connection changed while the setup review was open; reopen it.");
+    }
+    const nextSetup = update(structuredClone(setup));
+    if (!Object.hasOwn(settings.storageConnections, nextSetup.storage.connection)) {
+      throw new Error(`Storage connection not found: ${nextSetup.storage.connection}`);
+    }
+    const nextSetups = { ...settings.syncSetups, [name]: nextSetup };
+    assertUniqueLocations(nextSetups, settings.storageConnections);
+    return { ...settings, syncSetups: nextSetups };
+  }, options.signal);
 }
 
 export async function removeSyncSetup(name: string, signal?: AbortSignal) {
-	validateConfigName(name, "sync setup");
-	await updateSettings((settings) => {
-		if (!Object.hasOwn(settings.syncSetups, name)) throw new Error(`Sync setup not found: ${name}`);
-		const isCurrent = settings.activeSyncSetup === name;
-		if (isCurrent && Object.keys(settings.syncSetups).length > 1) {
-			throw new Error("Switch to another sync setup before removing the current setup.");
-		}
-		const syncSetups = { ...settings.syncSetups };
-		delete syncSetups[name];
-		const next = { ...settings, syncSetups };
-		if (isCurrent) delete next.activeSyncSetup;
-		return next;
-	}, signal);
+  validateConfigName(name, "sync setup");
+  await updateSettings((settings) => {
+    if (!Object.hasOwn(settings.syncSetups, name)) throw new Error(`Sync setup not found: ${name}`);
+    const isCurrent = settings.activeSyncSetup === name;
+    if (isCurrent && Object.keys(settings.syncSetups).length > 1) {
+      throw new Error("Switch to another sync setup before removing the current setup.");
+    }
+    const syncSetups = { ...settings.syncSetups };
+    delete syncSetups[name];
+    const next = { ...settings, syncSetups };
+    if (isCurrent) delete next.activeSyncSetup;
+    return next;
+  }, signal);
 }
 
 export async function removeStorageConnection(name: string, signal?: AbortSignal) {
-	validateConfigName(name, "storage connection");
-	await updateSettings((settings) => {
-		const referenced = referencingSetupNames(settings.syncSetups, name)[0];
-		if (referenced) {
-			throw new Error(`Storage connection “${name}” is used by sync setup “${referenced}”.`);
-		}
-		if (!Object.hasOwn(settings.storageConnections, name)) {
-			throw new Error(`Storage connection not found: ${name}`);
-		}
-		const storageConnections = { ...settings.storageConnections };
-		delete storageConnections[name];
-		return { ...settings, storageConnections };
-	}, signal);
+  validateConfigName(name, "storage connection");
+  await updateSettings((settings) => {
+    const referenced = referencingSetupNames(settings.syncSetups, name)[0];
+    if (referenced) {
+      throw new Error(`Storage connection “${name}” is used by sync setup “${referenced}”.`);
+    }
+    if (!Object.hasOwn(settings.storageConnections, name)) {
+      throw new Error(`Storage connection not found: ${name}`);
+    }
+    const storageConnections = { ...settings.storageConnections };
+    delete storageConnections[name];
+    return { ...settings, storageConnections };
+  }, signal);
 }
 
-async function updateSettings(
-	update: (settings: PiSyncSettingsV3) => PiSyncSettingsV3,
-	signal?: AbortSignal,
-) {
-	return updateLocalConfig((settings) => {
-		if (settings.version !== 3) {
-			throw new Error("Storage connections and sync setups require version 3 pi-sync settings.");
-		}
-		return update(settings);
-	}, signal);
+async function updateSettings(update: (settings: PiSyncSettingsV3) => PiSyncSettingsV3, signal?: AbortSignal) {
+  return updateLocalConfig((settings) => {
+    if (settings.version !== 3) {
+      throw new Error("Storage connections and sync setups require version 3 pi-sync settings.");
+    }
+    return update(settings);
+  }, signal);
 }
 
 function referencingSetupNames(setups: Record<string, SyncSetupSettings>, connection: string) {
-	return Object.entries(setups)
-		.filter(([, setup]) => setup.storage.connection === connection)
-		.map(([name]) => name)
-		.sort((left, right) => left.localeCompare(right));
+  return Object.entries(setups)
+    .filter(([, setup]) => setup.storage.connection === connection)
+    .map(([name]) => name)
+    .sort((left, right) => left.localeCompare(right));
 }
 
 function assertUniqueLocations(
-	setups: Record<string, SyncSetupSettings>,
-	connections: Record<string, StorageConnectionSettings>,
+  setups: Record<string, SyncSetupSettings>,
+  connections: Record<string, StorageConnectionSettings>,
 ) {
-	const identities = new Map<string, string>();
-	for (const [name, setup] of Object.entries(setups)) {
-		const connection = connections[setup.storage.connection];
-		if (!connection) throw new Error(`Storage connection not found: ${setup.storage.connection}`);
-		const identity = effectiveSyncSetupRemoteIdentity(setup, connection);
-		const previous = identities.get(identity);
-		if (previous) {
-			throw new Error(`Sync setup “${name}” duplicates the storage location of “${previous}”.`);
-		}
-		identities.set(identity, name);
-	}
+  const identities = new Map<string, string>();
+  for (const [name, setup] of Object.entries(setups)) {
+    const connection = connections[setup.storage.connection];
+    if (!connection) throw new Error(`Storage connection not found: ${setup.storage.connection}`);
+    const identity = effectiveSyncSetupRemoteIdentity(setup, connection);
+    const previous = identities.get(identity);
+    if (previous) {
+      throw new Error(`Sync setup “${name}” duplicates the storage location of “${previous}”.`);
+    }
+    identities.set(identity, name);
+  }
 }
 
 function sameNames(left: readonly string[], right: readonly string[]) {
-	return left.length === right.length && left.every((name, index) => name === right[index]);
+  return left.length === right.length && left.every((name, index) => name === right[index]);
 }
 
 function sameStorageReview(left: SyncSetupStorageReview, right: SyncSetupStorageReview) {
-	return (
-		left.connectionName === right.connectionName &&
-		left.storageKind === right.storageKind &&
-		left.storagePath === right.storagePath &&
-		left.bucket === right.bucket &&
-		left.branch === right.branch
-	);
+  return (
+    left.connectionName === right.connectionName &&
+    left.storageKind === right.storageKind &&
+    left.storagePath === right.storagePath &&
+    left.bucket === right.bucket &&
+    left.branch === right.branch
+  );
 }

package/src/settings/settings-store.ts

@@ -1,109 +1,95 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
-import {
-	localConfigPath,
-	readMigratingLocalConfigDocument,
-	updateLocalConfigDocument,
-} from "./config-file.js";
+import { localConfigPath, readMigratingLocalConfigDocument, updateLocalConfigDocument } from "./config-file.js";
 import type { OnSwitchAction, PiSyncSettingsV3 } from "./settings-types.js";
 import { DEFAULT_ON_SWITCH, validateSettingsDocument } from "./settings-validation.js";
 
 let configUpdateQueue: Promise<void> = Promise.resolve();
 
 export async function requireSettings() {
-	const settings = await readLocalConfigObject();
-	if (!settings) {
-		throw new Error(
-			`Missing pi-sync settings. Open /sync and choose Set up sync, or create ${localConfigPath()}.`,
-		);
-	}
-	return settings;
+  const settings = await readLocalConfigObject();
+  if (!settings) {
+    throw new Error(`Missing pi-sync settings. Open /sync and choose Set up sync, or create ${localConfigPath()}.`);
+  }
+  return settings;
 }
 
 export async function configuredSyncSetupNames() {
-	const settings = await readLocalConfigObject();
-	return settings
-		? Object.keys(settings.syncSetups).sort((left, right) => left.localeCompare(right))
-		: [];
+  const settings = await readLocalConfigObject();
+  return settings ? Object.keys(settings.syncSetups).sort((left, right) => left.localeCompare(right)) : [];
 }
 
 export async function loadOnSwitch(): Promise<OnSwitchAction> {
-	return (await requireSettings()).onSwitch;
+  return (await requireSettings()).onSwitch;
 }
 
 export function localConfigTemplate(): PiSyncSettingsV3 {
-	return {
-		version: 3,
-		onSwitch: DEFAULT_ON_SWITCH,
-		skipSecretScan: false,
-		storageConnections: {},
-		syncSetups: {},
-	};
+  return {
+    version: 3,
+    onSwitch: DEFAULT_ON_SWITCH,
+    skipSecretScan: false,
+    showStatus: true,
+    storageConnections: {},
+    syncSetups: {},
+  };
 }
 
 export async function readLocalConfigDocument() {
-	const document = await readMigratingLocalConfigDocument((settings) => {
-		validateSettingsDocument(settings);
-	});
-	if (document) validateSettingsDocument(document.parsed);
-	return document;
+  const document = await readMigratingLocalConfigDocument((settings) => {
+    validateSettingsDocument(settings);
+  });
+  if (document) validateSettingsDocument(document.parsed);
+  return document;
 }
 
 export async function readLocalConfigObject(): Promise<PiSyncSettingsV3 | undefined> {
-	return (await readLocalConfigDocument())?.parsed as PiSyncSettingsV3 | undefined;
+  return (await readLocalConfigDocument())?.parsed as PiSyncSettingsV3 | undefined;
 }
 
-export function updateLocalConfig(
-	update: (current: PiSyncSettingsV3) => PiSyncSettingsV3,
-	signal?: AbortSignal,
-) {
-	const operation = configUpdateQueue.then(() => {
-		signal?.throwIfAborted();
-		return performLocalConfigUpdate(update, signal);
-	});
-	configUpdateQueue = operation.then(
-		() => undefined,
-		() => undefined,
-	);
-	return operation;
+export function updateLocalConfig(update: (current: PiSyncSettingsV3) => PiSyncSettingsV3, signal?: AbortSignal) {
+  const operation = configUpdateQueue.then(() => {
+    signal?.throwIfAborted();
+    return performLocalConfigUpdate(update, signal);
+  });
+  configUpdateQueue = operation.then(
+    () => undefined,
+    () => undefined,
+  );
+  return operation;
 }
 
-async function performLocalConfigUpdate(
-	update: (current: PiSyncSettingsV3) => PiSyncSettingsV3,
-	signal?: AbortSignal,
-) {
-	return updateLocalConfigDocument(localConfigTemplate(), update, validateSettingsDocument, signal);
+async function performLocalConfigUpdate(update: (current: PiSyncSettingsV3) => PiSyncSettingsV3, signal?: AbortSignal) {
+  return updateLocalConfigDocument(localConfigTemplate(), update, validateSettingsDocument, signal);
 }
 
 export async function writeLocalConfigObject(value: PiSyncSettingsV3 | Record<string, unknown>) {
-	validateSettingsDocument(value as Record<string, unknown>);
-	const configPath = localConfigPath();
-	await fs.mkdir(path.dirname(configPath), { recursive: true });
-	try {
-		const stat = await fs.lstat(configPath);
-		if (stat.isSymbolicLink())
-			throw new Error(`Refusing to overwrite symlinked pi-sync settings: ${configPath}`);
-		if (!stat.isFile()) throw new Error(`pi-sync settings are not a regular file: ${configPath}`);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
-	}
-	const temporaryPath = path.join(
-		path.dirname(configPath),
-		`.${path.basename(configPath)}.${process.pid}.${randomUUID()}.tmp`,
-	);
-	let handle: fs.FileHandle | undefined;
-	try {
-		handle = await fs.open(temporaryPath, "wx", 0o600);
-		await handle.writeFile(`${JSON.stringify(value, null, "\t")}\n`, "utf8");
-		if (process.platform !== "win32") await handle.chmod(0o600);
-		await handle.sync();
-		await handle.close();
-		handle = undefined;
-		await fs.rename(temporaryPath, configPath);
-	} catch (error) {
-		await handle?.close().catch(() => undefined);
-		await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
-		throw error;
-	}
+  validateSettingsDocument(value as Record<string, unknown>);
+  const configPath = localConfigPath();
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  try {
+    const stat = await fs.lstat(configPath);
+    if (stat.isSymbolicLink()) throw new Error(`Refusing to overwrite symlinked pi-sync settings: ${configPath}`);
+    if (!stat.isFile()) throw new Error(`pi-sync settings are not a regular file: ${configPath}`);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+  const temporaryPath = path.join(
+    path.dirname(configPath),
+    `.${path.basename(configPath)}.${process.pid}.${randomUUID()}.tmp`,
+  );
+  let handle: fs.FileHandle | undefined;
+  try {
+    handle = await fs.open(temporaryPath, "wx", 0o600);
+    await handle.writeFile(`${JSON.stringify(value, null, "\t")}\n`, "utf8");
+    if (process.platform !== "win32") await handle.chmod(0o600);
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+    await fs.rename(temporaryPath, configPath);
+  } catch (error) {
+    await handle?.close().catch(() => undefined);
+    await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+    throw error;
+  }
 }