@narumitw/pi-sync 0.29.1 → 0.30.0

package/src/config.ts

@@ -7,9 +7,25 @@ import {
 	type ExtensionContext,
 	getAgentDir,
 } from "@earendil-works/pi-coding-agent";
+import {
+	activeLocalConfigPath,
+	consumeLocalConfigMigrationNotice,
+	legacyLocalConfigPath,
+	localConfigPath,
+	quarantineAndRemoveConfigIfMatches,
+	readMigratingLocalConfigDocument,
+	replaceLocalConfigDocument,
+	withLocalConfigFileLock,
+} from "./config-file.js";
 import { safeName } from "./paths.js";
 import { DEFAULT_SYNC_FILES, normalizeExtraFiles, normalizeSyncFiles } from "./sync-policy.js";
-import type { PartialConfig, Snapshot, SyncConfig, SyncState } from "./types.js";
+import type {
+	PartialConfig,
+	Snapshot,
+	SyncConfig,
+	SyncState,
+	TargetSwitchAction,
+} from "./types.js";
 
 export { extraFilePathsByLower, normalizeExtraFiles, normalizeSyncFiles } from "./sync-policy.js";
 
@@ -17,6 +33,16 @@ const VERSION = 1;
 const DEFAULT_PROFILE = "default";
 const DEFAULT_PREFIX = "pi-sync";
 const DEFAULT_REGION = "auto";
+export const DEFAULT_TARGET_SWITCH_ACTION: TargetSwitchAction = "ask";
+
+export {
+	activeLocalConfigPath,
+	consumeLocalConfigMigrationNotice,
+	legacyLocalConfigPath,
+	localConfigPath,
+	quarantineAndRemoveConfigIfMatches,
+	replaceLocalConfigDocument,
+};
 
 export const DEPRECATED_PI_SYNC_ENV_NAMES = [
 	"PI_SYNC_ENDPOINT",
@@ -121,6 +147,20 @@ export async function loadPartialConfig(targetName?: string): Promise<PartialCon
 	return resolveLegacyPartialConfig(fileConfig as PartialConfig);
 }
 
+export async function loadTargetSwitchAction(): Promise<TargetSwitchAction> {
+	const settings = await readLocalConfigObject();
+	if (!settings || !isV2SettingsObject(settings)) return DEFAULT_TARGET_SWITCH_ACTION;
+	return normalizeTargetSwitchAction(settings.targetSwitchAction);
+}
+
+export function normalizeTargetSwitchAction(value: unknown): TargetSwitchAction {
+	if (value === undefined) return DEFAULT_TARGET_SWITCH_ACTION;
+	if (value === "ask" || value === "pull" || value === "switch-only") return value;
+	throw new Error(
+		'Invalid pi-sync settings: targetSwitchAction must be "ask", "pull", or "switch-only".',
+	);
+}
+
 export function deprecatedPiSyncEnvironmentNames() {
 	return DEPRECATED_PI_SYNC_ENV_NAMES.filter((name) => hasEnv(name));
 }
@@ -160,6 +200,7 @@ export function resolveV2PartialConfig(
 	settings: Record<string, unknown>,
 	targetName?: string,
 ): PartialConfig {
+	normalizeTargetSwitchAction(settings.targetSwitchAction);
 	const targets = requireNamedObjectMap(settings.targets, "targets");
 	const profiles = requireNamedObjectMap(settings.profiles, "profiles");
 	validateUniqueRemoteTargets(targets);
@@ -469,14 +510,11 @@ export function stateDir() {
 	return path.join(agentDir(), ".pisync");
 }
 
-export function localConfigPath() {
-	return path.join(agentDir(), "pi-sync.local.json");
-}
-
 export function localConfigTemplate(): Record<string, unknown> {
 	return {
 		version: 2,
 		activeTarget: DEFAULT_PROFILE,
+		targetSwitchAction: DEFAULT_TARGET_SWITCH_ACTION,
 		profiles: {
 			[DEFAULT_PROFILE]: {
 				kind: "r2",
@@ -501,22 +539,91 @@ export function localConfigTemplate(): Record<string, unknown> {
 	};
 }
 
+export async function readLocalConfigDocument() {
+	return readMigratingLocalConfigDocument(validateConfigDocumentForMigration);
+}
+
 export async function readLocalConfigObject(): Promise<Record<string, unknown> | undefined> {
-	const configPath = localConfigPath();
-	try {
-		const stat = await fs.lstat(configPath);
-		if (stat.isSymbolicLink())
-			throw new Error(`Refusing to read symlinked pi-sync config: ${configPath}`);
-		if (!stat.isFile()) throw new Error(`pi-sync config is not a regular file: ${configPath}`);
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
-		throw error;
+	return (await readLocalConfigDocument())?.parsed;
+}
+
+function validateConfigDocumentForMigration(settings: Record<string, unknown>) {
+	if (!isV2SettingsObject(settings)) {
+		for (const field of [
+			"endpoint",
+			"bucket",
+			"region",
+			"accessKeyId",
+			"secretAccessKey",
+			"sessionToken",
+			"profile",
+			"prefix",
+		] as const) {
+			asOptionalString(settings[field]);
+		}
+		for (const field of ["autoSync", "syncSessions"] as const) {
+			const value = settings[field];
+			if (value !== undefined && typeof value !== "boolean" && typeof value !== "string") {
+				throw new Error(`Invalid pi-sync settings: ${field} must be a boolean or string.`);
+			}
+		}
+		normalizeSyncFiles(settings.syncFiles);
+		normalizeExtraFiles(settings.extraFiles);
+		return;
+	}
+
+	normalizeTargetSwitchAction(settings.targetSwitchAction);
+	const profiles = requireNamedObjectMap(settings.profiles, "profiles");
+	const targets = requireNamedObjectMap(settings.targets, "targets");
+	validateUniqueRemoteTargets(targets);
+	for (const [name, value] of Object.entries(profiles)) {
+		const profile = ownObject(profiles, name);
+		if (!profile || value !== profile) {
+			throw new Error(`Invalid pi-sync settings: storage profile "${name}" must be an object.`);
+		}
+		const kind = asOptionalString(profile.kind);
+		if (kind !== undefined && kind !== "r2" && kind !== "s3-compatible") {
+			throw new Error(
+				`Invalid pi-sync settings: profile "${name}" has unsupported kind "${kind}".`,
+			);
+		}
+		for (const field of [
+			"endpoint",
+			"region",
+			"accessKeyId",
+			"secretAccessKey",
+			"sessionToken",
+		] as const) {
+			asOptionalString(profile[field]);
+		}
+	}
+	for (const [name, value] of Object.entries(targets)) {
+		const target = ownObject(targets, name);
+		if (!target || value !== target) {
+			throw new Error(`Invalid pi-sync settings: target "${name}" must be an object.`);
+		}
+		const profileName = normalizeOptionalString(asOptionalString(target.profile));
+		if (!profileName || !Object.hasOwn(profiles, profileName)) {
+			throw new Error(`Invalid pi-sync settings: target "${name}" references a missing profile.`);
+		}
+		for (const field of ["bucket", "prefix", "namespace"] as const) {
+			asOptionalString(target[field]);
+		}
+		asOptionalBoolean(target.autoSync);
+		asOptionalBoolean(target.syncSessions);
+		normalizeSyncFiles(target.syncFiles);
+		normalizeExtraFiles(target.extraFiles);
+	}
+	const activeTarget = normalizeOptionalString(asOptionalString(settings.activeTarget));
+	if (Object.keys(targets).length === 0) {
+		if (activeTarget) {
+			throw new Error("Invalid pi-sync settings: targetless settings cannot have activeTarget.");
+		}
+		return;
 	}
-	const parsed = JSON.parse(await fs.readFile(configPath, "utf8")) as unknown;
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-		throw new Error(`pi-sync config must contain a JSON object: ${configPath}`);
+	if (!activeTarget || !Object.hasOwn(targets, activeTarget)) {
+		throw new Error("Invalid pi-sync settings: activeTarget must reference an existing target.");
 	}
-	return parsed as Record<string, unknown>;
 }
 
 let configUpdateQueue: Promise<void> = Promise.resolve();
@@ -541,7 +648,11 @@ async function performLocalConfigUpdate(
 	return next;
 }
 
-export async function writeLocalConfigObject(value: Record<string, unknown>) {
+export function writeLocalConfigObject(value: Record<string, unknown>) {
+	return withLocalConfigFileLock(() => writeLocalConfigObjectUnlocked(value));
+}
+
+async function writeLocalConfigObjectUnlocked(value: Record<string, unknown>) {
 	const configPath = localConfigPath();
 	await fs.mkdir(path.dirname(configPath), { recursive: true });
 	try {

package/src/file-selection.ts

@@ -145,7 +145,6 @@ async function showDraftEditor(
 			getSettingsListTheme(),
 			(id, newValue) => updateDraft(draft, id, newValue === INCLUDED),
 			() => done(undefined),
-			{ enableSearch: true },
 		);
 		container.addChild(settingsList);
 		container.addChild(hint);

package/src/manager-ui.ts

@@ -1,17 +1,17 @@
 import { BorderedLoader, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { setSyncTargetCompletions } from "./command.js";
 import {
+	activeLocalConfigPath,
 	configuredTargetNames,
 	deprecatedPiSyncEnvironmentWarnings,
 	isCloudflareR2Endpoint,
-	isEnabled,
 	loadConfig,
 	loadPartialConfig,
+	loadTargetSwitchAction,
 	localConfigPath,
-	normalizeExtraFiles,
 	normalizeSyncFiles,
 	readLocalConfigObject,
-	updateLocalConfig,
+	readStateForConfig,
 } from "./config.js";
 import { inspectLock, isStaleLock } from "./lock.js";
 import {
@@ -24,23 +24,37 @@ import {
 	updateStorageProfile,
 	updateSyncTarget,
 } from "./settings-management.js";
+import { showSyncSettings } from "./settings-ui.js";
 import { DEFAULT_SYNC_FILES } from "./sync-policy.js";
+import { type TargetPullOutcome, useSyncTarget } from "./target-switch.js";
 import type { SyncConfig } from "./types.js";
 
 export const MAIN_MENU_ACTIONS = [
-	"Sync now",
+	"Sync now (recommended)",
+	"Pull from remote",
+	"Push to remote",
 	"Switch target",
 	"Status & changes",
 	"Settings",
+	"More…",
+] as const;
+
+const MORE_MENU_ACTIONS = [
 	"Manage targets & storage",
 	"History & recovery",
 	"Help",
+	"Back",
 ] as const;
-
 const BACK = "Back";
 
 type MainMenuAction = (typeof MAIN_MENU_ACTIONS)[number];
-type RunRoute = (route: string, signal?: AbortSignal, onCommit?: () => void) => Promise<void>;
+type ContextualMenuAction = "Manage targets & storage" | "History & recovery" | "Help";
+type RunRoute = (
+	route: string,
+	signal?: AbortSignal,
+	onCommit?: () => void,
+	target?: string,
+) => Promise<TargetPullOutcome | undefined>;
 
 export async function showSyncManager(
 	ctx: ExtensionCommandContext,
@@ -54,18 +68,48 @@ export async function showSyncManager(
 		const state = await describeManagerState();
 		const selected = await ctx.ui.select(state.title, state.actions);
 		if (!selected) return;
-		switch (selected as MainMenuAction | "Set up sync" | "Use existing settings") {
-			case "Sync now":
+		switch (
+			selected as MainMenuAction | ContextualMenuAction | "Set up sync" | "Use existing settings"
+		) {
+			case "Sync now (recommended)":
 				await runCancellableOperation(ctx, "Checking current target…", "sync", runRoute, true);
 				break;
-			case "Switch target":
-				if (await showTargetSwitcher(ctx)) continue;
+			case "Pull from remote": {
+				const result = await runCancellableOperation(
+					ctx,
+					"Checking remote changes…",
+					"pull",
+					runRoute,
+					true,
+					"Pull check cancelled; no local files were changed.",
+				);
+				if (result === "applied") return;
 				break;
+			}
+			case "Push to remote":
+				await runCancellableOperation(
+					ctx,
+					"Preparing push preview…",
+					"push",
+					runRoute,
+					true,
+					"Push preparation cancelled; no remote files were changed.",
+				);
+				break;
+			case "Switch target": {
+				const result = await showTargetSwitcher(ctx, runRoute);
+				if (result === "pull-attempted") return;
+				if (result === "switched") continue;
+				break;
+			}
 			case "Status & changes":
 				await runCancellableOperation(ctx, "Checking current target…", "diff", runRoute);
 				break;
 			case "Settings":
-				await showSettingsMenu(ctx, runRoute);
+				await showSyncSettings(ctx, runRoute);
+				break;
+			case "More…":
+				if ((await showMoreMenu(ctx, runRoute)) === "exit") return;
 				break;
 			case "Manage targets & storage":
 				await showManageMenu(ctx, runRoute);
@@ -73,30 +117,43 @@ export async function showSyncManager(
 			case "History & recovery":
 				await showRecoveryMenu(ctx, runRoute);
 				break;
+			case "Help":
+				await runRoute("help");
+				return;
 			case "Set up sync":
 			case "Use existing settings":
 				await runRoute("init");
 				continue;
-			case "Help":
-				await runRoute("help");
-				return;
 		}
 	}
 }
 
+async function showMoreMenu(ctx: ExtensionCommandContext, runRoute: RunRoute) {
+	const selected = await ctx.ui.select("More options", [...MORE_MENU_ACTIONS]);
+	if (!selected || selected === BACK) return;
+	if (selected === "Manage targets & storage") await showManageMenu(ctx, runRoute);
+	else if (selected === "History & recovery") await showRecoveryMenu(ctx, runRoute);
+	else {
+		await runRoute("help");
+		return "exit" as const;
+	}
+}
+
 async function runCancellableOperation(
 	ctx: ExtensionCommandContext,
 	message: string,
 	route: string,
 	runRoute: RunRoute,
 	commitAware = false,
+	cancelledMessage: string | null = "Check cancelled; no settings or files were changed.",
+	target?: string,
 ) {
 	if (ctx.mode !== "tui") {
-		await runRoute(route);
-		return;
+		return await runRoute(route, undefined, undefined, target);
 	}
 	let commitStarted = false;
 	let operation: Promise<void> | undefined;
+	let routeResult: TargetPullOutcome | undefined;
 	const result = await ctx.ui.custom<{ cancelled?: boolean; error?: unknown }>(
 		(tui, theme, _kb, done) => {
 			const loader = new BorderedLoader(tui, theme, message, { cancellable: true });
@@ -116,8 +173,10 @@ async function runCancellableOperation(
 				route,
 				loader.signal,
 				commitAware ? () => (commitStarted = true) : undefined,
+				target,
 			)
-				.then(() => {
+				.then((result) => {
+					routeResult = result;
 					if (!closed) done({});
 				})
 				.catch((error) => {
@@ -128,10 +187,11 @@ async function runCancellableOperation(
 	);
 	if (result?.cancelled) {
 		await operation;
-		ctx.ui.notify("Check cancelled; no settings or files were changed.", "info");
-		return;
+		if (cancelledMessage) ctx.ui.notify(cancelledMessage, "info");
+		return "cancelled";
 	}
 	if (result?.error) throw result.error;
+	return routeResult;
 }
 
 async function describeManagerState(): Promise<{ title: string; actions: string[] }> {
@@ -145,7 +205,7 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 				"",
 				"Settings file needs repair. Automatic sync and settings writes are paused.",
 				`Error: ${safeTerminalText(errorMessage(error))}`,
-				`File: ${safeTerminalText(localConfigPath())}`,
+				`File: ${safeTerminalText(await activeLocalConfigPath())}`,
 				"",
 				"Repair the JSON file, then reopen /sync.",
 			].join("\n"),
@@ -181,15 +241,34 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 		const liveLock = lock.status === "valid" && !isStaleLock(lock.lock);
 		const recoverableLock =
 			lock.status === "unreadable" || (lock.status === "valid" && isStaleLock(lock.lock));
+		const builtInCount = normalizeSyncFiles(config.syncFiles).length;
+		const extraFileCount = config.extraFiles.length;
+		const noSyncedContent = builtInCount === 0 && extraFileCount === 0 && !config.syncSessions;
+		const stateReadDisabled = liveLock || recoverableLock;
+		const syncState = stateReadDisabled
+			? undefined
+			: await readStateForConfig(config).catch(() => undefined);
+		const lastAppliedSnapshot = stateReadDisabled
+			? "Unavailable while operations are locked"
+			: syncState?.lastAppliedSnapshot
+				? safeTerminalText(syncState.lastAppliedSnapshot)
+				: syncState
+					? "Never synced"
+					: "Unavailable";
 		return {
 			title: [
 				"Pi Sync",
 				"",
 				`Current target: ${safeTerminalText(target)}`,
 				`Storage: ${storage}`,
-				`Auto-sync: ${config.autoSync ? "On" : "Off"} · Sessions: ${config.syncSessions ? "On" : "Off"}`,
-				"Last known sync: Remote not checked",
+				`Synced content: ${builtInCount} built-in group${builtInCount === 1 ? "" : "s"} · ${extraFileCount} extra file${extraFileCount === 1 ? "" : "s"} · Sessions: ${config.syncSessions ? "On" : "Off"}`,
+				`Auto-sync: ${config.autoSync ? "On" : "Off"}`,
+				`Last applied snapshot: ${lastAppliedSnapshot}`,
+				"Remote changes: Not checked",
 				...warnings.map((warning) => `Warning: ${safeTerminalText(warning)}`),
+				...(noSyncedContent
+					? ["", "No synced content is selected. Choose synced content in Settings before syncing."]
+					: []),
 				...(liveLock
 					? [
 							"",
@@ -205,7 +284,9 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 			actions:
 				liveLock || recoverableLock
 					? ["Status & changes", "History & recovery", "Help"]
-					: [...MAIN_MENU_ACTIONS],
+					: noSyncedContent
+						? ["Settings", "Switch target", "Status & changes", "More…"]
+						: [...MAIN_MENU_ACTIONS],
 		};
 	} catch (error) {
 		const targets = ownRecord(raw.targets);
@@ -216,7 +297,7 @@ async function describeManagerState(): Promise<{ title: string; actions: string[
 				"Settings need attention. Automatic sync is paused.",
 				`Current target: ${safeTerminalText(typeof raw.activeTarget === "string" ? raw.activeTarget : "default")}`,
 				`Error: ${safeTerminalText(errorMessage(error))}`,
-				`File: ${safeTerminalText(localConfigPath())}`,
+				`File: ${safeTerminalText(await activeLocalConfigPath())}`,
 				"",
 				"What do you want to do?",
 			].join("\n"),
@@ -346,7 +427,7 @@ export async function showSetupWizard(ctx: ExtensionCommandContext) {
 	return true;
 }
 
-async function showTargetSwitcher(ctx: ExtensionCommandContext) {
+async function showTargetSwitcher(ctx: ExtensionCommandContext, runRoute: RunRoute) {
 	const raw = await readLocalConfigObject();
 	if (raw?.version !== 2) {
 		ctx.ui.notify("Add a second sync target before switching targets.", "info");
@@ -395,6 +476,13 @@ async function showTargetSwitcher(ctx: ExtensionCommandContext) {
 		);
 		return false;
 	}
+	const targetSwitchAction = await loadTargetSwitchAction();
+	const switchEffect =
+		targetSwitchAction === "ask"
+			? "After switching, pi-sync will ask whether to review a pull for the target."
+			: targetSwitchAction === "pull"
+				? "After switching, pi-sync will check the target and show exact changes before applying them."
+				: "After switching, pi-sync will not pull or modify synced files.";
 	const choice = await ctx.ui.select(
 		[
 			"Switch target",
@@ -405,70 +493,23 @@ async function showTargetSwitcher(ctx: ExtensionCommandContext) {
 			`Synced content: ${normalizeSyncFiles(config.syncFiles).length} built-in groups · ${config.extraFiles.length} extra files`,
 			`Auto-sync: ${config.autoSync ? "On" : "Off"} · Sessions: ${config.syncSessions ? "On" : "Off"}`,
 			"",
-			"Switching does not sync or modify files now.",
+			switchEffect,
 		].join("\n"),
 		[`Switch to ${safeTerminalText(name)}`, "Cancel"],
 	);
 	if (choice !== `Switch to ${safeTerminalText(name)}`) return false;
-	await useSyncTarget(ctx, name);
-	return true;
-}
-
-export async function useSyncTarget(ctx: ExtensionCommandContext, name: string) {
-	const normalized = name.trim();
-	if (!normalized) throw new Error("Usage: /sync use <target>");
-	await loadConfig(normalized);
-	await updateLocalConfig((current) => {
-		if (current.version !== 2) throw new Error("Target switching requires version 2 settings.");
-		return { ...current, activeTarget: normalized };
-	});
-	await refreshTargetCompletions();
-	ctx.ui.notify(
-		`Switched to “${safeTerminalText(normalized)}”. No files were synced; use Sync now when ready.`,
-		"info",
-	);
-}
-
-async function showSettingsMenu(ctx: ExtensionCommandContext, runRoute: RunRoute) {
-	const partial = await loadPartialConfig();
-	const automaticSyncOverridden = Object.hasOwn(process.env, "PI_SYNC_AUTO_SYNC");
-	const selected = await ctx.ui.select(
-		[
-			`Settings for target “${safeTerminalText(partial.target ?? "default")}”`,
-			`Storage: ${storageDescription(partial.storageKind, partial.endpoint, partial.bucket)}`,
-			"Automatic sync changes save immediately; synced-content changes use a reviewed draft.",
-			"",
-			`Auto-sync: ${isEnabled(partial.autoSync, true) ? "On" : "Off"}`,
-			`Synced content: ${normalizeSyncFiles(partial.syncFiles).length} built-ins · ${normalizeExtraFiles(partial.extraFiles).length} extra`,
-		].join("\n"),
-		[
-			"Choose synced content",
-			automaticSyncOverridden
-				? "Automatic sync (environment override, deprecated)"
-				: "Toggle automatic sync",
-			BACK,
-		],
-	);
-	if (!selected || selected === BACK) return;
-	if (selected === "Choose synced content") {
-		await runRoute("files");
-		return;
-	}
-	if (automaticSyncOverridden) {
-		ctx.ui.notify(
-			"Automatic sync is read-only because deprecated PI_SYNC_AUTO_SYNC currently overrides this target. Move it into target settings before the future major removal.",
-			"warning",
-		);
-		return;
-	}
-	await updateCurrentTarget((target) => ({
-		...target,
-		autoSync: !isEnabled(partial.autoSync, true),
-	}));
-	ctx.ui.notify(
-		`Automatic sync ${isEnabled(partial.autoSync, true) ? "disabled" : "enabled"} for “${safeTerminalText(partial.target ?? "default")}”.`,
-		"info",
+	const result = await useSyncTarget(ctx, name, (selectedTarget) =>
+		runCancellableOperation(
+			ctx,
+			`Pulling target “${safeTerminalText(name)}”…`,
+			"pull",
+			runRoute,
+			true,
+			null,
+			selectedTarget,
+		),
 	);
+	return result.pullApplied ? "pull-attempted" : "switched";
 }
 
 async function showManageMenu(ctx: ExtensionCommandContext, _runRoute: RunRoute) {
@@ -903,20 +944,6 @@ function formatRemotePath(prefix: string, namespace: string) {
 	return safeTerminalText(`${prefix}/profiles/${namespace}/`);
 }
 
-async function updateCurrentTarget(
-	update: (target: Record<string, unknown>) => Record<string, unknown>,
-) {
-	await updateLocalConfig((current) => {
-		if (current.version !== 2) return update(current);
-		const targets = ownRecord(current.targets);
-		const active = typeof current.activeTarget === "string" ? current.activeTarget : undefined;
-		if (!targets || !active) throw new Error("Current target is not configured.");
-		const target = ownRecord(targets[active]);
-		if (!target) throw new Error(`Current target “${active}” is invalid.`);
-		return { ...current, targets: { ...targets, [active]: update(target) } };
-	});
-}
-
 async function requiredExistingBucket(ctx: ExtensionCommandContext, example: string) {
 	const value = await ctx.ui.input("Existing bucket", `Example: ${example}`);
 	if (value === undefined) return undefined;

package/src/paths.ts

@@ -14,7 +14,12 @@ export function isDeniedPath(relativePath: string) {
 		base.endsWith(".env") ||
 		base.includes("secret") ||
 		base.includes("token") ||
-		base === "pi-sync.local.json"
+		base === "pi-sync.json" ||
+		base.startsWith("pi-sync.json.") ||
+		base.startsWith(".pi-sync.json.") ||
+		base === "pi-sync.local.json" ||
+		base.startsWith("pi-sync.local.json.") ||
+		base.startsWith(".pi-sync.local.json.")
 	);
 }
 

package/src/settings-management.ts

@@ -2,9 +2,12 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import {
+	DEFAULT_TARGET_SWITCH_ACTION,
 	effectiveTargetRemoteIdentity,
 	localConfigPath,
+	readLocalConfigDocument,
 	readLocalConfigObject,
+	replaceLocalConfigDocument,
 	resolveLegacyPartialConfig,
 	resolveV2PartialConfig,
 	stateDir,
@@ -14,6 +17,21 @@ import {
 import { withLock } from "./lock.js";
 import type { PartialConfig, StorageProfileSettings, SyncTargetSettings } from "./types.js";
 
+let afterLegacySettingsReadHook: () => Promise<void> = async () => undefined;
+
+export async function withLegacySettingsReadHookForTest<T>(
+	hook: () => Promise<void>,
+	run: () => Promise<T>,
+) {
+	const previous = afterLegacySettingsReadHook;
+	afterLegacySettingsReadHook = hook;
+	try {
+		return await run();
+	} finally {
+		afterLegacySettingsReadHook = previous;
+	}
+}
+
 const LEGACY_FIELDS = new Set([
 	"endpoint",
 	"bucket",
@@ -41,21 +59,17 @@ export async function migrateLegacySettings(
 	validateName(targetName, "target");
 	validateName(storageProfileName, "storage profile");
 	return withLock("settings-migration", async () => {
-		const configPath = localConfigPath();
-		const originalBytes = await fs.readFile(configPath);
-		const current = await readLocalConfigObject();
-		if (!current) throw new Error("No legacy pi-sync settings are available to migrate.");
+		const document = await readLocalConfigDocument();
+		if (!document) throw new Error("No legacy pi-sync settings are available to migrate.");
+		const { bytes: originalBytes, parsed: current } = document;
 		if (current.version === 2) {
 			throw new Error("pi-sync settings already use profiles and targets.");
 		}
+		await afterLegacySettingsReadHook();
 		const next = legacySettingsAsV2(current, targetName, storageProfileName);
 		const backupPath = await writeMigrationBackup(originalBytes);
 		await adoptLegacyState(current, next, targetName);
-		const latestBytes = await fs.readFile(configPath);
-		if (!latestBytes.equals(originalBytes)) {
-			throw new Error("pi-sync settings changed during migration; no settings were replaced.");
-		}
-		await writeLocalConfigObject(next);
+		await replaceLocalConfigDocument(document, next);
 		return { settings: next, backupPath };
 	});
 }
@@ -112,6 +126,7 @@ export async function saveNewV2Settings(input: {
 	const settings = {
 		version: 2,
 		activeTarget: input.targetName,
+		targetSwitchAction: DEFAULT_TARGET_SWITCH_ACTION,
 		profiles: { [input.storageProfileName]: { ...input.profile } },
 		targets: {
 			[input.targetName]: { ...input.target, profile: input.storageProfileName },