@narumitw/pi-sync 0.49.15 → 0.50.0

package/src/sync-extension.ts

@@ -1,103 +1,25 @@
-import type {
-	ExtensionAPI,
-	ExtensionCommandContext,
-	ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import type { RunRouteResult } from "./cancellable-operation.js";
-import {
-	completeSyncArguments,
-	parseOptions,
-	resolveSyncCommand,
-	setSyncSetupCompletions,
-	splitArgs,
-	usage,
-	validateCommandOptions,
-} from "./command.js";
-import {
-	activeLocalConfigPath,
-	configuredSyncSetupNames,
-	consumeLocalConfigMigrationNotice,
-	createLocalConfigDocument,
-	ensureStateDir,
-	isMissingConfigError,
-	loadConfig,
-	loadPartialConfig,
-	localConfigPath,
-	localConfigTemplate,
-	readLocalConfigObject,
-	readStateForConfig,
-	sessionTokenWarnings,
-	syncSessionsWarnings,
-} from "./config.js";
-import { unlock, withLock } from "./lock.js";
-import { recoverSnapshotTransactionsOnStartup } from "./snapshot-transaction.js";
-import {
-	migrateLegacyStateDirectory,
-	stateDirectoryMigrationNotice,
-	withStateDirectoryAccess,
-} from "./state-directory.js";
-import {
-	createSyncAttentionController,
-	type SyncAttentionController,
-	type SyncAttentionOrigin,
-	syncAttentionMatchesConfig,
-} from "./sync-attention.js";
-import {
-	errorMessage,
-	isSyncDecisionRequiredError,
-	SetupPullRequiresUiError,
-} from "./sync-errors.js";
-import {
-	formatRemoteSelectionMismatch,
-	type RemoteSelectionDecision,
-	RemoteSelectionMismatchError,
-} from "./sync-policy.js";
-import type { AnySyncConfig, CommandOptions, SnapshotOptions } from "./types.js";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { completeSyncArguments, splitArgs } from "./commands/command.js";
+import { handleCommand } from "./commands/command-handler.js";
+import type { AnySyncConfig } from "./settings/settings-types.js";
+import { withStateDirectoryAccess } from "./state/state-directory.js";
+import { autoPushSessions, startSession } from "./sync/automatic-sync.js";
+import { combineSignals } from "./sync/signals.js";
+import { createStartupCheck } from "./sync/startup-check.js";
+import { errorMessage } from "./sync/sync-errors.js";
+import { createSyncLoaders, type SyncDependencies } from "./sync/sync-loaders.js";
+import { createSyncAttentionController } from "./ui/sync-attention.js";
+import { safeTerminalText } from "./ui/terminal-text.js";
 
 const STATUS_KEY = "sync";
 
-type SetupSwitchModule = Pick<typeof import("./setup-switch.js"), "useSyncSetup">;
-type SnapshotModule = Pick<typeof import("./snapshot.js"), "createSnapshot">;
-type SyncStateModule = Pick<typeof import("./sync-state.js"), "hasLocalChanges">;
-type SyncOperations = typeof import("./sync-operations.js");
-
-export interface SyncDependencies {
-	loadSetupSwitch(): Promise<SetupSwitchModule>;
-	loadSnapshot(): Promise<SnapshotModule>;
-	loadSyncState(): Promise<SyncStateModule>;
-	loadSyncOperations(): Promise<SyncOperations>;
-}
-
-interface SyncLoaders {
-	setupSwitch(): Promise<SetupSwitchModule>;
-	snapshot(): Promise<SnapshotModule>;
-	syncState(): Promise<SyncStateModule>;
-	operations(): Promise<SyncOperations>;
-}
-
-const AUTO_SYNC_OPTIONS: CommandOptions = {
-	yes: true,
-	force: false,
-	stale: false,
-	silent: true,
-	reload: false,
-	auto: true,
-	args: [],
-};
 export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDependencies> = {}) {
-	const loaders: SyncLoaders = {
-		setupSwitch: cachedModuleLoader(
-			dependencies.loadSetupSwitch ?? (() => import("./setup-switch.js")),
-		),
-		snapshot: cachedModuleLoader(dependencies.loadSnapshot ?? (() => import("./snapshot.js"))),
-		syncState: cachedModuleLoader(dependencies.loadSyncState ?? (() => import("./sync-state.js"))),
-		operations: cachedModuleLoader(
-			dependencies.loadSyncOperations ?? (() => import("./sync-operations.js")),
-		),
-	};
+	const loaders = createSyncLoaders(dependencies);
 	const attention = createSyncAttentionController();
+	const check = createStartupCheck(loaders, attention);
 	let sessionAbort = new AbortController();
 	let shutdownAbort: AbortController | undefined;
+	let initialization = Promise.resolve<AnySyncConfig | false | undefined>(undefined);
 
 	pi.registerCommand("sync", {
 		description: "Sync Pi settings through Git, WebDAV, R2, or S3-compatible storage",
@@ -108,8 +30,28 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 					"/sync requires TUI or RPC mode so results and safety prompts are observable.",
 				);
 			}
-			const run = () => handleCommand(args, ctx, sessionAbort.signal, loaders, attention);
-			if (splitArgs(args)[0] === "migrate-state") await run();
+			const signal = sessionAbort.signal;
+			const ready = await initialization;
+			if (signal.aborted) return;
+			await check.stop();
+			if (signal.aborted) return;
+			const command = splitArgs(args)[0];
+			if (
+				ready === false &&
+				command !== "help" &&
+				command !== "unlock" &&
+				command !== "migrate-state"
+			) {
+				ctx.ui.notify(
+					"pi-sync recovery required. Repair the startup error, then /reload before syncing. Use /sync help for recovery guidance.",
+					"error",
+				);
+				return;
+			}
+			const run = () => handleCommand(args, ctx, signal, loaders, attention);
+			// Drain background cache/child cleanup before entering any foreground guard.
+			// Help must remain reachable when the state roots themselves need repair.
+			if (command === "migrate-state" || command === "help") await run();
 			else await withStateDirectoryAccess(run);
 		},
 	});
@@ -121,32 +63,27 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 		sessionAbort = new AbortController();
 		const signal = sessionAbort.signal;
 		attention.reset(ctx);
-		let decision: RemoteSelectionDecision | undefined;
-		try {
-			decision = await withStateDirectoryAccess(() => startSession(ctx, signal, loaders));
-		} catch (error) {
-			if (signal.aborted) return;
-			ctx.ui.notify(`pi-sync state access failed: ${errorMessage(error)}`, "error");
-			return;
-		}
-		if (!decision || signal.aborted) return;
-		attention.set(decision, "sync");
-		if (ctx.mode !== "tui") {
-			ctx.ui.notify(
-				`pi-sync auto sync skipped: ${formatRemoteSelectionMismatch(
-					decision.setupName,
-					decision.localInclude,
-					decision.remoteInclude,
-				)}\nRPC review is read-only.`,
-				"warning",
-			);
-		} else if (attention.markOffered()) {
-			await resolveSelectionAttention(ctx, attention, signal, loaders, {
-				cancelLabel: "Later",
-				withStateAccess: withStateDirectoryAccess,
-			});
-		}
-		if (!signal.aborted) attention.publish(ctx);
+		const previous = initialization;
+		initialization = (async () => {
+			await previous;
+			if (signal.aborted) return false;
+			await check.stop();
+			if (signal.aborted) return false;
+			try {
+				const config = await withStateDirectoryAccess(() => startSession(ctx, signal));
+				return signal.aborted ? false : config;
+			} catch (error) {
+				if (!signal.aborted && ctx.hasUI) {
+					ctx.ui.notify(
+						`pi-sync recovery required: ${safeTerminalText(errorMessage(error))}`,
+						"error",
+					);
+				}
+				return false;
+			}
+		})();
+		const ready = await initialization;
+		if (ready && !signal.aborted) check.start(ctx, signal, ready);
 	});
 
 	pi.on("session_shutdown", async (event, ctx) => {
@@ -159,7 +96,11 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 		const reason =
 			typeof event === "object" && event ? (event as { reason?: string }).reason : undefined;
 		try {
-			if (reason !== "reload") {
+			const ready = await initialization;
+			if (signal.aborted) return;
+			await check.stop();
+			if (signal.aborted) return;
+			if (ready !== false && reason !== "reload") {
 				await withStateDirectoryAccess(async () => {
 					if (signal.aborted) return;
 					await autoPushSessions(ctx, signal, loaders);
@@ -177,589 +118,4 @@ export default function sync(pi: ExtensionAPI, dependencies: Partial<SyncDepende
 	});
 }
 
-async function startSession(ctx: ExtensionContext, signal: AbortSignal, loaders: SyncLoaders) {
-	if (signal.aborted) return;
-	try {
-		const migrationNotice = stateDirectoryMigrationNotice();
-		if (migrationNotice) ctx.ui.notify(migrationNotice, "warning");
-	} catch (error) {
-		ctx.ui.notify(`pi-sync state directory requires attention: ${errorMessage(error)}`, "error");
-		return;
-	}
-	try {
-		await recoverSnapshotTransactionsOnStartup();
-		if (signal.aborted) return;
-	} catch (error) {
-		if (signal.aborted) return;
-		ctx.ui.notify(`pi-sync recovery required: ${errorMessage(error)}`, "error");
-		return;
-	}
-	try {
-		setSyncSetupCompletions(await configuredSyncSetupNames());
-		if (signal.aborted) return;
-	} catch {
-		if (signal.aborted) return;
-		setSyncSetupCompletions([]);
-	}
-	const migrationNotice = consumeLocalConfigMigrationNotice();
-	if (migrationNotice) ctx.ui.notify(migrationNotice, "warning");
-	if (signal.aborted) return;
-	return autoSync(ctx, signal, loaders);
-}
-
-async function handleCommand(
-	rawArgs: string,
-	ctx: ExtensionCommandContext,
-	sessionSignal: AbortSignal,
-	loaders: SyncLoaders,
-	attention: SyncAttentionController,
-) {
-	if (!rawArgs.trim()) {
-		try {
-			const { showSyncManager } = await import("./manager-ui.js");
-			if (sessionSignal.aborted) return;
-			await showSyncManager(
-				ctx,
-				(route, signal, onCommit, target) =>
-					executeCommand(
-						route,
-						ctx,
-						combineSignals(sessionSignal, signal),
-						loaders,
-						onCommit,
-						target,
-					),
-				sessionSignal,
-				{
-					getAttention: () => attention.current(),
-					onSelectionResolved: (expected) => {
-						if (attention.current() === expected) attention.clear(ctx);
-					},
-				},
-			);
-		} catch (error) {
-			if (sessionSignal.aborted) return;
-			ctx.ui.setStatus(STATUS_KEY, undefined);
-			ctx.ui.notify(errorMessage(error), "error");
-		}
-		if (!sessionSignal.aborted) attention.publish(ctx);
-		return;
-	}
-	const result = await executeCommand(rawArgs, ctx, sessionSignal, loaders);
-	if (result.kind === "decision-required") {
-		ctx.ui.notify(result.decision.directMessage, "error");
-	} else if (result.kind === "remote-selection-required") {
-		const origin = directSelectionOrigin(rawArgs);
-		if (origin) attention.set(result.decision, origin);
-		const deterministic = splitArgs(rawArgs).some((arg) => arg === "--yes" || arg === "-y");
-		if (origin && ctx.mode === "tui" && !deterministic) {
-			await resolveSelectionAttention(ctx, attention, sessionSignal, loaders);
-		} else {
-			ctx.ui.notify(
-				formatRemoteSelectionMismatch(
-					result.decision.setupName,
-					result.decision.localInclude,
-					result.decision.remoteInclude,
-				),
-				"error",
-			);
-		}
-	}
-	await clearAttentionAfterCompletedOperation(rawArgs, result, ctx, attention, sessionSignal);
-	await reconcileSelectionAttention(ctx, attention, sessionSignal);
-	if (!sessionSignal.aborted) attention.publish(ctx);
-}
-
-async function clearAttentionAfterCompletedOperation(
-	rawArgs: string,
-	result: RunRouteResult,
-	ctx: ExtensionContext,
-	attention: SyncAttentionController,
-	signal: AbortSignal,
-) {
-	if (result.kind !== "completed" || result.outcome === "cancelled" || signal.aborted) return;
-	const [command, ...rest] = splitArgs(rawArgs);
-	if (command !== "sync" && command !== "pull" && command !== "push") return;
-	const current = attention.current();
-	if (!current) return;
-	try {
-		const options = parseOptions(rest);
-		const setupName = options.setup ?? (await loadConfig()).setupName;
-		if (signal.aborted || attention.current() !== current) return;
-		if (current.decision.setupName === setupName) attention.clear(ctx);
-	} catch {
-		// Attention reconciliation below owns malformed or concurrently changed settings.
-	}
-}
-
-async function reconcileSelectionAttention(
-	ctx: ExtensionContext,
-	attention: SyncAttentionController,
-	signal: AbortSignal,
-) {
-	const current = attention.current();
-	if (!current || signal.aborted) return;
-	try {
-		const config = await loadConfig(current.decision.setupName);
-		if (signal.aborted || attention.current() !== current) return;
-		if (!syncAttentionMatchesConfig(current, config)) attention.clear(ctx);
-	} catch {
-		if (!signal.aborted && attention.current() === current) attention.clear(ctx);
-	}
-}
-
-function directSelectionOrigin(rawArgs: string): SyncAttentionOrigin | undefined {
-	const command = splitArgs(rawArgs)[0];
-	return command === "sync" || command === "pull" || command === "push" ? command : undefined;
-}
-
-async function resolveSelectionAttention(
-	ctx: ExtensionContext,
-	attention: SyncAttentionController,
-	signal: AbortSignal,
-	loaders: SyncLoaders,
-	options: {
-		cancelLabel?: string;
-		withStateAccess?: <T>(task: () => Promise<T>) => Promise<T>;
-	} = {},
-) {
-	const current = attention.current();
-	if (!current || signal.aborted) return;
-	const { dispatchManagerResult } = await import("./manager-result-dispatcher.js");
-	if (signal.aborted || attention.current() !== current) return;
-	await dispatchManagerResult(
-		ctx,
-		{ kind: "remote-selection-required", decision: current.decision },
-		current.origin,
-		(route, actionSignal, onCommit, target) => {
-			const execute = () =>
-				executeRecoveryCommand(
-					route,
-					ctx,
-					combineSignals(signal, actionSignal),
-					loaders,
-					onCommit,
-					target,
-				);
-			return options.withStateAccess ? options.withStateAccess(execute) : execute();
-		},
-		signal,
-		{
-			cancelLabel: options.cancelLabel,
-			withStateAccess: options.withStateAccess,
-			onSelectionResolved: () => {
-				if (attention.current() === current) attention.clear(ctx);
-			},
-		},
-	);
-}
-
-async function executeRecoveryCommand(
-	rawArgs: string,
-	ctx: ExtensionContext,
-	signal: AbortSignal | undefined,
-	loaders: SyncLoaders,
-	onCommit?: () => void,
-	setup?: string,
-): Promise<RunRouteResult> {
-	try {
-		const [subcommand, ...rest] = splitArgs(rawArgs);
-		if (subcommand !== "sync" && subcommand !== "pull" && subcommand !== "push") {
-			throw new Error(`Unsupported sync recovery route: ${subcommand ?? "missing"}`);
-		}
-		const options = parseOptions(rest);
-		if (setup !== undefined) options.setup = setup;
-		if (signal) options.signal = signal;
-		if (onCommit) options.onCommit = onCommit;
-		options.reload = false;
-		options.auto = false;
-		validateCommandOptions(subcommand, options);
-		const operations = await loaders.operations();
-		throwIfAborted(options.signal);
-		if (subcommand === "push") {
-			const outcome = await withLock("push", () => operations.push(ctx, options));
-			return { kind: "completed", ...(outcome ? { outcome } : {}) };
-		}
-		if (subcommand === "pull") {
-			const outcome = await withLock("pull", () => operations.pull(ctx, options));
-			return { kind: "completed", ...(outcome ? { outcome } : {}) };
-		}
-		await withLock("sync", () => operations.syncBoth(ctx, options));
-		return { kind: "completed" };
-	} catch (error) {
-		if (signal?.aborted) return { kind: "failed" };
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-		if (error instanceof RemoteSelectionMismatchError) {
-			return { kind: "remote-selection-required", decision: error.decision };
-		}
-		if (isSyncDecisionRequiredError(error)) {
-			return { kind: "decision-required", decision: error.decision };
-		}
-		ctx.ui.notify(errorMessage(error), "error");
-		return { kind: "failed" };
-	}
-}
-
-async function executeCommand(
-	rawArgs: string,
-	ctx: ExtensionCommandContext,
-	signal: AbortSignal | undefined,
-	loaders: SyncLoaders,
-	onCommit?: () => void,
-	setup?: string,
-): Promise<RunRouteResult> {
-	try {
-		const command = await resolveSyncCommand(rawArgs, ctx);
-		if (signal?.aborted || !command) return { kind: "completed" };
-		const { subcommand, rest } = command;
-		const options = parseOptions(rest);
-		if (setup !== undefined) options.setup = setup;
-		if (signal) options.signal = signal;
-		if (onCommit) options.onCommit = onCommit;
-		validateCommandOptions(subcommand, options);
-
-		switch (subcommand) {
-			case "help":
-				ctx.ui.notify(usage(), "info");
-				return { kind: "completed" };
-			case "use": {
-				const { useSyncSetup } = await loaders.setupSwitch();
-				throwIfAborted(options.signal);
-				await useSyncSetup(
-					ctx,
-					options.args[0] ?? "",
-					async (selectedSetup) => {
-						const operations = await loaders.operations();
-						throwIfAborted(options.signal);
-						return withLock("pull", () =>
-							operations.pull(ctx, { ...options, setup: selectedSetup }),
-						);
-					},
-					undefined,
-					options.signal,
-				);
-				return { kind: "completed" };
-			}
-			case "init":
-				await initConfig(ctx, signal);
-				return { kind: "completed" };
-			case "config":
-				await showConfig(ctx, options);
-				return { kind: "completed" };
-			case "files": {
-				const { showFileSelection } = await import("./file-selection.js");
-				throwIfAborted(options.signal);
-				await showFileSelection(ctx, options.setup, options.signal);
-				return { kind: "completed" };
-			}
-			case "status": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				await operations.status(ctx, options);
-				return { kind: "completed" };
-			}
-			case "diff": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				await operations.diff(ctx, options);
-				return { kind: "completed" };
-			}
-			case "doctor": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				await operations.doctor(ctx, options);
-				return { kind: "completed" };
-			}
-			case "push": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				const outcome = await withLock("push", () => operations.push(ctx, options));
-				return { kind: "completed", ...(outcome ? { outcome } : {}) };
-			}
-			case "pull": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				const outcome = await withLock("pull", () => operations.pull(ctx, options));
-				return { kind: "completed", ...(outcome ? { outcome } : {}) };
-			}
-			case "sync": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				await withLock("sync", () => operations.syncBoth(ctx, options));
-				return { kind: "completed" };
-			}
-			case "history": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				await operations.history(ctx, options);
-				return { kind: "completed" };
-			}
-			case "rollback": {
-				const operations = await loaders.operations();
-				throwIfAborted(options.signal);
-				await withLock("rollback", () => operations.rollback(ctx, options));
-				return { kind: "completed" };
-			}
-			case "migrate-state":
-				await migrateStateDirectory(ctx, options);
-				return { kind: "completed" };
-			case "unlock":
-				await unlock(ctx, options);
-				return { kind: "completed" };
-			default:
-				ctx.ui.notify(`Unknown /sync command: ${subcommand}\n\n${usage()}`, "warning");
-				return { kind: "failed" };
-		}
-	} catch (error) {
-		if (signal?.aborted) return { kind: "failed" };
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-		if (error instanceof SetupPullRequiresUiError) throw error;
-		if (error instanceof RemoteSelectionMismatchError) {
-			return { kind: "remote-selection-required", decision: error.decision };
-		}
-		if (isSyncDecisionRequiredError(error)) {
-			return { kind: "decision-required", decision: error.decision };
-		}
-		ctx.ui.notify(errorMessage(error), "error");
-		return { kind: "failed" };
-	}
-}
-
-async function migrateStateDirectory(ctx: ExtensionCommandContext, options: CommandOptions) {
-	const notice = stateDirectoryMigrationNotice();
-	if (!notice) {
-		ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
-		return;
-	}
-	if (
-		!options.yes &&
-		!(await ctx.ui.confirm(
-			"Migrate pi-sync state directory",
-			"Confirm that every other Pi process is closed. pi-sync will atomically rename .pisync/ to pi-sync/ without merging or deleting either root.",
-			{ signal: options.signal },
-		))
-	) {
-		ctx.ui.notify("pi-sync state migration cancelled.", "info");
-		return;
-	}
-	throwIfAborted(options.signal);
-	const result = await migrateLegacyStateDirectory();
-	throwIfAborted(options.signal);
-	if (result.status === "ready") {
-		ctx.ui.notify("pi-sync already uses the canonical pi-sync/ state directory.", "info");
-		return;
-	}
-	ctx.ui.notify(result.message, result.status === "migrated" ? "info" : "warning");
-}
-
-async function autoSync(
-	ctx: ExtensionContext,
-	signal: AbortSignal,
-	loaders: SyncLoaders,
-): Promise<RemoteSelectionDecision | undefined> {
-	try {
-		const partial = await loadPartialConfig();
-		throwIfAborted(signal);
-		if (!partial.automatic) return;
-		await ensureStateDir();
-		throwIfAborted(signal);
-		await loadConfig();
-		throwIfAborted(signal);
-		const operations = await loaders.operations();
-		throwIfAborted(signal);
-		await withLock("auto-sync", () => {
-			throwIfAborted(signal);
-			return operations.syncBoth(ctx, { ...AUTO_SYNC_OPTIONS, signal });
-		});
-	} catch (error) {
-		if (signal.aborted || isMissingConfigError(error)) return;
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-		if (error instanceof RemoteSelectionMismatchError) return error.decision;
-		ctx.ui.notify(`pi-sync auto sync skipped: ${errorMessage(error)}`, "warning");
-	}
-}
-
-async function autoPushSessions(ctx: ExtensionContext, signal: AbortSignal, loaders: SyncLoaders) {
-	try {
-		const partial = await loadPartialConfig();
-		throwIfAborted(signal);
-		if (!partial.automatic) return;
-		if (!partial.include.includes("sessions")) return;
-		await ensureStateDir();
-		throwIfAborted(signal);
-		const config = await loadConfig();
-		throwIfAborted(signal);
-		if (!config.include.includes("sessions")) return;
-		const [operations, snapshotModule, syncStateModule] = await Promise.all([
-			loaders.operations(),
-			loaders.snapshot(),
-			loaders.syncState(),
-		]);
-		throwIfAborted(signal);
-		await withLock("auto-session-push", async () => {
-			throwIfAborted(signal);
-			const state = await readStateForConfig(config);
-			throwIfAborted(signal);
-			const local = await snapshotModule.createSnapshot(
-				config.snapshotIdentity,
-				snapshotOptionsForContext(ctx, config),
-			);
-			throwIfAborted(signal);
-			if (!syncStateModule.hasLocalChanges(local, state, config)) return;
-			await operations.push(ctx, { ...AUTO_SYNC_OPTIONS, signal }, { config, state, local });
-		});
-	} catch (error) {
-		if (signal.aborted || isMissingConfigError(error)) return;
-		ctx.ui.setStatus(STATUS_KEY, undefined);
-		ctx.ui.notify(`pi-sync session push skipped: ${errorMessage(error)}`, "warning");
-	}
-}
-
-async function initConfig(ctx: ExtensionCommandContext, signal?: AbortSignal) {
-	const configPath = localConfigPath();
-	if (await readLocalConfigObject()) {
-		ctx.ui.notify(`Config already exists: ${await activeLocalConfigPath()}`, "info");
-		return;
-	}
-
-	if (ctx.mode === "tui") {
-		const { showSetupWizard } = await import("./manager-ui.js");
-		throwIfAborted(signal);
-		await showSetupWizard(ctx, signal);
-		return;
-	}
-	await createLocalConfigDocument(localConfigTemplate());
-	ctx.ui.notify(
-		`Created ${configPath}. Add a storage connection and sync setup before syncing.`,
-		"info",
-	);
-}
-
-async function showConfig(ctx: ExtensionCommandContext, options: CommandOptions) {
-	const config = await loadConfig(options.setup);
-	const warnings = [
-		...(config.backend.type === "s3" ? sessionTokenWarnings(config.backend.profile) : []),
-		...syncSessionsWarnings(config),
-	];
-	const storageLines = configStorageLines(config);
-	ctx.ui.notify(
-		[
-			"pi-sync config:",
-			`sync setup: ${config.setupName}`,
-			`storage connection: ${config.connectionName}`,
-			...storageLines,
-			`storage path: ${config.storagePath}`,
-			`automatic sync: ${config.automatic ? "enabled" : "disabled"}`,
-			`included content: ${config.include.join(", ") || "none"}`,
-			`sessions: ${config.include.includes("sessions") ? "included" : "not included"}`,
-			`settings file: ${localConfigPath()}`,
-			...warnings,
-		].join("\n"),
-		warnings.length > 0 ? "warning" : "info",
-	);
-}
-
-function configStorageLines(config: AnySyncConfig) {
-	switch (config.backend.type) {
-		case "git":
-			return [
-				"kind: git",
-				`remote: ${displayGitRemote(config.backend.profile.remote)}`,
-				"authentication: existing Git/SSH credentials (not stored)",
-				`branch: ${config.backend.destination.branch}`,
-			];
-		case "webdav":
-			return [
-				"kind: webdav",
-				`url: ${displayWebDavUrl(config.backend.profile.url, config.backend.profile.username)}`,
-				"username: configured (value hidden)",
-				"password: configured",
-			];
-		case "s3":
-			return [
-				"kind: s3",
-				`endpoint: ${config.backend.profile.endpoint}`,
-				`bucket: ${config.backend.destination.bucket}`,
-				`region: ${config.backend.profile.region}`,
-				"access key id: configured",
-				"secret access key: configured",
-				`session token: ${config.backend.profile.sessionToken ? "configured" : "not configured"}`,
-			];
-	}
-}
-
-function displayGitRemote(value: string | undefined) {
-	if (!value) return "missing";
-	try {
-		const url = new URL(value);
-		url.username = "";
-		url.password = "";
-		url.search = "";
-		url.hash = "";
-		return url.toString();
-	} catch {
-		return value.replace(/^(?:[^@\s]+@)?(?<host>[^:]+):.+$/u, "$<host>:…");
-	}
-}
-
-function displayWebDavUrl(value: string | undefined, username: string | undefined) {
-	if (!value) return "missing";
-	try {
-		const url = new URL(value);
-		url.username = "";
-		url.password = "";
-		url.search = "";
-		url.hash = "";
-		return username ? `${url.origin}/…` : `${url.origin}${url.pathname}`;
-	} catch {
-		return "invalid (value hidden)";
-	}
-}
-
-function throwIfAborted(signal?: AbortSignal) {
-	if (!signal?.aborted) return;
-	throw signal.reason instanceof Error
-		? signal.reason
-		: new DOMException("The operation was aborted", "AbortError");
-}
-
-function combineSignals(primary: AbortSignal, secondary?: AbortSignal) {
-	return secondary ? AbortSignal.any([primary, secondary]) : primary;
-}
-
-function snapshotOptionsForContext(
-	ctx: ExtensionCommandContext | ExtensionContext,
-	config: AnySyncConfig,
-): SnapshotOptions {
-	return {
-		include: config.include,
-		sessionDir: sessionDirFromContext(ctx),
-	};
-}
-
-function sessionDirFromContext(ctx: ExtensionCommandContext | ExtensionContext) {
-	const manager = ctx.sessionManager as typeof ctx.sessionManager & {
-		usesDefaultSessionDir?: () => boolean;
-	};
-	const usesDefaultSessionDir = manager.usesDefaultSessionDir;
-	if (typeof usesDefaultSessionDir === "function" && usesDefaultSessionDir.call(manager)) {
-		return undefined;
-	}
-	const getSessionDir = manager.getSessionDir;
-	return typeof getSessionDir === "function"
-		? (getSessionDir.call(manager) as string | undefined)
-		: undefined;
-}
-
-function cachedModuleLoader<Module>(load: () => Promise<Module>): () => Promise<Module> {
-	let pending: Promise<Module> | undefined;
-	return () => {
-		if (!pending) {
-			pending = load().catch((error) => {
-				pending = undefined;
-				throw error;
-			});
-		}
-		return pending;
-	};
-}
+export type { SyncDependencies } from "./sync/sync-loaders.js";