@narumitw/pi-sync 0.30.0 → 0.34.0

package/src/settings-ui.ts

@@ -3,88 +3,77 @@ import {
 	getSettingsListTheme,
 } from "@earendil-works/pi-coding-agent";
 import { Container, type SettingItem, SettingsList, Text } from "@earendil-works/pi-tui";
+import { loadConfig, localConfigPath } from "./config.js";
+import { updateSyncSetup } from "./settings-management.js";
 import {
-	isCloudflareR2Endpoint,
-	isEnabled,
-	loadPartialConfig,
-	loadTargetSwitchAction,
-	localConfigPath,
-	normalizeExtraFiles,
-	normalizeSyncFiles,
-	readLocalConfigObject,
-	updateLocalConfig,
-} from "./config.js";
-import { errorMessage, safeTerminalText } from "./sync-format.js";
-import {
-	saveTargetSwitchAction,
-	TARGET_SWITCH_ACTION_OPTIONS,
-	type TargetPullOutcome,
-	targetSwitchActionFromLabel,
-	targetSwitchActionLabel,
-} from "./target-switch.js";
+	SETUP_SWITCH_ACTION_OPTIONS,
+	type SetupPullOutcome,
+	saveOnSwitch,
+	setupSwitchActionFromLabel,
+	setupSwitchActionLabel,
+} from "./setup-switch.js";
+import { safeTerminalText } from "./sync-format.js";
 
 export type SyncSettingsRoute = (
 	route: string,
 	signal?: AbortSignal,
 	onCommit?: () => void,
-	target?: string,
-) => Promise<TargetPullOutcome | undefined>;
+	setup?: string,
+) => Promise<SetupPullOutcome | undefined>;
 
-export async function showSyncSettings(ctx: ExtensionCommandContext, runRoute: SyncSettingsRoute) {
+export async function showSyncSettings(
+	ctx: ExtensionCommandContext,
+	runRoute: SyncSettingsRoute,
+	signal?: AbortSignal,
+) {
 	if (ctx.mode !== "tui") {
 		ctx.ui.notify(`Edit pi-sync settings manually: ${safeTerminalText(localConfigPath())}`, "info");
 		return;
 	}
-	while (true) {
-		const raw = await readLocalConfigObject();
-		const version2 = raw?.version === 2;
-		const partial = await loadPartialConfig();
-		const action = await showSettingsList(ctx, partial, version2);
-		if (action !== "files") return;
-		await runRoute("files", undefined, undefined, version2 ? partial.target : undefined);
+	while (!signal?.aborted) {
+		const config = await loadConfig();
+		if (signal?.aborted) return;
+		const action = await showSettingsList(ctx, config, signal);
+		if (signal?.aborted || action !== "files") return;
+		await runRoute("files", signal, undefined, config.setupName);
 	}
 }
 
 async function showSettingsList(
 	ctx: ExtensionCommandContext,
-	partial: Awaited<ReturnType<typeof loadPartialConfig>>,
-	version2: boolean,
+	config: Awaited<ReturnType<typeof loadConfig>>,
+	signal?: AbortSignal,
 ) {
-	const targetName = version2 ? partial.target : undefined;
-	const automaticSyncOverridden = Object.hasOwn(process.env, "PI_SYNC_AUTO_SYNC");
-	const automaticSyncValue = isEnabled(partial.autoSync, true) ? "On" : "Off";
-	const targetSwitchAction = await loadTargetSwitchAction();
-	const targetSwitchValue = targetSwitchActionLabel(targetSwitchAction);
+	const automaticValue = config.automatic ? "On" : "Off";
+	const switchValue = setupSwitchActionLabel(config.onSwitch);
 	let saveQueue = Promise.resolve();
 	const latestRequested = new Map<string, string>();
+	const mutationController = new AbortController();
+	const mutationSignal = signal
+		? AbortSignal.any([signal, mutationController.signal])
+		: mutationController.signal;
 
 	return ctx.ui.custom<"files" | undefined>((tui, theme, _keybindings, done) => {
 		const items: SettingItem[] = [
 			{
-				id: "automaticSync",
-				label: automaticSyncOverridden ? "Automatic sync (environment override)" : "Automatic sync",
-				description: automaticSyncOverridden
-					? "Read-only while deprecated PI_SYNC_AUTO_SYNC overrides this target. Move the value into target settings before the future major removal."
-					: "Run conservative synchronization automatically at session startup and shutdown.",
-				currentValue: automaticSyncValue,
-				...(automaticSyncOverridden ? {} : { values: ["On", "Off"] }),
+				id: "automatic",
+				label: "Automatic sync",
+				description: "Run conservative synchronization at session startup and shutdown.",
+				currentValue: automaticValue,
+				values: ["On", "Off"],
 			},
-			...(version2
-				? [
-						{
-							id: "targetSwitchAction",
-							label: "After target switch",
-							description:
-								"Ask before starting a pull, start a pull review automatically, or switch without checking remote files. Every pull still shows exact changes before apply.",
-							currentValue: targetSwitchValue,
-							values: TARGET_SWITCH_ACTION_OPTIONS.map(({ label }) => label),
-						},
-					]
-				: []),
 			{
-				id: "syncFiles",
-				label: "Synced content",
-				description: `${normalizeSyncFiles(partial.syncFiles).length} built-in groups and ${normalizeExtraFiles(partial.extraFiles).length} extra files. Opens the reviewed content-selection draft.`,
+				id: "onSwitch",
+				label: "After switching setup",
+				description:
+					"Ask before a reviewed pull, start a reviewed pull, or switch without checking remote files.",
+				currentValue: switchValue,
+				values: SETUP_SWITCH_ACTION_OPTIONS.map(({ label }) => label),
+			},
+			{
+				id: "include",
+				label: "Included content",
+				description: `${config.include.length} selected path${config.include.length === 1 ? "" : "s"}. Opens the reviewed content-selection draft.`,
 				currentValue: "Open editor",
 				values: ["Open editor"],
 			},
@@ -95,7 +84,7 @@ async function showSettingsList(
 			new Text(
 				theme.fg(
 					"muted",
-					`Target: ${safeTerminalText(partial.target ?? "default")} · ${storageDescription(partial.storageKind, partial.endpoint, partial.bucket)}`,
+					`Sync setup: ${safeTerminalText(config.setupName)} · Storage connection: ${safeTerminalText(config.connectionName)}`,
 				),
 				1,
 				0,
@@ -103,50 +92,66 @@ async function showSettingsList(
 		);
 		let settingsList: SettingsList;
 		let closing = false;
+		let disposed = false;
 		const closeAfterSaves = (result: "files" | undefined) => {
-			if (closing) return;
+			if (closing || disposed) return;
 			closing = true;
-			void saveQueue.then(() => done(result));
+			void saveQueue.then(() => {
+				if (!disposed) done(signal?.aborted ? undefined : result);
+			});
+		};
+		const onAbort = () => {
+			if (!closing && !disposed) done(undefined);
 		};
+		signal?.addEventListener("abort", onAbort, { once: true });
 		settingsList = new SettingsList(
 			items,
 			Math.min(items.length + 2, 15),
 			getSettingsListTheme(),
 			(id, newValue) => {
-				if (id === "syncFiles") {
+				if (id === "include") {
 					closeAfterSaves("files");
 					return;
 				}
 				latestRequested.set(id, newValue);
-				const fallbackValue = id === "automaticSync" ? automaticSyncValue : targetSwitchValue;
+				const fallback = id === "automatic" ? automaticValue : switchValue;
 				const operation = saveQueue.then(async () => {
-					let previousValue = fallbackValue;
+					if (disposed || signal?.aborted) return;
+					let previousValue = fallback;
 					try {
-						if (id === "automaticSync") {
-							const latest = await loadPartialConfig(targetName);
-							previousValue = isEnabled(latest.autoSync, true) ? "On" : "Off";
-							const enabled = newValue === "On";
-							await updateSettingsTarget(targetName, (target) => ({
-								...target,
-								autoSync: enabled,
-							}));
+						const latest = await loadConfig(config.setupName);
+						if (disposed || signal?.aborted) return;
+						if (id === "automatic") {
+							previousValue = latest.automatic ? "On" : "Off";
+							const automatic = newValue === "On";
+							await updateSyncSetup(
+								config.setupName,
+								(setup) => ({
+									...setup,
+									sync: { ...setup.sync, automatic },
+								}),
+								{ signal: mutationSignal },
+							);
+							if (disposed || signal?.aborted) return;
 							ctx.ui.notify(
-								`Automatic sync ${enabled ? "enabled" : "disabled"} for “${safeTerminalText(partial.target ?? "default")}”.`,
+								`Automatic sync ${automatic ? "enabled" : "disabled"} for “${safeTerminalText(config.setupName)}”.`,
 								"info",
 							);
-						} else if (id === "targetSwitchAction") {
-							const latest = await loadTargetSwitchAction();
-							previousValue = targetSwitchActionLabel(latest);
-							const action = targetSwitchActionFromLabel(newValue);
-							if (!action) throw new Error(`Invalid target-switch action: ${newValue}`);
-							await saveTargetSwitchAction(action);
-							ctx.ui.notify(`After target switch: ${newValue}.`, "info");
+						} else {
+							previousValue = setupSwitchActionLabel(latest.onSwitch);
+							const action = setupSwitchActionFromLabel(newValue);
+							if (!action) throw new Error(`Invalid setup-switch action: ${newValue}`);
+							await saveOnSwitch(action, mutationSignal);
+							if (disposed || signal?.aborted) return;
+							ctx.ui.notify(`After switching setup: ${newValue}.`, "info");
 						}
 					} catch (error) {
-						if (latestRequested.get(id) === newValue) {
-							settingsList.updateValue(id, previousValue);
-						}
-						ctx.ui.notify(`Pi Sync settings save failed: ${errorMessage(error)}`, "error");
+						if (disposed || signal?.aborted) return;
+						if (latestRequested.get(id) === newValue) settingsList.updateValue(id, previousValue);
+						ctx.ui.notify(
+							`Pi Sync settings save failed: ${error instanceof Error ? error.message : String(error)}`,
+							"error",
+						);
 						tui.requestRender();
 					}
 				});
@@ -159,41 +164,15 @@ async function showSettingsList(
 			render: (width: number) => container.render(width),
 			invalidate: () => container.invalidate(),
 			handleInput(data: string) {
+				if (disposed) return;
 				settingsList.handleInput?.(data);
 				tui.requestRender();
 			},
+			dispose() {
+				disposed = true;
+				mutationController.abort(new DOMException("Settings UI disposed", "AbortError"));
+				signal?.removeEventListener("abort", onAbort);
+			},
 		};
 	});
 }
-
-async function updateSettingsTarget(
-	targetName: string | undefined,
-	update: (target: Record<string, unknown>) => Record<string, unknown>,
-) {
-	await updateLocalConfig((current) => {
-		if (current.version !== 2) return update(current);
-		const targets = ownRecord(current.targets);
-		const selected =
-			targetName ?? (typeof current.activeTarget === "string" ? current.activeTarget : undefined);
-		if (!targets || !selected) throw new Error("Settings target is not configured.");
-		const target = ownRecord(targets[selected]);
-		if (!target) throw new Error(`Settings target “${selected}” is invalid.`);
-		return { ...current, targets: { ...targets, [selected]: update(target) } };
-	});
-}
-
-function storageDescription(
-	kind: string | undefined,
-	endpoint: string | undefined,
-	bucket: string | undefined,
-) {
-	const label =
-		kind === "r2" || isCloudflareR2Endpoint(endpoint) ? "Cloudflare R2" : "S3-compatible";
-	return `${label} · ${safeTerminalText(bucket ?? "bucket missing")}`;
-}
-
-function ownRecord(value: unknown): Record<string, unknown> | undefined {
-	return value && typeof value === "object" && !Array.isArray(value)
-		? (value as Record<string, unknown>)
-		: undefined;
-}

package/src/setup-switch.ts

@@ -0,0 +1,150 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { setSyncSetupCompletions } from "./command.js";
+import {
+	configuredSyncSetupNames,
+	loadConfig,
+	normalizeOnSwitch,
+	syncConfigReviewIdentity,
+	syncSetupReviewIdentity,
+	updateLocalConfig,
+} from "./config.js";
+import { safeTerminalText } from "./sync-format.js";
+import type { OnSwitchAction } from "./types.js";
+
+export const SETUP_SWITCH_ACTION_OPTIONS: ReadonlyArray<{
+	label: string;
+	value: OnSwitchAction;
+}> = [
+	{ label: "Ask before pull", value: "ask-before-pull" },
+	{ label: "Start pull", value: "pull-after-switch" },
+	{ label: "Switch only", value: "switch-only" },
+];
+
+export function setupSwitchActionLabel(action: OnSwitchAction) {
+	return SETUP_SWITCH_ACTION_OPTIONS.find((option) => option.value === action)?.label ?? action;
+}
+
+export function setupSwitchActionFromLabel(label: string): OnSwitchAction | undefined {
+	return SETUP_SWITCH_ACTION_OPTIONS.find((option) => option.label === label)?.value;
+}
+
+export async function saveOnSwitch(action: OnSwitchAction, signal?: AbortSignal) {
+	await updateLocalConfig((settings) => ({ ...settings, onSwitch: action }), signal);
+}
+
+export type SetupPullOutcome = "applied" | "cancelled";
+
+export class SetupPullRequiresUiError extends Error {}
+
+export interface SetupSwitchResult {
+	pullApplied: boolean;
+}
+
+export async function useSyncSetup(
+	ctx: ExtensionCommandContext,
+	name: string,
+	pullCurrentSetup?: (setup: string) => Promise<SetupPullOutcome | undefined>,
+	expectedAction?: OnSwitchAction,
+	signal?: AbortSignal,
+	expectedSetupIdentity?: string,
+): Promise<SetupSwitchResult> {
+	const normalized = name.trim();
+	if (!normalized) throw new Error("Usage: /sync use <setup>");
+	const loadedConfig = await loadConfig(normalized);
+	const reviewedSetupIdentity = expectedSetupIdentity ?? syncConfigReviewIdentity(loadedConfig);
+	throwIfAborted(signal);
+	const switchResult: { action: OnSwitchAction; switched: boolean } = {
+		action: "ask-before-pull",
+		switched: false,
+	};
+	await updateLocalConfig((current) => {
+		throwIfAborted(signal);
+		const setup = current.syncSetups[normalized];
+		if (!setup) {
+			throw new Error(`Sync setup “${safeTerminalText(normalized)}” no longer exists.`);
+		}
+		const connectionName = setup.storage.connection;
+		const connection = current.storageConnections[connectionName];
+		if (
+			!connection ||
+			syncSetupReviewIdentity(normalized, setup, connectionName, connection) !==
+				reviewedSetupIdentity
+		) {
+			throw new Error(
+				`Sync setup “${safeTerminalText(normalized)}” changed while the switch preview was open; reopen it and review the current destination.`,
+			);
+		}
+		switchResult.action = normalizeOnSwitch(current.onSwitch);
+		if (expectedAction !== undefined && switchResult.action !== expectedAction) {
+			throw new Error(
+				"Setup-switch behavior changed while the preview was open; reopen it and retry.",
+			);
+		}
+		if (switchResult.action === "pull-after-switch" && !ctx.hasUI) {
+			throw new SetupPullRequiresUiError(
+				`Automatic setup pulls require interactive confirmation; sync setup “${safeTerminalText(normalized)}” was not switched. Use TUI or RPC mode.`,
+			);
+		}
+		if (current.activeSyncSetup === normalized) return current;
+		switchResult.switched = true;
+		return { ...current, activeSyncSetup: normalized };
+	}, signal);
+	throwIfAborted(signal);
+	if (!switchResult.switched) {
+		ctx.ui.notify(`Sync setup “${safeTerminalText(normalized)}” is already current.`, "info");
+		return { pullApplied: false };
+	}
+	setSyncSetupCompletions(await configuredSyncSetupNames());
+	throwIfAborted(signal);
+
+	if (switchResult.action === "switch-only") {
+		ctx.ui.notify(`Switched to “${safeTerminalText(normalized)}”. No files were pulled.`, "info");
+		return { pullApplied: false };
+	}
+	if (switchResult.action === "ask-before-pull") {
+		if (ctx.mode !== "tui") {
+			ctx.ui.notify(
+				`Switched to “${safeTerminalText(normalized)}”. No files were pulled because confirmation requires TUI mode; run /sync pull to apply this setup.`,
+				"info",
+			);
+			return { pullApplied: false };
+		}
+		const confirmed = await ctx.ui.confirm(
+			`Review a pull for sync setup “${safeTerminalText(normalized)}” now?`,
+			"pi-sync will check the remote snapshot and show the exact local writes and deletions before applying anything.",
+			{ signal },
+		);
+		throwIfAborted(signal);
+		if (!confirmed) {
+			ctx.ui.notify(
+				`Switched to “${safeTerminalText(normalized)}”; files were not pulled.`,
+				"info",
+			);
+			return { pullApplied: false };
+		}
+	}
+
+	ctx.ui.notify(
+		`Switched to “${safeTerminalText(normalized)}”. Checking remote files for a reviewed pull…`,
+		"info",
+	);
+	if (!pullCurrentSetup) {
+		throw new Error(`Switched to “${safeTerminalText(normalized)}”, but pull is unavailable.`);
+	}
+	const pullOutcome = await pullCurrentSetup(normalized);
+	throwIfAborted(signal);
+	if (pullOutcome === "cancelled") {
+		ctx.ui.notify(
+			`Pull cancelled; sync setup “${safeTerminalText(normalized)}” remains current and synced files were not changed.`,
+			"info",
+		);
+	}
+	return { pullApplied: pullOutcome === "applied" };
+}
+
+function throwIfAborted(signal?: AbortSignal) {
+	if (!signal?.aborted) return;
+	throw signal.reason instanceof Error
+		? signal.reason
+		: new DOMException("The operation was aborted", "AbortError");
+}

package/src/snapshot-apply.ts

@@ -36,16 +36,18 @@ function fileHashMap(snapshot: Snapshot) {
 export async function applySnapshot(
 	snapshot: Snapshot,
 	protectedRelativePaths = new Set<string>(),
-	options: Pick<SnapshotOptions, "syncFiles" | "sessionDir" | "extraFiles"> = {},
+	options: Pick<
+		SnapshotOptions,
+		"include" | "sessionDir" | "syncFiles" | "syncSessions" | "extraFiles"
+	> = {},
 ) {
 	const root = agentDir();
 	const { sessionDir } = options;
 	await recoverPendingSnapshotTransactions();
 	const current = await createSnapshot(snapshot.profile, {
-		syncFiles: options.syncFiles,
-		syncSessions: snapshotIncludesSessions(snapshot),
+		...options,
+		...(options.include === undefined ? { syncSessions: snapshotIncludesSessions(snapshot) } : {}),
 		sessionDir,
-		extraFiles: options.extraFiles,
 	});
 	const plan = await addTopLevelCaseVariantDeletes(
 		root,
@@ -228,7 +230,8 @@ function rootForTarget(root: string, target: string, sessionDir?: string) {
 }
 
 async function prepareSnapshotWrite(root: string, target: string, deletePaths: Set<string>) {
-	await ensureSafeDirectory(root, path.dirname(target));
+	const parentWillBeReplaced = await ensureSafeDirectory(root, path.dirname(target), deletePaths);
+	if (parentWillBeReplaced) return;
 	try {
 		const stat = await fs.lstat(target);
 		if (stat.isSymbolicLink())
@@ -241,7 +244,7 @@ async function prepareSnapshotWrite(root: string, target: string, deletePaths: S
 	}
 }
 
-async function ensureSafeDirectory(root: string, directory: string) {
+async function ensureSafeDirectory(root: string, directory: string, deletePaths: Set<string>) {
 	assertWithinRoot(root, directory);
 	const rootPath = path.resolve(root);
 	const relative = path.relative(rootPath, path.resolve(directory));
@@ -252,13 +255,16 @@ async function ensureSafeDirectory(root: string, directory: string) {
 			const stat = await fs.lstat(current);
 			if (stat.isSymbolicLink())
 				throw new Error(`Refusing to follow symlink during snapshot apply: ${current}`);
-			if (!stat.isDirectory())
+			if (!stat.isDirectory()) {
+				if (deletePaths.has(current)) return true;
 				throw new Error(`Snapshot path parent is not a directory: ${current}`);
+			}
 		} catch (error) {
 			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
 			await fs.mkdir(current);
 		}
 	}
+	return false;
 }
 
 async function assertNoSymlinkParents(root: string, target: string) {

package/src/snapshot-codec.ts

@@ -0,0 +1,48 @@
+import { Readable, Writable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { promisify } from "node:util";
+import { createGunzip, gzip } from "node:zlib";
+import type { Snapshot } from "./types.js";
+
+const VERSION = 1;
+const MAX_DECOMPRESSED_SNAPSHOT_BYTES = 512 * 1024 * 1024;
+const gzipAsync = promisify(gzip);
+
+export async function encodeSnapshot(snapshot: Snapshot) {
+	return gzipAsync(Buffer.from(JSON.stringify(snapshot), "utf8"));
+}
+
+export async function decodeSnapshot(
+	buffer: Buffer,
+	options: { signal?: AbortSignal; maxOutputLength?: number } = {},
+): Promise<Snapshot> {
+	throwIfAborted(options.signal);
+	const limit = options.maxOutputLength ?? MAX_DECOMPRESSED_SNAPSHOT_BYTES;
+	const chunks: Buffer[] = [];
+	let total = 0;
+	const sink = new Writable({
+		write(chunk: Buffer, _encoding, callback) {
+			total += chunk.byteLength;
+			if (total > limit) {
+				callback(new Error(`Decompressed snapshot exceeds the ${limit}-byte limit.`));
+				return;
+			}
+			chunks.push(Buffer.from(chunk));
+			callback();
+		},
+	});
+	await pipeline(Readable.from([buffer]), createGunzip(), sink, { signal: options.signal });
+	throwIfAborted(options.signal);
+	const parsed = JSON.parse(Buffer.concat(chunks, total).toString("utf8")) as Snapshot;
+	if (parsed.version !== VERSION || !Array.isArray(parsed.files)) {
+		throw new Error("Unsupported snapshot format.");
+	}
+	return parsed;
+}
+
+function throwIfAborted(signal?: AbortSignal) {
+	if (!signal?.aborted) return;
+	throw signal.reason instanceof Error
+		? signal.reason
+		: new DOMException("The operation was aborted", "AbortError");
+}

package/src/snapshot-transaction.ts

@@ -34,6 +34,7 @@ export async function applySnapshotTransaction(
 			await fs.rm(target, { force: true, recursive: true });
 		}
 		for (const item of plan.writes) {
+			await fs.mkdir(path.dirname(item.target), { recursive: true });
 			await fs.writeFile(item.target, item.content);
 		}
 		await fs.rm(transaction.directory, { recursive: true, force: true });
@@ -125,7 +126,8 @@ async function prepareTransaction(plan: SnapshotApplyPlan, sessionDir?: string)
 				throw new Error(`Unsupported existing snapshot target: ${target}`);
 			}
 		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+			const code = (error as NodeJS.ErrnoException).code;
+			if (code !== "ENOENT" && code !== "ENOTDIR") throw error;
 			entries.push({ target, backupName, kind: "missing" });
 		}
 	}