@narumitw/pi-sync 0.49.6 → 0.49.9

package/src/manager-state.ts

@@ -1,3 +1,4 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
 import {
 	activeLocalConfigPath,
 	isCloudflareR2Endpoint,
@@ -5,9 +6,15 @@ import {
 	readLocalConfigObject,
 	readStateForConfig,
 } from "./config.js";
-import { inspectLock, isStaleLock } from "./lock.js";
 import { errorMessage, ownRecord, safeTerminalText } from "./manager-helpers.js";
-import { syncIncludeSelection } from "./sync-policy.js";
+import {
+	inspectOperationAvailability,
+	type OperationAvailability,
+	operationBlocksChanges,
+	operationCanRecover,
+} from "./operation-availability.js";
+import { type SyncAttentionState, syncAttentionMatchesConfig } from "./sync-attention.js";
+import { compareSyncInclude, syncIncludeSelection } from "./sync-policy.js";
 import { countValidSyncSetups } from "./sync-setups-ui.js";
 import type { AnySyncConfig } from "./types.js";
 
@@ -19,9 +26,20 @@ export const MAIN_MENU_ACTIONS = [
 	"More…",
 ] as const;
 
+export interface ManagerDescription {
+	title: string;
+	actions: string[];
+	operation?: OperationAvailability;
+	attention?: SyncAttentionState;
+	attentionBlocksSync?: boolean;
+	attentionReviewDisabled?: boolean;
+}
+
 export async function describeManagerState(
 	signal?: AbortSignal,
-): Promise<{ title: string; actions: string[] }> {
+	attention?: SyncAttentionState,
+	inspectOperation: () => Promise<OperationAvailability> = inspectOperationAvailability,
+): Promise<ManagerDescription> {
 	let raw: Record<string, unknown> | undefined;
 	try {
 		raw = await readLocalConfigObject();
@@ -61,62 +79,86 @@ export async function describeManagerState(
 	}
 	try {
 		const config = await loadConfig();
-		const lock = await inspectLock();
-		const liveLock = lock.status === "valid" && !isStaleLock(lock.lock);
-		const recoverableLock =
-			lock.status === "unreadable" || (lock.status === "valid" && isStaleLock(lock.lock));
+		const operation = await inspectOperation();
+		const changesBlocked = operationBlocksChanges(operation);
 		const selection = syncIncludeSelection(config.include);
+		let currentAttention: SyncAttentionState | undefined;
+		if (attention) {
+			try {
+				const attentionConfig =
+					attention.decision.setupName === config.setupName
+						? config
+						: await loadConfig(attention.decision.setupName);
+				if (syncAttentionMatchesConfig(attention, attentionConfig)) currentAttention = attention;
+			} catch {
+				currentAttention = undefined;
+			}
+			if (signal?.aborted) throw signal.reason;
+		}
+		const attentionComparison = currentAttention
+			? compareSyncInclude(
+					currentAttention.decision.localInclude,
+					currentAttention.decision.remoteInclude,
+				)
+			: undefined;
 		const noSyncedContent = config.include.length === 0;
-		const syncState =
-			liveLock || recoverableLock
-				? undefined
-				: await readStateForConfig(config).catch(() => undefined);
-		const lastAppliedSnapshot =
-			liveLock || recoverableLock
-				? "Unavailable while operations are locked"
-				: syncState?.lastAppliedSnapshot
-					? safeTerminalText(syncState.lastAppliedSnapshot)
-					: syncState
-						? "Never synced"
-						: "Unavailable";
+		const syncState = changesBlocked
+			? undefined
+			: await readStateForConfig(config).catch(() => undefined);
+		const lastAppliedSnapshot = changesBlocked
+			? "Unavailable while operations are locked"
+			: syncState?.lastAppliedSnapshot
+				? safeTerminalText(syncState.lastAppliedSnapshot)
+				: syncState
+					? "Never synced"
+					: "Unavailable";
 		const canSwitch = (await countValidSyncSetups(configuredTargets, signal)) > 1;
 		const mainActions = MAIN_MENU_ACTIONS.filter(
 			(action) => action !== "Switch sync setup" || canSwitch,
 		);
+		const ordinaryTitle = [
+			"Manage sync",
+			"",
+			`Current sync setup: ${safeTerminalText(config.setupName)}`,
+			`Storage: ${backendStorageDescription(config)}`,
+			`Included: ${selection.builtIns.length} built-in group${selection.builtIns.length === 1 ? "" : "s"} · ${selection.custom.length} extra path${selection.custom.length === 1 ? "" : "s"} · Sessions ${selection.sessions ? "on" : "off"}`,
+			`Automatic sync: ${config.automatic ? "On" : "Off"}`,
+			`Last applied: ${lastAppliedSnapshot}`,
+			...(currentAttention
+				? [
+						currentAttention.decision.setupName === config.setupName
+							? "Sync status: Review needed"
+							: `Sync status: Review needed for setup ${safeTerminalText(currentAttention.decision.setupName)}`,
+						attentionComparison?.remoteOnly.length === 0 &&
+						attentionComparison.localOnly.length === 0
+							? "Only the synced-content order differs."
+							: `Remote-only paths: ${attentionComparison?.remoteOnly.length ?? 0} · Device-only paths: ${attentionComparison?.localOnly.length ?? 0}`,
+						"Nothing has been changed.",
+					]
+				: ["Remote status: Not checked"]),
+			...(noSyncedContent
+				? [
+						"",
+						"No included content is selected. Choose included content in Settings before syncing.",
+					]
+				: []),
+			"",
+			"What do you want to do?",
+		];
 		return {
-			title: [
-				"Manage sync",
-				"",
-				`Current sync setup: ${safeTerminalText(config.setupName)}`,
-				`Storage: ${backendStorageDescription(config)}`,
-				`Included: ${selection.builtIns.length} built-in group${selection.builtIns.length === 1 ? "" : "s"} · ${selection.custom.length} extra path${selection.custom.length === 1 ? "" : "s"} · Sessions ${selection.sessions ? "on" : "off"}`,
-				`Automatic sync: ${config.automatic ? "On" : "Off"}`,
-				`Last applied: ${lastAppliedSnapshot}`,
-				"Remote status: Not checked",
-				...(noSyncedContent
-					? [
-							"",
-							"No included content is selected. Choose included content in Settings before syncing.",
-						]
-					: []),
-				...(liveLock
-					? [
-							"",
-							`Operation in progress: ${safeTerminalText(lock.lock.command)} (pid ${lock.lock.pid}). Sync and settings changes are disabled.`,
-						]
-					: []),
-				...(recoverableLock
-					? ["", "Recovery required: lock metadata is stale or unreadable."]
-					: []),
-				"",
-				"What do you want to do?",
-			].join("\n"),
-			actions:
-				liveLock || recoverableLock
-					? ["Status & changes", "History & recovery…", "Help"]
-					: noSyncedContent
-						? ["Settings", ...(canSwitch ? ["Switch sync setup"] : []), "Status & changes", "More…"]
-						: mainActions,
+			title: (changesBlocked
+				? ["Manage sync", ...operationStatusLines(operation)]
+				: ordinaryTitle
+			).join("\n"),
+			actions: operationActions(operation, noSyncedContent, canSwitch, mainActions),
+			operation,
+			...(currentAttention
+				? {
+						attention: currentAttention,
+						attentionBlocksSync: currentAttention.decision.setupName === config.setupName,
+						attentionReviewDisabled: changesBlocked,
+					}
+				: {}),
 		};
 	} catch (error) {
 		if (signal?.aborted) throw error;
@@ -136,6 +178,57 @@ export async function describeManagerState(
 	}
 }
 
+function operationActions(
+	operation: OperationAvailability,
+	noSyncedContent: boolean,
+	canSwitch: boolean,
+	mainActions: string[],
+) {
+	if (operationCanRecover(operation)) {
+		return [
+			"Restore sync access… (recommended)",
+			"Status & changes",
+			"History & recovery…",
+			"Help",
+		];
+	}
+	if (operation.kind !== "free") {
+		return ["Refresh operation status", "Status & changes", "History & recovery…", "Help"];
+	}
+	return noSyncedContent
+		? ["Settings", ...(canSwitch ? ["Switch sync setup"] : []), "Status & changes", "More…"]
+		: mainActions;
+}
+
+function operationStatusLines(operation: OperationAvailability): string[] {
+	switch (operation.kind) {
+		case "free":
+			return [];
+		case "live": {
+			const command = truncateToWidth(safeTerminalText(operation.lock.command), 16, "…");
+			return [
+				`Running: ${command} (pid ${operation.lock.pid}). Wait, then refresh; Settings and More return.`,
+			];
+		}
+		case "busy":
+			return [
+				"Pi-sync may be starting or finishing. Wait, then refresh; Settings and More remain unavailable.",
+			];
+		case "recoverable-stale":
+			return [
+				"Sync paused: old lock remains. Close other Pi sessions then restore; Settings and More return.",
+			];
+		case "recoverable-unreadable":
+			return [
+				"Sync paused: owner unknown. Close other Pi sessions then restore; Settings and More return.",
+			];
+		case "inspection-error":
+			return [
+				"Lock check failed. Fix path access, then refresh; Settings and More remain unavailable.",
+			];
+	}
+}
+
 export function backendStorageDescription(config: AnySyncConfig) {
 	const connection = safeTerminalText(config.connectionName);
 	switch (config.backend.type) {

package/src/manager-ui.ts

@@ -1,10 +1,6 @@
 import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { type ActionMenuItem, defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import {
-	type CancellableOperationResult,
-	type RunRoute,
-	runCancellableOperation,
-} from "./cancellable-operation.js";
+import { type RunRoute, runCancellableOperation } from "./cancellable-operation.js";
 import { setSyncSetupCompletions } from "./command.js";
 import {
 	configuredSyncSetupNames,
@@ -17,7 +13,12 @@ import {
 	syncConfigReviewIdentity,
 } from "./config.js";
 import { showAddGitTarget, showEditGitTarget, showGitSetup } from "./git-ui.js";
-import { inspectLock, isStaleLock } from "./lock.js";
+import {
+	attentionMainMenuItems,
+	blockedSyncMenuItem,
+	type SyncManagerAttentionOptions,
+	showManagerAttention,
+} from "./manager-attention.js";
 import {
 	errorMessage,
 	ownRecord,
@@ -25,7 +26,10 @@ import {
 	requiredInput,
 	safeTerminalText,
 } from "./manager-helpers.js";
+import { recoverSyncAccess } from "./manager-recovery.js";
+import { dispatchManagerResult } from "./manager-result-dispatcher.js";
 import { backendStorageDescription, describeManagerState } from "./manager-state.js";
+import { operationCanRecover } from "./operation-availability.js";
 import { chooseS3Credentials } from "./s3-credentials-ui.js";
 import {
 	addSyncSetup,
@@ -37,7 +41,6 @@ import { showSyncSettings } from "./settings-ui.js";
 import { useSyncSetup } from "./setup-switch.js";
 import { showAddStorageConnection, showStorageConnections } from "./storage-connections-ui.js";
 import { DEFAULT_SYNC_INCLUDE, syncIncludeSelection } from "./sync-policy.js";
-import { showSyncResolution } from "./sync-resolution-ui.js";
 import { showSyncSetups } from "./sync-setups-ui.js";
 import type { AnySyncConfig } from "./types.js";
 import { showAddWebDavTarget, showEditWebDavTarget, showWebDavSetup } from "./webdav-ui.js";
@@ -46,6 +49,7 @@ export async function showSyncManager(
 	ctx: ExtensionCommandContext,
 	runRoute: RunRoute,
 	sessionSignal?: AbortSignal,
+	options: SyncManagerAttentionOptions = {},
 ): Promise<void> {
 	if (!ctx.hasUI) {
 		await runRoute("help");
@@ -53,6 +57,7 @@ export async function showSyncManager(
 	}
 	type Screen = "main" | "more" | "recovery";
 	type Action =
+		| "review-attention"
 		| "sync"
 		| "switch"
 		| "diff"
@@ -64,23 +69,34 @@ export async function showSyncManager(
 		| "history"
 		| "doctor"
 		| "unlock"
+		| "recover"
+		| "refresh"
 		| "help"
 		| "init"
 		| "back";
 	interface State {
 		manager: Awaited<ReturnType<typeof describeManagerState>>;
-		canRecover: boolean;
 	}
 	const menu = defineMenu<State, Screen, Action, ExtensionCommandContext>({
 		start: "main",
 		screens: {
-			main: ({ state }) => ({
-				kind: "actions",
-				title: "Manage sync",
-				lines: state.manager.title.split("\n").slice(1),
-				items: state.manager.actions.map(syncMainMenuItem),
-				hint: "close",
-			}),
+			main: ({ state }) => {
+				const attentionItems = attentionMainMenuItems(state.manager);
+				const managerItems = state.manager.actions.map(
+					(label) => blockedSyncMenuItem(label, state.manager) ?? syncMainMenuItem(label),
+				);
+				const operationFirst =
+					state.manager.operation !== undefined && state.manager.operation.kind !== "free";
+				return {
+					kind: "actions",
+					title: "Manage sync",
+					lines: state.manager.title.split("\n").slice(1),
+					items: operationFirst
+						? [...managerItems, ...attentionItems]
+						: [...attentionItems, ...managerItems],
+					hint: "close",
+				};
+			},
 			more: () => ({
 				kind: "actions",
 				title: "More options",
@@ -105,7 +121,7 @@ export async function showSyncManager(
 				items: [
 					{ id: "history", label: "Browse history", action: "history" },
 					{ id: "doctor", label: "Check setup", action: "doctor" },
-					...(state.canRecover
+					...(state.manager.operation && operationCanRecover(state.manager.operation)
 						? [{ id: "unlock", label: "Recover stale operation", action: "unlock" as const }]
 						: []),
 					{ id: "back", label: "Back", action: "back" },
@@ -114,7 +130,28 @@ export async function showSyncManager(
 			}),
 		},
 		actions: {
+			"review-attention": async () => {
+				const attention = options.getAttention?.();
+				if (!attention) return { kind: "stay" };
+				const disposition = await showManagerAttention(
+					ctx,
+					attention,
+					runRoute,
+					sessionSignal,
+					() => options.onSelectionResolved?.(attention),
+				);
+				return { kind: disposition };
+			},
 			sync: async () => {
+				const pendingAttention = options.getAttention?.();
+				if (pendingAttention) {
+					const activeConfig = await loadConfig();
+					if (sessionSignal?.aborted) return { kind: "close" };
+					if (pendingAttention.decision.setupName === activeConfig.setupName) {
+						ctx.ui.notify("Review synced content before starting Sync now.", "warning");
+						return { kind: "stay" };
+					}
+				}
 				const result = await runCancellableOperation(
 					ctx,
 					"Checking current sync setup…",
@@ -125,10 +162,14 @@ export async function showSyncManager(
 						signal: sessionSignal,
 					},
 				);
-				const resolution = await resolveManagerDecision(ctx, result, runRoute, sessionSignal);
-				return result.kind === "closed" || resolution === "close"
-					? { kind: "close" }
-					: { kind: "stay" };
+				const disposition = await dispatchManagerResult(
+					ctx,
+					result,
+					"sync",
+					runRoute,
+					sessionSignal,
+				);
+				return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
 			},
 			switch: async () => {
 				const result = await showSetupSwitcher(ctx, runRoute, undefined, sessionSignal);
@@ -162,12 +203,14 @@ export async function showSyncManager(
 						signal: sessionSignal,
 					},
 				);
-				const resolution = await resolveManagerDecision(ctx, result, runRoute, sessionSignal);
-				return result.kind === "closed" ||
-					(result.kind === "completed" && result.outcome === "applied") ||
-					resolution === "close"
-					? { kind: "close" }
-					: { kind: "stay" };
+				const disposition = await dispatchManagerResult(
+					ctx,
+					result,
+					"pull",
+					runRoute,
+					sessionSignal,
+				);
+				return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
 			},
 			push: async () => {
 				const result = await runCancellableOperation(
@@ -181,10 +224,14 @@ export async function showSyncManager(
 						signal: sessionSignal,
 					},
 				);
-				const resolution = await resolveManagerDecision(ctx, result, runRoute, sessionSignal);
-				return result.kind === "closed" || resolution === "close"
-					? { kind: "close" }
-					: { kind: "stay" };
+				const disposition = await dispatchManagerResult(
+					ctx,
+					result,
+					"push",
+					runRoute,
+					sessionSignal,
+				);
+				return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
 			},
 			setups: async () => {
 				const result = await showSyncSetupManager(ctx, runRoute, sessionSignal);
@@ -202,10 +249,28 @@ export async function showSyncManager(
 				await runRoute("doctor");
 				return { kind: "stay" };
 			},
-			unlock: async () => {
-				await runRoute("unlock --stale");
-				return { kind: "stay" };
+			unlock: async ({ state, signal: actionSignal }) => {
+				const result = await recoverSyncAccess(
+					ctx,
+					state.manager,
+					runRoute,
+					sessionSignal,
+					actionSignal,
+				);
+				if (result === "close") return { kind: "close" };
+				return result === "restored" ? { kind: "to", screen: "main" } : { kind: "stay" };
 			},
+			recover: async ({ state, signal: actionSignal }) => {
+				const result = await recoverSyncAccess(
+					ctx,
+					state.manager,
+					runRoute,
+					sessionSignal,
+					actionSignal,
+				);
+				return { kind: result === "close" ? "close" : "stay" };
+			},
+			refresh: async () => ({ kind: "stay" }),
 			help: async () => {
 				await runRoute("help");
 				return { kind: "close" };
@@ -219,52 +284,54 @@ export async function showSyncManager(
 	});
 	await runMenu(ctx, menu, {
 		getState: async () => {
-			const [manager, lock] = await Promise.all([
-				describeManagerState(sessionSignal),
-				inspectLock(),
-			]);
-			return {
-				manager,
-				canRecover:
-					lock.status === "unreadable" || (lock.status === "valid" && isStaleLock(lock.lock)),
-			};
+			const pendingAttention = options.getAttention?.();
+			const manager = await describeManagerState(sessionSignal, pendingAttention);
+			if (pendingAttention && options.getAttention?.() === pendingAttention && !manager.attention) {
+				options.onSelectionResolved?.(pendingAttention);
+			}
+			return { manager };
 		},
 		signal: sessionSignal,
 		isCurrent: () => !sessionSignal?.aborted,
 	});
 }
 
-async function resolveManagerDecision(
-	ctx: ExtensionCommandContext,
-	result: CancellableOperationResult,
-	runRoute: RunRoute,
-	signal?: AbortSignal,
-) {
-	if (result.kind !== "decision-required") return undefined;
-	const resolution = await showSyncResolution(ctx, result.decision, runRoute, signal);
-	return resolution.kind === "resolved" ||
-		resolution.kind === "closed" ||
-		resolution.kind === "stale"
-		? "close"
-		: "stay";
-}
-
 function syncMainMenuItem(
 	label: string,
 ): ActionMenuItem<
 	"main" | "more" | "recovery",
-	"sync" | "switch" | "diff" | "settings" | "setups" | "connections" | "help" | "init"
+	| "sync"
+	| "switch"
+	| "diff"
+	| "settings"
+	| "setups"
+	| "connections"
+	| "recover"
+	| "refresh"
+	| "help"
+	| "init"
 > {
 	if (label === "More…") return { id: "more", label, to: "more" };
 	if (label === "History & recovery…") return { id: "recovery", label, to: "recovery" };
 	const actions = new Map<
 		string,
-		"sync" | "switch" | "diff" | "settings" | "setups" | "connections" | "help" | "init"
+		| "sync"
+		| "switch"
+		| "diff"
+		| "settings"
+		| "setups"
+		| "connections"
+		| "recover"
+		| "refresh"
+		| "help"
+		| "init"
 	>([
 		["Sync now (recommended)", "sync"],
 		["Switch sync setup", "switch"],
 		["Status & changes", "diff"],
 		["Settings", "settings"],
+		["Restore sync access… (recommended)", "recover"],
+		["Refresh operation status", "refresh"],
 		["Sync setups…", "setups"],
 		["Storage connections…", "connections"],
 		["Help", "help"],
@@ -553,23 +620,11 @@ async function showSetupSwitcher(
 						signal,
 					},
 				);
-				if (pullResult.kind === "closed") {
-					pullClosed = true;
-					return undefined;
-				}
-				if (pullResult.kind === "decision-required") {
-					const resolution = await showSyncResolution(ctx, pullResult.decision, runRoute, signal);
-					if (
-						resolution.kind === "resolved" ||
-						resolution.kind === "closed" ||
-						resolution.kind === "stale"
-					) {
-						pullClosed = true;
-					}
-					return resolution.kind === "resolved" && resolution.direction === "pull"
-						? "applied"
-						: undefined;
+				const disposition = await dispatchManagerResult(ctx, pullResult, "pull", runRoute, signal);
+				if (pullResult.kind === "closed" || pullResult.kind.endsWith("required")) {
+					pullClosed = disposition.kind === "close";
 				}
+				if (disposition.appliedRoute === "pull") return "applied";
 				if (pullResult.kind === "completed") return pullResult.outcome;
 				return pullResult.kind === "cancelled" ? "cancelled" : undefined;
 			},

package/src/operation-availability.ts

@@ -0,0 +1,64 @@
+import { inspectLock, isLockGuardHeld, isStaleLock, type LockInspection } from "./lock.js";
+import { errorMessage } from "./manager-helpers.js";
+import type { LockFile } from "./types.js";
+
+export type OperationAvailability =
+	| { kind: "free" }
+	| { kind: "live"; lock: LockFile }
+	| { kind: "busy"; lock?: LockFile; metadata: LockInspection["status"] }
+	| { kind: "recoverable-stale"; lock: LockFile }
+	| { kind: "recoverable-unreadable" }
+	| { kind: "inspection-error"; message: string };
+
+interface OperationInspectionDependencies {
+	inspectMetadata(): Promise<LockInspection>;
+	inspectGuard(): Promise<boolean>;
+}
+
+const DEFAULT_INSPECTION_DEPENDENCIES: OperationInspectionDependencies = {
+	inspectMetadata: inspectLock,
+	inspectGuard: isLockGuardHeld,
+};
+
+export async function inspectOperationAvailability(
+	dependencies: OperationInspectionDependencies = DEFAULT_INSPECTION_DEPENDENCIES,
+): Promise<OperationAvailability> {
+	try {
+		const metadata = await dependencies.inspectMetadata();
+		const guardHeld = await dependencies.inspectGuard();
+		return classifyOperationAvailability(metadata, guardHeld);
+	} catch (error) {
+		return { kind: "inspection-error", message: errorMessage(error) };
+	}
+}
+
+export function classifyOperationAvailability(
+	metadata: LockInspection,
+	guardHeld: boolean,
+): OperationAvailability {
+	if (metadata.status === "valid" && !isStaleLock(metadata.lock)) {
+		return { kind: "live", lock: metadata.lock };
+	}
+	if (guardHeld) {
+		return {
+			kind: "busy",
+			metadata: metadata.status,
+			...(metadata.status === "valid" ? { lock: metadata.lock } : {}),
+		};
+	}
+	if (metadata.status === "valid") {
+		return { kind: "recoverable-stale", lock: metadata.lock };
+	}
+	if (metadata.status === "unreadable") return { kind: "recoverable-unreadable" };
+	return { kind: "free" };
+}
+
+export function operationBlocksChanges(availability: OperationAvailability) {
+	return availability.kind !== "free";
+}
+
+export function operationCanRecover(availability: OperationAvailability) {
+	return (
+		availability.kind === "recoverable-stale" || availability.kind === "recoverable-unreadable"
+	);
+}